YII2 implémente une programmation orientée aspect

Cet article vous présente l'implémentation de la programmation orientée aspect dans YII2. Les amis dans le besoin peuvent s'y référer

.

Introduction :
L'objectif du développement logiciel est d'établir un modèle de certains éléments ou flux d'informations dans le monde. L'ingénierie des systèmes logiciels nécessite de décomposer le système en. composants pouvant être créés et module de gestion. En conséquence, une technologie de programmation orientée objet avec une modularité du système a émergé. La programmation modulaire orientée objet améliore considérablement la lisibilité, la réutilisabilité et l'évolutivité des systèmes logiciels. L'objectif de l'approche orientée objet est de sélectionner l'objet comme unité principale du module et de connecter l'objet à tous les comportements du système. Les objets deviennent les principaux éléments des domaines problématiques et des processus informatiques. Cependant, la technologie orientée objet ne résout pas essentiellement la réutilisation des systèmes logiciels. Lors de la création d'un système logiciel, de nombreuses préoccupations transversales se posent dans les problèmes réels, tels que les contrôles de sécurité, la journalisation, la surveillance des performances, la gestion des exceptions, etc. Leurs codes d'implémentation sont mélangés avec d'autres codes de logique métier et dispersés dans différentes parties de le logiciel. (Ajout direct du code pour gérer ces opérations dans chaque module), cela détruit sans aucun doute le principe de « responsabilité unique » de la POO, et la réutilisabilité du module sera considérablement réduite, ce qui rend la maintenabilité et la réutilisabilité du système logiciel. affecté. Extrêmement restrictif. À l'heure actuelle, la stratégie souvent adoptée par la conception POO traditionnelle consiste à ajouter la couche proxy correspondante pour compléter les exigences fonctionnelles du système. Cependant, un tel traitement ajoute évidemment un niveau de division à l'ensemble du système, et la complexité augmente également. donnant le sentiment d'être trop lourd. Cela a donné naissance à la technologie de programmation orientée aspect (AOP). Ce modèle de programmation extrait les codes de préoccupation transversaux dispersés dans tout le système logiciel, les modularise et les regroupe, améliorant ainsi encore la maintenabilité, la réutilisabilité et l'évolutivité du logiciel.

Introduction à l'AOP :
AOP : Programmation orientée aspect.
Programmation orientée aspect (également appelée orientée aspect) : La programmation orientée aspect (AOP) est un point chaud dans le développement logiciel actuel. AOP peut être utilisé pour isoler diverses parties de la logique métier, réduisant ainsi le couplage entre les différentes parties de la logique métier, améliorant la réutilisabilité du programme et améliorant l'efficacité du développement.
AOP est la continuation de POO et est l'abréviation de (Aspect Oriented Programming), qui signifie programmation orientée aspect.
Les principales fonctions sont : la journalisation, les statistiques de performances, le contrôle de sécurité, le traitement des transactions, la gestion des exceptions, etc.
L'intention principale est de séparer la journalisation, les statistiques de performances, le contrôle de sécurité, le traitement des transactions, la gestion des exceptions et d'autres codes du code de logique métier, nous espérons les séparer en méthodes logiques métiers non directrices. puis modifiez ces comportements sans affecter le code de logique métier.
Une technologie qui peut ajouter dynamiquement et uniformément des fonctions à un programme sans modifier le code source grâce à la précompilation et aux proxys dynamiques d'exécution. AOP est en fait une continuation du modèle de conception du GoF. Le modèle de conception poursuit sans relâche le découplage entre l'appelant et l'appelé. L'AOP peut être considéré comme une réalisation de cet objectif.
Si vous considérez l'application comme une structure tridimensionnelle, le point fort de la POO est de couper le système verticalement, en divisant le système en de nombreux modules (tels que les modules utilisateur, les modules d'articles, etc.), tandis que le Le point fort d'AOP est de couper horizontalement le système. Extrayez les parties qui peuvent nécessiter des opérations répétées dans chaque module (telles que les contrôles d'autorisation, la journalisation, etc.). On peut voir que l'AOP est un complément efficace à la POO.
Remarque : AOP n'est pas une technologie, c'est en fait une idée de programmation. Toute technologie conforme à la pensée AOP peut être considérée comme la mise en œuvre de l’AOP.

