Comment utiliser l'injection de dépendances dans le framework Kajona ?

Kajona est un framework open source PHP léger qui met l'accent sur la facilité d'utilisation et l'évolutivité et fournit de nombreux outils et composants pratiques, permettant aux développeurs de créer rapidement des applications Web complexes. L'une des fonctionnalités très importantes est l'injection de dépendances (Dependency Injection), qui nous permet de gérer de manière plus flexible les dépendances entre les classes et favorise la testabilité et la maintenabilité du code.

Cet article présentera en détail l'injection de dépendances dans le framework Kajona, notamment comment définir des services (Service), comment injecter des dépendances (Dependency), comment utiliser des conteneurs (Container), etc.

1. Définir des services

Dans le framework Kajona, un service fait référence à une classe ou un objet réutilisable sur lequel s'appuient généralement plusieurs composants. Lors de la définition d'un service, vous devez fournir le nom de classe du service et les valeurs des paramètres du constructeur. Par exemple, nous pouvons définir un service nommé « UserService », qui est utilisé pour gérer les informations utilisateur et nécessite un objet de connexion à la base de données nommé « db » comme paramètre de constructeur.

Il existe deux manières de définir les services : l'une est définie dans le fichier de configuration et l'autre est définie dans le code. Ils sont présentés séparément ci-dessous.

1. Définir dans le fichier de configuration

Dans le framework Kajona, les fichiers XML sont généralement utilisés pour la configuration. Vous pouvez ajouter le code suivant au fichier de configuration pour définir un service :

<service id="UserService" class="ppservicesUserService">
   <argument type="service" id="Database"/>
</service>

où l'attribut id est le nom du service, l'attribut class est le nom de la classe correspondant au service, et l'argument La balise est utilisée pour définir les paramètres du constructeur, l'attribut type peut être "service" (faisant référence à d'autres services) ou "value" (transmettant directement les valeurs des paramètres), et l'attribut id est le nom du service référencé ou la valeur du paramètre.

Dans l'exemple ci-dessus, nous avons défini un service nommé "UserService", et la classe correspondante est "ppservicesUserService". Le constructeur nécessite un service nommé « Base de données » comme paramètre, qui représente un objet de connexion à la base de données.

2. Définir dans le code

En plus de définir des services dans les fichiers de configuration, ils peuvent également être définis via du code. Par exemple, on peut définir le service "UserService" dans le fichier "app.php" :

$app->register('UserService', function($app){
   $db = $app->make('Database');
   return new ppservicesUserService($db);
});

Dans le code ci-dessus, on appelle d'abord la fonction $app->register() pour enregistrer le service. Le premier paramètre de cette fonction est le nom du service et le deuxième paramètre est une fonction anonyme utilisée pour générer l'instance de service. Cette fonction reçoit l'objet $app en paramètre et peut appeler la méthode $app->make() pour obtenir d'autres services. Enfin, nous renvoyons un nouvel objet UserService et passons $db comme paramètre constructeur.

2. Injecter des dépendances

Dans le framework Kajona, il existe généralement deux façons d'injecter des dépendances : l'injection de constructeur et l'injection d'attributs, qui sont présentées ci-dessous.

1. Injection de constructeur

L'injection de constructeur fait référence au passage d'objets dépendants via le constructeur lors de la création d'un objet. Par exemple, nous pouvons injecter le service "Database" requis par "UserService" via le constructeur :

class UserService {
   private $db;
   public function __construct(Database $db){
      $this->db = $db;
   }
}

Dans le code ci-dessus, nous avons reçu un objet Database dans le constructeur de UserService et lui avons attribué une valeur To la variable privée $db. De cette façon, l'objet $db devient une variable membre de UserService et peut être utilisé dans d'autres méthodes de cette classe.

Lors de la création d'un objet UserService, nous devons fournir un objet Database, comme indiqué ci-dessous :

$userService = $app->make('UserService');

Le framework Kajona analysera automatiquement le constructeur de la classe UserService et transmettra Service "Base de données" pour créer un nouvel objet. Par conséquent, nous n'avons pas besoin de créer manuellement des objets de base de données, ni de nous soucier de l'ordre de création. Les dépendances sont automatiquement gérées par le framework.

2. Injection de propriété

L'injection de propriété fait référence à l'injection d'objets dépendants via la méthode Setter après la création de l'objet. Par exemple, nous pouvons définir une méthode setDatabase() dans la classe UserService pour injecter l'objet Database :

class UserService {
   private $db;
   public function setDatabase(Database $db){
      $this->db = $db;
   }
}

Lorsque nous utilisons l'injection d'attributs, nous devons d'abord créer l'objet UserService puis utiliser setDatabase() méthode pour injecter l'objet Database :

$userService = $app->make('UserService');
$userService->setDatabase($app->make('Database'));

Notez que lors de l'utilisation de l'injection d'attributs, vous devez appeler manuellement la méthode set pour injecter l'objet dépendant, sinon une erreur Null se produira lors de l'utilisation de l'objet UserService.

3. Utiliser des conteneurs

Dans le framework Kajona, le conteneur (Container) est un concept important, utilisé pour gérer les instances de service et les dépendances. Le conteneur résout automatiquement les dépendances entre les services et instancie les objets de service selon les besoins.

Dans le framework Kajona, le conteneur est accessible via l'objet $app. Par exemple, nous pouvons utiliser la méthode $app->make() pour obtenir une instance de service :

$userService = $app->make('UserService');

Cette méthode trouvera un service nommé "UserService" dans le conteneur et retournera un nouvel objet UserService .

En plus de la méthode $app->make(), il existe d'autres méthodes pour accéder au conteneur, telles que :

• $app->has( $id ), utilisé pour vérifier s'il existe un service spécifié dans le conteneur ;
• $app->get($id), utilisé pour obtenir une instance du service spécifié ;
• $app ; ->bind($ id, $concrete), utilisé pour lier une instance spécifique au service spécifié dans le conteneur.

résumé

L'injection de dépendances est un modèle de conception très important. Le mécanisme d'injection de dépendances est implémenté dans le framework Kajona, ce qui réduit considérablement le couplage entre les systèmes et améliore l'évolutivité et la testabilité du code. Cet article présente en détail comment définir des services, injecter des dépendances et utiliser des conteneurs dans le framework Kajona, dans l'espoir d'aider les développeurs.

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!