En profondeur dans les trois domaines du découplage PHP (une brève discussion sur les conteneurs de services)

Avant de lire cet article, vous devez maîtriser : Syntaxe PHP, Orienté objet

En train d'achever le développement de l'ensemble du projet logiciel, parfois plusieurs personnes sont nécessaires pour coopérer, et parfois Vous pouvez également le compléter indépendamment, quel que soit le code, à mesure que la quantité de code augmente, il devient « incontrôlable » au fur et à mesure que vous écrivez et devient progressivement « laid . interface , mise en œuvre sale", et le coût et la difficulté de maintenance du projet augmentent. , dans la mesure où il n'est pas durable, la seule option est de reconstruire ou de re-développer.

Le premier niveau

Scénario hypothétique : nous devons écrire une classe de traitement capable de faire fonctionner des sessions, des bases de données et des systèmes de fichiers en même temps. Nous pourrions écrire ceci.

Caractéristiques du domaine : il peut fonctionner, mais il est sévèrement couplé

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

Inconvénients de l'écriture :

1. Construire des objets dans des fonctions publiques, une fois que cela implique des changements tels que en tant que paramètres de base de données, la modification représentera une charge de travail énorme

2. La personne responsable de la conception de la classe Writer doit être familiarisée avec diverses API de base de données et d'autres classes

Y a-t-il un moyen de réduire l'accouplement ?

Le deuxième niveau (dépendance des paramètres)

Scénario hypothétique : l'adresse de la base de données doit être modifiée fréquemment en raison de différents clients, et de nombreuses classes appellent la base de données (s'il y en a des dizaines), en espérant que même si l'adresse de la base de données est modifiée, le code de ces classes n'aura pas besoin d'être modifié.

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

Bien que la construction de la classe DB ait été déplacée vers le client, une fois les modifications impliquées, la charge de travail est considérablement réduite, mais un nouveau problème surgit : dans Pour créer une classe Writer, nous devons d'abord créer la classe DB, la classe FileSystem, etc. Ceci est très exigeant pour la personne responsable de la classe Writer. Il doit lire de nombreux autres documents de classe et les créer un par un (. il faudra peut-être également l'initialiser) avant de pouvoir les créer avec la variable d'écriture qu'il souhaite.

Nous espérons donc avoir une meilleure façon d'écrire, afin que les personnes qui écrivent la classe Writer puissent utiliser une interface plus rapide pour créer et appeler la classe de leur choix, sans même remplir les paramètres.

Le troisième niveau (conteneur IOC)

Après les deux premiers niveaux, nous espérons ajouter les avantages suivants :

1. Hope The DB. la classe, la classe Session et la classe FileSystem sont "prêtes à l'emploi" sans initialisation fastidieuse à chaque fois, comme l'écriture d'instructions telles que $db=new DB(arg1,arg2);.

2. On espère que la base de données et les autres types d'objets sont "globaux" et peuvent être appelés à tout moment pendant toute l'exécution du programme.

3. Les programmeurs qui appellent DB et d'autres types n'ont pas besoin de connaître trop de détails sur cette classe et peuvent même utiliser un alias de chaîne pour créer un tel objet.

Ce qui peut atteindre les objectifs ci-dessus, c'est le conteneur IOC. Vous pouvez simplement considérer le conteneur IOC comme une variable globale et utiliser un tableau associatif pour lier la chaîne au constructeur.

Nous implémentons d'abord une classe de conteneur

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

Enregistrement du service (liaison)

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

Dépendances du conteneur

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!