Quale tecnica di programmazione può tagliare il codice extra generato da Dependency Injection?

1

Classe originale

class HomeController
{
    function __construct()
    {
        $this->setPhpRenderer('Module');
        $this->repository = new HomeRepository($id);
        $this->proposalService = new ProposalService($this->repository);
        $this->quickAdd = new QuickAdd($this->repository);
    }
}

/*
 * Instantiation is nice and clean:
 */
$home = new HomeController();

Utilizzo dell'iniezione delle dipendenze

class HomeController
{
    function __construct(
        PhpRenderer $renderer,
        HomeRepository $repository,
        ProposalService $proposalService,
        QuickAdd $quickAdd)
    )
    {
        $this->renderer = $renderer;
        $this->repository = $repository;
        $this->proposalService = $proposalService;
        $this->quickAdd = quickAdd;
    }
}

/*
 * Instantiate Class components
 */    
$renderer = PhpRenderer('Module');
$repository = new HomeRepository($id);
$proposalService = new ProposalService($this->repository);
$quickAdd = new QuickAdd($this->repository);

/*
 * Instantiate class - 
 */
$home = new HomeController(
            $renderer, 
            $repository,
            $proposalService, 
            $quickAdd
        );

Domanda

Sto osservando che il DI aggiunge un carico di codice di nave e voglio mantenere la mia istanziazione bella e pulita pur usando i principi dell'iniezione di dipendenza.

Un pensiero che ho avuto è invece di passare singoli componenti di classe, mettere quei componenti in un array . Questo aggiungerà ovviamente del codice extra per gestire array , ma tutti i componenti della classe saranno nascosti all'interno.

    
posta Dennis 13.10.2016 - 18:53
fonte

2 risposte

3

puoi usare i contenitori IoC per farlo. Basta scaricare tutte le dipendenze in esse (o lasciare che il contenitore IoC le scopra).

Non consiglio questo percorso perché complica il debug, complica il test delle unità e altrimenti nasconde ciò che accade quando stai solo cercando di rendere le cose più pulite (e quindi più leggibili).

Potresti usare le fabbriche di base, che prendono l'iniezione e la nascondono dietro una chiamata di fabbrica.

Generalmente non consiglio questo percorso perché è stato aggiunto il boilerplate a quello che hai già e più cose da rovinare. Inoltre, tende a rendere il tuo codice meno facilmente individuabile.

Ma in generale - non dovresti farlo neanche. Quelle poche linee aggiunte non sono tanto rumore. Rendono esplicito quello che sta succedendo. Aggiungono flessibilità per come le persone possono usare il tuo codice. Semplificano il debug del codice. Rendono il codice migliore.

    
risposta data 13.10.2016 - 19:01
fonte
0

La tecnica migliore per risolvere questo è scegliere la convenzione sulla configurazione.

I contenitori possono finire per nascondere le dipendenze in un modo misterioso. Le fabbriche possono finire per fare lo stesso, ma non è necessario.

Il cuore e l'anima della convenzione sono valori predefiniti. Il trucco è che è necessario consentire a ogni impostazione predefinita di essere sovrascritta indipendentemente. Se la tua lingua consente i parametri denominati, ottieni questo gratuitamente. Se no, hai bisogno di un codice di costruzione che lo simuli.

In Java il go to pattern per questo è il josh builder. Esiste una variazione PHP .

Onestamente, lo stile di Josh Builder porta solo a meno codice di quello che hai iniziato qui quando hai più codice che costruisce oggetti di quello che hai il codice che definisce gli oggetti.

Il tuo stile rende semplice la definizione di una classe, ma la costruzione di un dolore. Il costruttore Bloch rende la definizione di una classe un dolore, ma facile da costruire.

Entrambi offrono flessibilità, quindi è ciò che fai di più che determina ciò che ha più senso.

    
risposta data 13.10.2016 - 21:19
fonte

Leggi altre domande sui tag