Parlons de l'injection de dépendances, des conteneurs et des modèles d'apparence dans le développement de framework (Partie 1)

Cet article présente principalement l'injection de dépendances, les conteneurs et les modèles d'apparence (partie supérieure) sur le développement du framework de discussion. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

. 1. Injection de dépendance et découplage

Les hommes et les femmes amoureux disent souvent : je ne peux pas vivre sans toi Quelle profonde dépendance c'est~~

Programmation La dépendance au travail. C'est essentiellement la même chose que la dépendance dans nos vies : mon travail ne peut se faire sans votre soutien. Sans vous, il n'y aurait pas de moi.

Il existe deux types de dépendances : l'une est fonctionnelle et l'autre est séquentielle. Utilisons des exemples pour illustrer :

Nous avons maintenant une telle tâche :

Connexion utilisateur. opérations

1. Implique les opérations de base de données, la vérification des données et la sortie du modèle ;

2 Correspond respectivement à la classe Db, à la classe Validate ; Une démonstration et des exemples spécifiques doivent être complétés par les étudiants par eux-mêmes ;

Avant le codage formel, comprenons brièvement ce qu'est un client ?

1. Client : tant qu'il peut lancer une requête, il peut être considéré comme un client, un navigateur ou un morceau de code

2. Le code suivant instancie la classe User et appelle Sa méthode de connexion interne fonctionne

3 Par conséquent, $user = new User(); est le code client

4 Ou, cela peut aussi être compris de cette façon, tout ce qui est écrit dans un. classe ou fonction Autre que le code, il peut être considéré comme le client

Le code source est le suivant :

Bien que le code ci-dessus puisse fonctionner normalement, il contient toujours les éléments suivants problèmes :

<?php 
//数据库操作类
class Db
{
//数据库连接
public function connect()
{
return &#39;数据库连接成功<br>&#39;;
}
}
//数据验证类
class Validate
{
//数据验证
public function check()
{
return &#39;数据验证成功<br>&#39;;
}
}
//视图图
class View
{
//内容输出
public function display()
{
return &#39;用户登录成功&#39;;
}
}
//用户类
class User
{
//用户登录操作
public function login()
{
//实例化Db类并调用connect()连接数据库
$db = new Db();
echo $db->connect();
//实例化Validate类并调用check()进行数据验证
$validate = new Validate();
echo $validate->check();
//实例化视图类并调用display()显示运行结果
$view = new View();
echo $view->display();
}
}
//创建User类
$user = new User();
//调用User对象的login方法进行登录操作
echo $user->login();

1 . Parmi les quatre classes ci-dessus, seule User est la classe de travail réelle et les trois autres sont des classes d'outils (Db, Validate, View)

2. appelé dans les changements de classe de travail, tous les codes de référence correspondants de ces classes d'outils, tels que les changements de paramètres Db

3 L'appelant de la classe de travail doit être très familier avec toutes les classes d'outils à utiliser, et. doit comprendre les paramètres et les valeurs de retour

4. La classe de travail a formé une dépendance sérieuse à l'égard des trois classes d'outils ci-dessus, ce qui est également appelé couplage sérieux entre les classes

Ci-dessous, nous utilisons le plus couramment. utilisé l'injection de dépendances (DI) pour découpler le couplage

Comprenons d'abord l'idée de base du découplage :

1 L'injection de dépendances n'est pas divine

2 En substance. , l'instanciation des classes d'outils n'est pas terminée dans la classe de travail, mais elle est en dehors de la classe de travail, c'est-à-dire qu'elle est terminée sur le client

3 puisque l'instanciation de la classe d'outils est terminée sur le client. client, il est dans la classe de travail, et il doit y avoir un récepteur pour enregistrer l'objet outil instancié

4 A ce moment, l'utilisateur peut directement transmettre l'objet outil qui a été instancié sur le client au client. méthode de la classe ouvrière sous forme de paramètres

5. Ce genre d'objet direct de l'extérieur La méthode de passage dans la classe ouvrière actuelle est appelée injection de dépendances

Le code source est comme suit :

Bien que l'instanciation de la classe dépendante soit avancée vers le client, elle résout le problème entre les classes Problèmes de dépendance

<?php
//数据库操作类
class Db
{
//数据库连接
public function connect()
{
return &#39;数据库连接成功<br>&#39;;
}
}
//数据验证类
class Validate
{
//数据验证
public function check()
{
return &#39;数据验证成功<br>&#39;;
}
}
//视图图
class View
{
//内容输出
public function display()
{
return &#39;用户登录成功&#39;;
}
}
//用户类
class User
{
//创建三个成员属性,用来保存本类所依赖的对象
protected $db = null;
protected $validate = null;
protected $view = &#39;&#39;;
//用户登录操作
public function login(Db $db, Validate $validate, View $view)
{
//实例化Db类并调用connect()连接数据库
// $db = new Db();
echo $db->connect();
//实例化Validate类并调用check()进行数据验证
// $validate = new Validate();
echo $validate->check();
//实例化视图类并调用display()显示运行结果
// $view = new View();
echo $view->display();
}
}
//在客户端完成工具类的实例化(即工具类实例化前移)
$db = new Db();
$validate = new Validate();
$view = new View();
//创建User类
$user = new User();
//调用User对象的login方法进行登录操作
// echo $user->login();
// 将该类依赖的外部对象以参数方式注入到当前方法中,当然,推荐以构造器方式注入最方便
echo &#39;<h3>用依赖注入进行解藕:</h3>&#39;;
echo $user->login($db, $validate, $view);

Mais il reste toujours les problèmes suivants :

1. Afin de faire de l'utilisateur de la classe ouvrière un outil normal, toutes les classes requises doivent être instanciées en externe à l'avance ;

Tant que l'instanciation est impliquée, le client (appelant) doit avoir un. bonne compréhension des détails de ces classes dépendantes, tels que les paramètres et les valeurs de retour

L'utilisateur peut-il être autorisé à instancier la classe dépendante ? Ne serait-ce pas mieux et plus simple ?

Quand on appelle une classe dépendante externe, on a seulement besoin de donner un nom de classe et une méthode (constructeur) pour créer une instance de la classe ?

C'est à dire : on donne seulement : la classe le nom, la méthode de création d'une instance de classe, et rien d'autre

Ci-dessous, nous utilisons la "technologie des conteneurs" pour implémenter ce processus de découplage insensé

Ce qui précède est tout le contenu de cet article .J'espère que cela sera utile à l'étude de tout le monde. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Parlons de l'injection de dépendances, des conteneurs et des modèles d'apparence dans le développement de frameworks (Partie 2)

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!