Analyse der drei Bereiche der PHP-Entkopplung (eine kurze Diskussion von Service-Containern)

Analyse der drei Bereiche der PHP-Entkopplung (eine kurze Diskussion von ServicesContainern)

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

Beim Abschluss der Entwicklung des gesamten Softwareprojekts ist manchmal die Zusammenarbeit mehrerer Personen erforderlich, und manchmal kann es unabhängig voneinander abgeschlossen werden Das heißt, mit zunehmender Codemenge gerät es nach und nach zu einer „hässlichenSchnittstelle, schmutzigen Implementierung“, die Kosten und die Schwierigkeit der Projektwartung stiegen bis zu einem Punkt, an dem sie nicht mehr tragbar war Die einzige Option war Wiederaufbau oder Sanierung.

Die erste Ebene

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

Realm-Funktionen: Kann laufen, aber 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 beim Schreiben:

1 DomäneObjekte in Funktionen erstellen Sobald Änderungen an Datenbankparametern erforderlich sind, erfordern Änderungen viel Arbeit

2. Die für den Entwurf der Writer-Klasse verantwortliche Person muss verschiedene Aufgaben in der Datenbank ausführen und andere KlassenAPISeien Sie damit vertraut

Gibt es eine Möglichkeit, die Kopplung zu reduzieren?

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, wird der Arbeitsaufwand durch die damit verbundenen Änderungen erheblich reduziert, es entsteht jedoch ein neues Problem Es entsteht: Um eine Writer-Klasse zu erstellen, müssen wir zunächst die DB-Klasse, die FileSystem-Klasse usw. erstellen. Dies stellt eine große Herausforderung für den Verantwortlichen der Writer-Klasse dar. Er muss viele andere Klassendokumente lesen und erstellen eine nach der anderen (muss möglicherweise auch initialisiert werden). Dann kann er die gewünschte Writer Variable erstellen.

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. Ich hoffe, dass die DB-Klasse, die Session-Klasse und die FileSystem-Klasse „out of the box“ verwendet werden können, ohne dass jedes Mal eine mühsame 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 allzu viele Details dieser Klasse kennen und können sogar einen Alias ​​einer Zeichenfolge 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 das zugehörige -Array verwenden, um die Zeichenfolge an den -Konstruktor zu binden Auf jeden Fall.

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 (verbindlich)

$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 vonAnalyse der drei Bereiche der PHP-Entkopplung (eine kurze Diskussion von Service-Containern). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!