Wykonywanie tej klasy są zgodne z zasadą Dependency Inversion

Question

Definicja DI cytowany z Wikipedii stwierdza:

A. moduły wysokiego szczebla nie powinno zależeć od modułów niskopoziomowych. Obie powinny zależeć od abstrakcji. B. Abstrakcje nie powinny zależeć od szczegółów. Szczegóły powinny zależeć od abstrakcji.

Próbuję zastosować tę zasadę do mojego kodu:

class Printer{ 
     private $logger;  
     function __construct(Zend_Log $logger){ 
      $this->logger=$logger; 
     }  
     function print(){ 
      //Some code 
      $this->logger->log('Logger in action ;)'); 
     }   
    } 

Teraz ponieważ dlaczego Printer klasa zależy Zend_Log który nie jest ani klasa abstrakcyjna ani interfejsu potem mam naruszenie Dependency Inversion zasada.

Jak mogę to naprawić, wiedząc, że Zend_Log nie rozszerza klasy abstrakcyjnej ani nie implementuje interfejsu?

Answer 1

Najprostszym sposobem byłoby użycie adaptera interfejsu, np. utworzyć interfejs API, którego powinna używać drukarka w interfejsie, a następnie zaimplementować ten interfejs w adapterze dla składnika Zend_Log. Przełóż betonowy łącznik do drukarki. Drukarka będzie wówczas zależeć od PrinterLog, a nie od konkretnego Zend_Loga.

interface PrinterLog 
{ 
    public function log($whatever); 
} 

class ZendPrinterLogAdapter implements PrinterLog 
{ 
    private $logger; 

    public function __construct(Zend_Log $logger) 
    { 
     $this->logger = $logger 
    } 

    public function log($whatever) 
    { 
     // delegate call to $this->logger 
    } 
} 

class Printer 
{ 
    private $logger; 

    function __construct(PrinterLog $logger) 
    { 
     $this->logger = $logger; 
    } 
} 

$printer = new Printer(new ZendPrinterLogAdapter(new Zend_Log)); 

Answer 2

Oto nieco alternatywa spojrzenie na samego API .. więc to byłoby Ci standardowy setup:

interface Printerish // couldn't think of a good ajective 
{ 
    public function print(); 
} 

interface CanLogStuff // couldn't think of a good ajective 
{ 
    public function log($text); 
} 


class Printer implements Printerish 
{ 
    public function print() 
    { 
     // do something 
    } 
} 

I to byłoby loggable drukarka:

class LoggedPrinter implements Printerish 
{ 
    protected $logger; 
    protected $pritner; 

    public function __construct(Printerish $printer, CanLogStuff $logger) 
    { 
     $this->logger = $logger; 
     $this->printer = $printer; 
    } 

    protected function print() 
    { 
     $this->logger('I can print, I can print !!'); 
     $this->printer->print(); 
    } 

} 

Gdzie ten pochodzi z jest następujący przypadek użycia: jeśli w rzeczywistości chcesz zacząć kontrolować korzystanie z prawdziwej drukarki (stażysta znowu był printing out the internet). Wtedy nie zrobiłbyś innej drukarki. Próbowałbyś dodać kontrolę zewnętrzną.

Programowanie to rodzaj związany z Open/closed principle.

Należy pamiętać, że jest to tylko jeden z pomysłów i należy się temu przyjrzeć przed próbą użycia w kodzie produkcyjnym.