machen diese Klasse mit dem Prinzip Inversion Abhängigkeit erfüllt

Question

Die Definition von DI aus Wikipedia zitiert heißt es:

A. High-level-Module nicht auf Low-Level-Module abhängen. Beide sollten von Abstraktionen abhängen. B. Abstraktionen sollten nicht von Details abhängen. Details sollten von Abstraktionen abhängen.

Ich versuche, diesen Grundsatz zu meinen Code anwenden:

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

Da nun, warum hängt Printer Klasse auf Zend_Log die weder eine abstrakte Klasse ist noch eine Schnittstelle dann bin ich zu verletzen die Abhängigkeit Inversion Prinzip.

Wie kann ich das beheben, wissend, dass Zend_Log keine abstrakte Klasse erweitert noch eine Schnittstelle implementieren?

Answer 1

Der einfachste Ansatz wäre die Verwendung eines Schnittstellenadapters, z. Erstelle die API, die dein Drucker in einer Schnittstelle verwenden soll und implementiere diese Schnittstelle in einen Adapter für die Zend_Log-Komponente. Übergeben Sie den Betonadapter an den Drucker. Der Drucker hängt dann vom PrinterLog und nicht vom konkreten Zend_Log ab. Hier

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

ist etwas alternative Einstellung auf gleiche API .. so würde dies Sie Standard-Setup sein:

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 
    } 
} 

Und dies wäre speicherbare Drucker:

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(); 
    } 

} 

Wo diese kommen aus ist der folgende Anwendungsfall: Wenn Sie in der realen Welt anfangen wollen, die Verwendung eines echten Druckers zu steuern (intern war wieder printing out the internet). Dann würdest du keinen anderen Drucker machen. Sie würden versuchen, eine externe Kontrolle hinzuzufügen.

Bei der Programmierung bezieht es sich irgendwie auf Open/closed principle.

Denken Sie daran, dass dies nur eine Idee ist, und Sie sollten sich das genau ansehen, bevor Sie versuchen, es im Produktionscode zu verwenden.