Tiefer Einblick in die drei Bereiche der PHP-Entkopplung (eine kurze Diskussion über Service-Container)

Bevor Sie diesen Artikel lesen, müssen Sie Folgendes beherrschen: PHP-Syntax, Objektorientiert

Während des Abschlusses der Entwicklung des gesamten Softwareprojekts Manchmal müssen mehrere Personen zusammenarbeiten, und manchmal können Sie es auch unabhängig voneinander abschließen. Mit zunehmender Codemenge gerät es „außer Kontrolle“ und wird allmählich zu einer „hässlichen Schnittstelle , schmutzige Implementierung“, und die Kosten und der Schwierigkeitsgrad der Projektwartung steigen. Sobald es nicht nachhaltig ist, besteht die einzige Option darin, es zu rekonstruieren oder neu zu entwickeln.

Die erste Ebene

Hypothetisches Szenario: Wir müssen eine Verarbeitungsklasse schreiben, die gleichzeitig Sitzungen, Datenbanken und Dateisysteme betreiben kann. Wir könnten das schreiben.

Realm-Eigenschaften: Es kann ausgeführt werden, ist jedoch stark gekoppelt.

class DB{
	public function DB($arg1,$arg2){
		echo 'constructed!'.PHP_EOL;
	}
}

class FileSystem{
	public function FileSystem($arg1,$arg2){
		echo 'constructed!'.PHP_EOL;
	}
}

class Session{
	public function Session($arg1,$arg2){
		echo 'constructed!'.PHP_EOL;
	}
}

class Writer{
	public function Write(){
		$db=new DB(1,2);
		$filesystem=new FileSystem(3,4);
		$session=new Session(5,6);
	}
}

$writer=new Writer();
$writer->write();

Nachteile des Schreibens:

1. Objekte in öffentlichen Funktionen konstruieren, sobald Änderungen erforderlich sind Als Datenbankparameter wird die Änderung eine enorme Arbeitsbelastung darstellen

2. Die für das Design der Writer-Klasse verantwortliche Person muss mit verschiedenen APIs von DB und anderen Klassen vertraut sein

Gibt es eine Möglichkeit, dies zu reduzieren? die Kupplung?

Die zweite Ebene (Parameterabhängigkeit)

Hypothetisches Szenario: Die Datenbankadresse muss aufgrund unterschiedlicher Kunden häufig geändert werden, und es gibt viele Klassen, die die Datenbank aufrufen (Wenn es Dutzende gibt), in der Hoffnung, dass der Code dieser Klassen auch dann nicht geändert werden muss, wenn die Datenbankadresse geändert wird.

class DB{
	public function DB($arg1,$arg2){
		echo 'constructed!'.PHP_EOL;
	}
}

class FileSystem{
	public function FileSystem($arg1,$arg2){
		echo 'constructed!'.PHP_EOL;
	}
}

class Session{
	public function Session($arg1,$arg2){
		echo 'constructed!'.PHP_EOL;
	}
}

class Writer{
	protected $_db;
	protected $_filesystem;
	protected $_session;
	public function Set($db,$filesystem,$session){
		$this->_db=$db;
		$this->_filesystem=$filesystem;
		$this->_session=$session;
	}
	public function Write(){
		
	}
}

$db=new DB(1,2);
$filesystem=new FileSystem(3,4);
$session=new Session(5,6);

$writer=new Writer();
$writer->Set($db,$filesystem,$session);
$writer->write();

Obwohl die Konstruktion der DB-Klasse auf den Client verlagert wurde, verringert sich der Arbeitsaufwand, sobald Änderungen erforderlich sind, erheblich, es entsteht jedoch ein neues Problem: in Um eine Writer-Klasse zu erstellen, müssen wir zuerst die DB-Klasse, die FileSystem-Klasse usw. erstellen. Dies ist eine große Herausforderung für die Person, die für die Writer-Klasse verantwortlich ist. Er muss viele andere Klassendokumente lesen und einzeln erstellen. müssen möglicherweise auch initialisiert werden), bevor er sie aus der gewünschten Writer-Variable erstellen kann.

Wir hoffen also, eine bessere Schreibweise zu haben, damit Leute, die die Writer-Klasse schreiben, eine schnellere Schnittstelle verwenden können, um die gewünschte Klasse zu erstellen und aufzurufen, ohne die Parameter einzugeben.

Die dritte Ebene (IOC-Container)

Nach den ersten beiden Ebenen hoffen wir, die folgenden Vorteile hinzuzufügen:

1 Die Klassen, Session-Klassen und FileSystem-Klassen sind jedes Mal „einsatzbereit“, ohne dass eine langwierige Initialisierung erforderlich ist, z. B. das Schreiben von Anweisungen wie $db=new DB(arg1,arg2);.

2. Es wird erwartet, dass DB und andere Objekttypen „global“ sind und jederzeit während der gesamten Programmausführung aufgerufen werden können.

3. Programmierer, die DB und andere Typen aufrufen, müssen nicht zu viele Details dieser Klasse kennen und können sogar einen String-Alias ​​verwenden, um ein solches Objekt zu erstellen.

Was die oben genannten Ziele erreichen kann, ist der IOC-Container. Sie können den IOC-Container einfach als globale Variable betrachten und ein assoziatives Array verwenden, um die Zeichenfolge an den Konstruktor zu binden.

Wir implementieren zunächst eine Containerklasse

class Container{
	public $bindings;
	public function bind($abstract,$concrete){
		$this->bindings[$abstract]=$concrete;
	}
	public function make($abstract,$parameters=[]){
		return call_user_func_array($this->bindings[$abstract],$parameters);
	}
}

Dienstregistrierung (Bindung)

$container=new Container();
$container->bind('db',function($arg1,$arg2){
	return new DB($arg1,$arg2);
});

$container->bind('session',function($arg1,$arg2){
	return new Session($arg1,$arg2);
});

$container->bind('fs',function($arg1,$arg2){
	return new FileSystem($arg1,$arg2);
});

Containerabhängigkeiten

class Writer{
	protected $_db;
	protected $_filesystem;
	protected $_session;
	protected $container;
	public function Writer(Container $container){
		$this->_db=$container->make('db',[1,2]);
		$this->_filesystem=$container->make('session',[3,4]);
		$this->_session=$container->make('fs',[5,6]);
	}
}

$writer=new Writer($container);

Das obige ist der detaillierte Inhalt vonTiefer Einblick in die drei Bereiche der PHP-Entkopplung (eine kurze Diskussion über Service-Container). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!