Exemple de code du triple domaine du découplage PHP (une brève discussion sur les conteneurs de services)

Cet article présente principalement les connaissances pertinentes des trois domaines du découplage PHP (une brève discussion sur les conteneurs de services). A une très bonne valeur de référence. Jetons un coup d'oeil avec l'éditeur ci-dessous

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

Dans le processus de développement complet du projet logiciel, cela nécessite parfois la coopération de plusieurs personnes, et parfois cela peut être réalisé indépendamment, quelle que soit la manière dont il s'effectue, ainsi que la quantité de code. augmente, il deviendra « hors de contrôle » au fur et à mesure que le code est écrit. Peu à peu, « des interfaces laides, des implémentations sales » ont progressivement augmenté le coût et la difficulté de la maintenance du projet, atteignant le point où elle n'est plus viable et où la seule option est de refactoriser. ou à réaménager.

Le premier niveau

Scénario hypothétique : nous devons écrire une classe de traitement qui peut 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 royaume : 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 d'écriture :

1. Construire un objet dans une fonction publique Une fois qu'il implique des changements dans les paramètres de la base de données, les modifications nécessiteront beaucoup de travail

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

. Y a-t-il un moyen de réduire le couplage ?

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, appelant la classe DB Il y en a beaucoup (s'il y en a des dizaines), et j'espère 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. Sortez 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. J'espère que la classe DB, la classe Session et la classe FileSystem pourront être utilisées « prêtes à l'emploi » sans initialisation fastidieuse à chaque fois, comme écrire $db=new. DB(arg1, arg2);Ce type d'instruction.

2. On espère que la base de données et d'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 string 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 le

tableau associé pour construire la chaîne. et Function effectue la liaison.

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

$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

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!