"Proprietà contenitore" definizione del modello di progettazione approfondita

Un Property Container è una classe le cui proprietà possono essere personalizzate in fase di runtime senza dover modificare la definizione della classe.

Questo articolo ha l'unico completo esempio che ho potuto trovare. In esso, usano l'esempio di una classe Movie personalizzabile.

La classe base PropertyContainer fornisce metodi per aggiungere / rimuovere / recuperare proprietà memorizzate nella classe. Fondamentalmente, si comporta molto come HashMap :

PropertyContainer:
   + addPropertyBy()
   + removeProperty()
   + getPropertyBy()
   + getPropertyKeys()

Quindi hai una classe Movie che eredita da PropertyContainer :

Movie extends PropertyContainer:
   - rating
   - available
   - description
   - title
   - id
   - price

   + [getters and setters for private properties]

Successivamente, se devi aggiungere releasedate come proprietà alla classe Movie in un progetto, hai la possibilità di aggiungerlo in fase di esecuzione anziché aggiornare la tua classe.

Movie m = new Movie()
m.addPropertyBy("3/5/14", "releasedate")

Nella mia esperienza, ho visto questo applicato come memoria generica su un oggetto.

Un oggetto ha una relazione con altri oggetti "proprietà" che sono memorizzati in una tabella hash o in un elenco, oppure un oggetto ha semplicemente un hash interno che associa chiavi ai valori.

Ciò consente di aggiungere dati in fase di runtime che non sono stati considerati in fase di progettazione. Questo può essere veramente buono o molto cattivo.

Bene: un oggetto è progettato per essere estensibile, forse contenente dati arbitrari definiti da clienti o utenti. Se questo è il suo scopo nella vita, questo può essere potente.

Cattivo: un oggetto può assumere preoccupazioni che non dovrebbe. Lo spazio extra può incoraggiare l'uso di vari anti-pattern relativi allo stato dell'oggetto e alle responsabilità.

Esempio Java:

import java.util.*;

public class Example {
  private Map<String, Object> properties = new HashMap<>();

  public void setProperty(String key, Object value) {
    properties.put(key, value);
  }

  public Object getProperty(String key) {
    return properties.get(key);
  }

  // Might also want to expose other methods such as containsKey() or clear().
}

La spiegazione più semplice è "A Service locator for properties" o più breve "Data locator".

Ed è anche un antipattern dal punto di vista OOP in quanto rompe il suo concetto principale - Incapsulamento e riduce la sicurezza del tipo, quando la tendenza dello sviluppo moderno è esattamente l'opposto: dalla digitazione debole al strong (es. JavaScript - > TypeScript).

In termini di programmazione funzionale è persino peggio come costruzione mutabile in sostanza.

Ma per la programmazione procedurale è il modo di implementare la piattaforma estensibile.

Ho scritto la mia implementazione PHP per il modello di progettazione "Property Container". ( link )

Assicurati di controllare i suggerimenti suggeriti anche nel post "risposta".