YII2 implementiert aspektorientierte Programmierung

Dieser Artikel stellt Ihnen die Implementierung der aspektorientierten Programmierung in YII2 vor. Freunde in Not können sich darauf beziehen

Einführung:
Das Ziel der Softwareentwicklung besteht darin, ein Modell einiger Elemente oder Informationsflüsse in der Welt zu erstellen. Die Entwicklung von Softwaresystemen erfordert die Zerlegung des Systems Komponenten, die erstellt werden können, und Verwaltungsmodul. Als Ergebnis entstand eine objektorientierte Programmiertechnologie mit Systemmodularität. Modulare objektorientierte Programmierung verbessert die Lesbarkeit, Wiederverwendbarkeit und Skalierbarkeit von Softwaresystemen erheblich. Der Schwerpunkt des objektorientierten Ansatzes besteht darin, das Objekt als Haupteinheit des Moduls auszuwählen und das Objekt mit allen Verhaltensweisen des Systems zu verbinden. Objekte werden zu Hauptelementen von Problembereichen und Rechenprozessen. Allerdings löst die objektorientierte Technologie nicht grundsätzlich die Wiederverwendbarkeit von Softwaresystemen. Beim Erstellen eines Softwaresystems gibt es viele übergreifende Probleme bei realen Problemen, wie z. B. Sicherheitsüberprüfungen, Protokollierung, Leistungsüberwachung, Ausnahmebehandlung usw. Ihre Implementierungscodes werden mit anderen Geschäftslogikcodes gemischt und auf verschiedene Teile verteilt (Durch das direkte Hinzufügen des Codes zur Abwicklung dieser Vorgänge in jedes Modul wird das Prinzip der „Einzelverantwortung“ von OOP zerstört, und die Wiederverwendbarkeit des Moduls wird erheblich verringert, was die Wartbarkeit und Wiederverwendbarkeit des Softwaresystems beeinträchtigt Äußerst restriktiv. Derzeit besteht die Strategie des traditionellen OOP-Designs häufig darin, die entsprechende Proxy-Schicht hinzuzufügen, um die funktionalen Anforderungen des Systems zu erfüllen. Eine solche Verarbeitung führt jedoch offensichtlich zu einer Aufteilung des Gesamtsystems und erhöht somit auch die Komplexität Gibt das Gefühl, zu schwer zu sein. Daraus entstand die Technologie der aspektorientierten Programmierung (AOP). Dieses Programmiermodell extrahiert über das Softwaresystem verstreute übergreifende Problemcodes, modularisiert sie und organisiert sie zusammen, was die Wartbarkeit, Wiederverwendbarkeit und Skalierbarkeit der Software weiter verbessert.

AOP-Einführung:
AOP: Aspektorientierte Programmierung.
Aspektorientierte Programmierung (auch aspektorientiert genannt): Aspektorientierte Programmierung (AOP) ist ein Hotspot in der aktuellen Softwareentwicklung. AOP kann verwendet werden, um verschiedene Teile der Geschäftslogik zu isolieren, wodurch die Kopplung zwischen den verschiedenen Teilen der Geschäftslogik verringert, die Wiederverwendbarkeit des Programms verbessert und die Effizienz der Entwicklung verbessert wird.
AOP ist die Fortsetzung von OOP und die Abkürzung für (Aspect Oriented Programming), was aspektorientierte Programmierung bedeutet.
Die Hauptfunktionen sind: Protokollierung, Leistungsstatistiken, Sicherheitskontrolle, Transaktionsverarbeitung, Ausnahmebehandlung usw.
Die Hauptabsicht besteht darin, Protokollierung, Leistungsstatistiken, Sicherheitskontrolle, Transaktionsverarbeitung, Ausnahmebehandlung und andere Codes vom Geschäftslogikcode zu trennen. Durch die Trennung dieser Verhaltensweisen hoffen wir, sie von nicht leitenden Geschäftslogikmethoden unabhängig zu machen. und dann diese Verhaltensweisen ändern, ohne den Geschäftslogikcode zu beeinträchtigen.
Eine Technologie, die einem Programm dynamisch und einheitlich Funktionen hinzufügen kann, ohne den Quellcode durch Vorkompilierung und dynamische Laufzeit-Proxys zu ändern. AOP ist eigentlich eine Fortsetzung des GoF-Entwurfsmusters. Das Entwurfsmuster verfolgt unermüdlich die Entkopplung zwischen dem Anrufer und dem Angerufenen. Man kann sagen, dass AOP eine Verwirklichung dieses Ziels darstellt.
Wenn Sie sich die Anwendung als dreidimensionale Struktur vorstellen, besteht die scharfe Kante von OOP darin, vertikal in das System einzuschneiden und das System in viele Module (z. B. Benutzermodule, Artikelmodule usw.) zu unterteilen Die scharfe Kante von AOP besteht darin, Teile horizontal in das System zu schneiden, die möglicherweise wiederholte Vorgänge in jedem Modul erfordern (z. B. Berechtigungsprüfungen, Protokollierung usw.). Es zeigt sich, dass AOP eine wirksame Ergänzung zu OOP darstellt.
Hinweis: AOP ist keine Technologie, sondern eine Programmieridee. Jede Technologie, die dem AOP-Denken entspricht, kann als Implementierung von AOP betrachtet werden.

Grundkonzepte von AOP:
In der objektorientierten Programmierung Klasse, Objekt, Kapselung, Vererbung, Polymorphismus und andere Konzepte Es ist der Hauptbegriff, der objektorientiertes Denken beschreibt. In ähnlicher Weise gibt es auch in der aspektorientierten Programmierung einige grundlegende Konzepte:
​​JointPoint: Ein bestimmter Punkt in der Ausführung eines gemeinsamen Programms. Typische Verbindungspunkte sind: Aufrufen einer Methode; Initialisierung des Prozesses selbst; Verbindungspunkte sind eines der Kernkonzepte von AOP, mit denen definiert wird, wo im Programm neue Logik durch AOP hinzugefügt wird.
Pointcut: Ein Pointcut ist eine Reihe von Verbindungspunkten, die verwendet werden, um zu definieren, wann eine Benachrichtigung ausgeführt werden soll. Durch die Definition von Pointcuts können wir genau steuern, welche Komponenten im Programm welche Benachrichtigungen erhalten. Wir haben oben erwähnt, dass ein typischer Verbindungspunkt ein Methodenaufruf ist und ein typischer Einstiegspunkt eine Sammlung von Methodenaufrufen für eine bestimmte Klasse ist. Normalerweise steuern wir, wann Benachrichtigungen ausgeführt werden, indem wir komplexe Einstiegspunkte bilden.
Hinweis: Der Code, der an einem bestimmten Verbindungspunkt ausgeführt wird, wird als „Hinweis“ bezeichnet. Es gibt viele Arten von Ratschlägen, wie zum Beispiel
Pre-Advice (Before-Advice), der vor dem Verbindungspunkt ausgeführt wird, und Post-Advice (After-Advice), der nach dem Verbindungspunkt ausgeführt wird.
       方面（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容器源码中了解反射的作用

Das obige ist der detaillierte Inhalt vonYII2 implementiert aspektorientierte Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!