Concepts de base de l'AOP :
En programmation orientée objet, classe, objet, encapsulation, héritage, polymorphisme et autres concepts C'est le terme principal décrivant la pensée orientée objet. De même, en programmation orientée aspect, on retrouve aussi quelques concepts de base :
​​JointPoint : Un point précis dans l'exécution d'un programme commun. Les points de connexion typiques incluent : l'appel d'une méthode ; la méthode exécutant le processus lui-même ; l'initialisation de l'objet de classe, etc. Les points de connexion sont l'un des concepts fondamentaux d'AOP, qui sont utilisés pour définir où dans le programme une nouvelle logique est ajoutée via AOP.
Pointcut : Un pointcut est un ensemble de points de connexion utilisés pour définir le moment où une notification doit être exécutée. En définissant des points de coupure, nous pouvons contrôler avec précision quels composants du programme reçoivent quelles notifications. Nous avons mentionné ci-dessus qu'un point de connexion typique est un appel de méthode et qu'un point d'entrée typique est une collection d'appels de méthode à une certaine classe. Habituellement, nous contrôlons le moment où les notifications sont exécutées en formant des points d'entrée complexes.
Conseil : Le code qui s'exécute à un point de connexion spécifique est appelé un « conseil ». Il existe de nombreux types de conseils, comme le
pré-conseil (avant conseil) qui est exécuté avant le point de connexion et le post-conseil (après conseil) qui est exécuté après le point de connexion.
       方面（Aspect） ：通知和切入点的组合叫做方面，所以，方面定义了一段程序中应该包括的逻辑，以及何时应该执行该逻辑。
       织入（Weaving） ：织入是将方面真正加入程序代码的过程。对于静态 AOP 方案而言，织入是在编译时完成的，通常是在编译过程中增加一个步骤。类似的，动态 AOP 方案则是在程序运行是动态织入的。
       目标（Target） ：如果一个对象的执行过程受到某一个 AOP 的修改，那么它就叫一个目标对象。目标对象通常也称为被通知对象。
       引入（Introduction） ：   通过引入，可以在一个对象中加入新的方法或属性，以改变它的结构，这样即使该对象的类没有实现某一个接口，也可以修改它，使之成为该接口的一个实现。   

       静态和动态：静态 AOP 和动态 AOP 两者之间的区别主要在于什么时间织入，以及如何织入。最早的 AOP 实现大多都是静态的。在静态 AOP 中，织入是编译过程的一个步骤。用Java 的术语说，静态 AOP 通过直接对字节码进行操作，包括修改代码和扩展类，来完成织入过程。显然，这种办法生成的程序性能很好，因为最后的结果就是普通的 Java 字节码，在运行时不再需要特别的技巧来确定什么时候应该执行通知。这种方法的缺点是，如果想对方面做什么修改，即使只是加入一个新的联结点，都必须重新编译整个程序。AspectJ 是静态 AOP 的一个典型例子。与静态 AOP 不同，动态 AOP 中织入是在运行时动态完成的。织入具体是如何完成的，各个实现有所不同。Spring AOP 采取的方法是建立代理，然后代理在适当的时候执行通知。动态 AOP 的一个弱点就在于，其性能一般不如静态 AOP。而动态AOP 的主要优点在于可以随时修改程序的所有方面，而不需重新编译目标。

AOP实践：

YII2框架本身拥有一个功能，叫做行为.它可以动态的为当前的类附加额外的功能,但这种功能在代码层级结构是静态的，有侵入性的。

下面以YII2框架集成go!aop库为例，介绍在YII2中如何实现AOP编程.（go!aop简介，可以参考go!aop的官网.）

由于YII框架拥有自己的类加载器，所在集成go!aop的时候，不能正常的工作，所以要将其禁用掉，使用composer提供的类加载器。

如下代码所示(这里使用YII2高级应用模板):

1、找到  spl_autoload_register(['Yii', 'autoload'], true, true);  (PROJECT_PATH/vendor/yiisoft/yii2/Yii.php) 将其禁用掉.

2、执行  composer require goaop/framework

3、修改composer.json文件,加入如下代码段:

 "autoload": {
        "psr-4": {
          "backend\\": "backend//",
          "frontend\\": "frontend//",
          "common\\": "common//"
        }
  }

4、 在frontend 目录下创建一个components是目录，并新建一个类AopAspectKernel，例如：

namespace frontend\components;
use frontend\aspects\MonitorAspect;
use Go\Core\AspectContainer;
use Go\Core\AspectKernel;
class AopAspectKernel extends AspectKernel
{
        protected function configureAop(AspectContainer $container)
        {
            $container->registerAspect(new MonitorAspect());
        }
}

5、在forntend目录下在新建一个类InitAopComponent,并使其实现BootstrapInterface，使其可以在YII2框架引导时被自动引导

namespace frontend\components;
use yii\base\BootstrapInterface;
class InitAopComponent implements BootstrapInterface
{
        public function bootstrap($app)
        {
            print_r(\Yii::$app->params['aop']);
            $applicationAspectKernel = AopAspectKernel::getInstance();
            $applicationAspectKernel->init(\Yii::$app->params['aop']);
        }
}

6、在frontend/config/params.php中新增如下代码：

 'aop' => [
        'debug' => true,
        'appDir' => dirname(__DIR__),
        'cacheDir' => dirname(__DIR__) . '/runtime/aop',
        'includePaths' => [
            dirname(__DIR__)
        ]
    ]

7、在frontend下面新建aspects目录，并新建类MonitorAspect，代码如下:

namespace frontend\aspects;

use Go\Aop\Aspect;
use Go\Aop\Intercept\MethodInvocation;
use Go\Lang\Annotation\Before;
class MonitorAspect implements Aspect
{
        /**
         * Method that will be called before real method
         *
         * @param MethodInvocation $invocation Invocation
         * @Before("execution(public frontend\components\AopTestComponent->*(*))")
         */
        public function beforeMethodExecution(MethodInvocation $invocation)
        {
            $obj = $invocation->getThis();
            echo 'Calling Before Interceptor for method: ',
            is_object($obj) ? get_class($obj) : $obj,
            $invocation->getMethod()->isStatic() ? '::' : '->',
            $invocation->getMethod()->getName(),
            '()',
            ' with arguments: ',
            json_encode($invocation->getArguments()),
            "<br>\n";
        }
}

9、修改frontend/config/main.php文件，并在components数组下新增一个key，代码如下:

 'components'=>[
        'aop' => [
            'class' => 'frontend\components\InitAopComponent'
        ]
    ]

10、修改frontend/config/main.php文件，并在bootstrap数组下新增aop值，代码如下:

'bootstrap'=>['log','aop']

至此，YII2整合go!aop完成...

相关推荐：

关于IIS下PHP快三平台源码的架设环境的配置过程

如何在yii2框架的di容器源码中了解反射的作用

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!