Come progettare il mio codice in modo che possa utilizzare informazioni alternative per aiutare a creare un oggetto

Mi piacerebbe sviluppare la soluzione che @TMN sta presentando e prenderla un po 'oltre per rispondere al tuo problema SRP. Inserire il codice del database all'interno di ProductFactory non sarebbe sensato quindi per incapsulare questa responsabilità è possibile creare una classe separata ProductModelNumberProvider con un solo metodo findByProductId(int productId) .

Il ProductFactory dovrebbe fornire un setter setProductModelNumberProvider(ProductModelNumberProvider lookupProvider) che assegnerà il provider internamente e chiamerà findByProductId() quando appropriato.

Avrai un ProductFactory responsabile della creazione del prodotto e un ProductModelNumberProvider che eseguirà l'interazione del database, se necessario.

Avere un'occhiata alla tua domanda StackOverflow per un esempio più concreto.

Forse crei un ProductFactory , con metodi per creare un Product dato un numero di ruote e un ID prodotto o un numero di modello. Dato un numero di modello, si rimette al costruttore della classe e, se viene fornito un ID prodotto, esegue la ricerca DB, ottiene il numero del modello, quindi rimanda al costruttore della classe.

Non vuoi duplicare la mappatura del DB product_id -> model_number codificando la logica, questo ha senso. Quindi la prima cosa di cui hai bisogno è una funzione come

int mapProductIdToModelNumber(int product_id)

che esegue questa mappatura ottenendo le informazioni dal database (prendere in considerazione la memorizzazione nella cache quando questa funzione viene utilizzata molto spesso).

Ciò che rimane è come rendere questa funzione disponibile per la tua classe Product senza accoppiamento stretto. Hai le seguenti alternative:

• passa la funzione direttamente ai blocchi di codice ogni volta che viene creato Product oggetti (dipende dal tuo linguaggio di programmazione come farlo)

• implementa la funzione in una classe ProductFactory . Ricava ProductFactory da un'interfaccia IProductFactory e passa un oggetto di questo tipo alle aree di codice in cui al momento desideri un new Product() . Utilizza la fabbrica come suggerito da @ TMN.

In questo modo, il tuo codice legacy rimane disaccoppiato dal database, poiché non dipenderà direttamente da un ProductFactory legato al database, solo da IProductFactory , che può essere facilmente deriso (ad esempio, a scopo di test ).

Forse questo - rinuncia all'idea di una classe Product e crea un wrapper DB dove dirò $pf = ProductFinder() , poi fai $pf->findById() e $pf->findByModel() se necessario. Problema: dove inserisco il mio codice calcolo ? Non può essere nello stesso posto, in quanto viola il Principio di Responsabilità Singola. alias, il calcolo e la gestione dei dati dovrebbero essere separati. Quindi forse Product class può essere la parte computazionale e ProductFinder essere la parte di estrazione del database.

Quello che ho finito per fare:

All'inizio mi stavo chiedendo se sto meglio con una tale complessità.

Il modo più semplice era:

C'è un altro schema qui che potrei usare che mantiene le cose in una classe: link . Breaks SRP.

$product = Product::fromProductId($productId, $wheels);

Modo SRP (scelto)

• ProductData class che ha solo i dati (può essere scambiato dal database più tardi)
• ProductFactory class che utilizza la classe Provider per cercare il numero di modello
• ProductNumberProvider class che fornisce il numero del modello quando viene fornito l'id prodotto
• Product class che carica i dati del prodotto e calcola i calcoli

Codice:

$provider = new ProductModelNumberProvider();
$factory = new ProductFactory($provider);
$product = $factory->constructFromProductId($productId, $wheels);