php aop下载php aop源代码下载

php aop

其他源码

Release 1.2.15

下载

php aop

PHP AOP是一个PHP库，为PHP提供了有力的方面编程（AOP）实现。

安装

composer require okapi/aop

用法

目录列表

术语
隐性方面
- 创建一个内核
- 创建一个方面
- 目标类
- 初始化内核
- 结果
班级的明确方面
- 创建一个方面
- 目标类
- 初始化内核
- 结果
方法级的显式方面
- 创建一个方面
- 目标类
- 初始化内核
- 结果
特征
限制
它如何工作
测试
贡献

术语

AOP ：面向方面的编程 - 一种编程范式，旨在通过允许分离交叉切割问题来增加模块化。
方面：一个实现您要应用于目标类的逻辑的类。必须用#[Aspect]属性注释方面。
建议：要应用于目标课程的逻辑。建议方法必须用#[Before] ， #[Around]或#[After]属性注释。
加入点：执行目标课程的点，您可以在其中应用建议。联接点由#[Before] ， #[Around]或#[After]属性定义。
尖端：一组连接点，您可以在其中应用建议。点数由#[Pointcut]属性定义。
编织：将建议应用于目标课程的过程。
隐式方面：这些方面是应用的，而无需对目标类别进行任何修改。该方面本身指定了其适用的类或方法。
类级别的显式方面：通过修改目标类，通常通过将方面作为目标类的属性来应用这些方面。
方法级别的显式方面：通过修改目标类，通常通过将方面作为目标方法属性来应用这些方面。

隐性方面

单击以展开

创建一个内核

 <?php

use Okapi  Aop  AopKernel ;

// Extend from the "AopKernel" class
class MyKernel extends AopKernel
{
    // Define a list of aspects
    protected array $ aspects = [
        DiscountAspect ::class,
        PaymentProcessorAspect ::class,
    ];   
}

创建一个方面

 // Discount Aspect

<?php

use Okapi  Aop  Attributes  Aspect ;
use Okapi  Aop  Attributes  After ;
use Okapi  Aop  Invocation  AfterMethodInvocation ;

// Aspects must be annotated with the "Aspect" attribute
#[ Aspect ]
class DiscountAspect
{
    // Annotate the methods that you want to intercept with
    // "Before", "Around" or "After" attributes
    #[ After (
        // Use named arguments
        // You can also use Wildcards (see Okapi/Wildcards package)
        class: Product ::class . ' | ' . Order ::class,
        method: ' get(Price|Total) ' ,

        // When using wildcards you can also use some of these options:
        onlyPublicMethods: false , // Intercepts only public methods and ignores protected and private methods (default: false)
        interceptTraitMethods: true , // Also intercepts methods from traits (default: true)
    )]
    public function applyDiscount ( AfterMethodInvocation $ invocation ): void
    {
        // Get the subject of the invocation
        // The subject is the object class that contains the method
        // that is being intercepted
        $ subject = $ invocation -> getSubject ();
        
        $ productDiscount = 0.1 ;
        $ orderDiscount   = 0.2 ;
        
        if ( $ subject instanceof Product ) {
            // Get the result of the original method
            $ oldPrice = $ invocation -> proceed ();
            $ newPrice = $ oldPrice - ( $ oldPrice * $ productDiscount );
            
            // Set the new result
            $ invocation -> setResult ( $ newPrice );
        }
        
        if ( $ subject instanceof Order ) {
            $ oldTotal = $ invocation -> proceed ();
            $ newTotal = $ oldTotal - ( $ oldTotal * $ orderDiscount );
            
            $ invocation -> setResult ( $ newTotal );
        }
    }
}

 // PaymentProcessor Aspect

<?php

use InvalidArgumentException ;
use Okapi  Aop  Attributes  After ;
use Okapi  Aop  Attributes  Around ;
use Okapi  Aop  Attributes  Aspect ;
use Okapi  Aop  Attributes  Before ;
use Okapi  Aop  Invocation  AroundMethodInvocation ;
use Okapi  Aop  Invocation  AfterMethodInvocation ;
use Okapi  Aop  Invocation  BeforeMethodInvocation ;

#[ Aspect ]
class PaymentProcessorAspect
{
    #[ Before (
        class: PaymentProcessor ::class,
        method: ' processPayment ' ,
    )]
    public function checkPaymentAmount ( BeforeMethodInvocation $ invocation ): void
    {
        $ payment = $ invocation -> getArgument ( ' amount ' );
        
        if ( $ payment < 0 ) {
            throw new InvalidArgumentException ( ' Invalid payment amount ' );
        }
    }
    
    #[ Around (
        class: PaymentProcessor ::class,
        method: ' processPayment ' ,
    )]
    public function logPayment ( AroundMethodInvocation $ invocation ): void
    {
        $ startTime = microtime ( true );
        
        // Proceed with the original method
        $ invocation -> proceed ();
        
        $ endTime     = microtime ( true );
        $ elapsedTime = $ endTime - $ startTime ;
        
        $ amount = $ invocation -> getArgument ( ' amount ' );
        
        $ logMessage = sprintf (
            ' Payment processed for amount $%.2f in %.2f seconds ' ,
            $ amount ,
            $ elapsedTime ,
        );
        
        // Singleton instance of a logger
        $ logger = Logger :: getInstance ();
        $ logger -> log ( $ logMessage );
    }
    
    #[ After (
        class: PaymentProcessor ::class,
        method: ' processPayment ' ,
    )]
    public function sendEmailNotification ( AfterMethodInvocation $ invocation ): void
    {
        // Proceed with the original method
        $ result = $ invocation -> proceed ();
        $ amount = $ invocation -> getArgument ( ' amount ' );
        
        $ message = sprintf (
            ' Payment processed for amount $%.2f ' ,
            $ amount ,
        );
        if ( $ result === true ) {
            $ message .= ' - Payment successful ' ;
        } else {
            $ message .= ' - Payment failed ' ;
        }
        
        // Singleton instance of an email queue
        $ mailQueue = MailQueue :: getInstance ();
        $ mailQueue -> addMail ( $ message );
    }
}

目标类

 // Product

<?php

class Product
{
    private float $ price ;
    
    public function getPrice (): float
    {
        return $ this -> price ;
    }
}

 // Order

<?php

class Order
{
    private float $ total = 500.00 ;
    
    public function getTotal (): float
    {
        return $ this -> total ;
    }
}

 // PaymentProcessor

<?php

class PaymentProcessor
{
    public function processPayment ( float $ amount ): bool
    {
        // Process payment
        
        return true ;
    }
}

初始化内核

 // Initialize the kernel early in the application lifecycle
// Preferably after the autoloader is registered

<?php

use MyKernel ;

require_once __DIR__ . ' /vendor/autoload.php ' ;

// Initialize the AOP Kernel
$ kernel = MyKernel :: init ();

结果

 <?php

// Just use your classes as usual

$ product = new Product ();

// Before AOP: 100.00
// After AOP: 90.00
$ productPrice = $ product -> getPrice ();


$ order = new Order ();

// Before AOP: 500.00
// After AOP: 400.00
$ orderTotal = $ order -> getTotal ();



$ paymentProcessor = new PaymentProcessor ();

// Invalid payment amount
$ amount = - 50.00 ;

// Before AOP: true
// After AOP: InvalidArgumentException
$ paymentProcessor -> processPayment ( $ amount );


// Valid payment amount
$ amount = 100.00 ;

// Value: true
$ paymentProcessor -> processPayment ( $ amount );


$ logger   = Logger :: getInstance ();
$ logs     = $ logger -> getLogs ();

// Value: Payment processed for amount $100.00 in 0.00 seconds
$ firstLog = $ logs [ 0 ]; 


$ mailQueue = MailQueue :: getInstance ();
$ mails     = $ mailQueue -> getMails ();

// Value: Payment processed for amount $100.00 - Payment successful
$ firstMail = $ mails [ 0 ];

班级的明确方面

单击以展开

将自定义方面添加到内核不需要类级显式方面，因为它们在运行时自动注册。

创建一个方面

 // Logging Aspect

<?php

use Attribute ;
use Okapi  Aop  Attributes  Aspect ;
use Okapi  Aop  Attributes  Before ;
use Okapi  Aop  Invocation  BeforeMethodInvocation ;

// Class-Level Explicit Aspects must be annotated with the "Aspect" attribute
// and the "Attribute" attribute
#[ Attribute ]
#[ Aspect ]
class LoggingAspect
{
    // The "class" argument is not required
    // The "method" argument is optional
    //   Without the argument, the aspect will be applied to all methods
    //   With the argument, the aspect will be applied to the specified method
    #[ Before ]
    public function logAllMethods ( BeforeMethodInvocation $ invocation ): void
    {
        $ methodName = $ invocation -> getMethodName ();
        
        $ logMessage = sprintf (
            " Method '%s' executed. " ,
            $ methodName ,
        );
        
        $ logger = Logger :: getInstance ();
        $ logger -> log ( $ logMessage );
    }
    
    #[ Before (
        method: ' updateInventory ' ,
    )]
    public function logUpdateInventory ( BeforeMethodInvocation $ invocation ): void
    {
        $ methodName = $ invocation -> getMethodName ();

        $ logMessage = sprintf (
            " Method '%s' executed. " ,
            $ methodName ,
        );

        $ logger = Logger :: getInstance ();
        $ logger -> log ( $ logMessage );
    }
}

目标类

 // Inventory Tracker

<?php

// Custom Class-Level Explicit Aspect added to the class
#[ LoggingAspect ]
class InventoryTracker
{
    private array $ inventory = [];
    
    public function updateInventory ( int $ productId , int $ quantity ): void
    {
         $ this -> inventory [ $ productId ] = $ quantity ;
    }
    
    public function checkInventory ( int $ productId ): int
    {
        return $ this -> inventory [ $ productId ] ?? 0 ;
    }
}

初始化内核

 // Initialize the kernel early in the application lifecycle
// Preferably after the autoloader is registered

// The kernel must still be initialized, even if it has no Aspects

<?php

use MyKernel ;

require_once __DIR__ . ' /vendor/autoload.php ' ;

// Initialize the AOP Kernel
$ kernel = MyKernel :: init ();

结果

 <?php

// Just use your classes as usual

$ inventoryTracker = new InventoryTracker ();
$ inventoryTracker -> updateInventory ( 1 , 100 );
$ inventoryTracker -> updateInventory ( 2 , 200 );

$ countProduct1 = $ inventoryTracker -> checkInventory ( 1 );
$ countProduct2 = $ inventoryTracker -> checkInventory ( 2 );



$ logger = Logger :: getInstance ();

// Value:
//   Method 'updateInventory' executed. (4 times)
//   Method 'checkInventory' executed. (2 times)
$ logs = $ logger -> getLogs ();

方法级的显式方面

单击以展开

将自定义方面添加到内核不需要方法级显式方面，因为它们在运行时自动注册。

创建一个方面

 // Performance Aspect

<?php

use Attribute ;
use Okapi  Aop  Attributes  Around ;
use Okapi  Aop  Invocation  AroundMethodInvocation ;
use Okapi  Aop  Attributes  Aspect ;

// Method-Level Explicit Aspects must be annotated with the "Aspect" attribute
// and the "Attribute" attribute
#[ Attribute ]
#[ Aspect ]
class PerformanceAspect
{
    // The "class" argument is not required
    // The "method" argument is optional
    //   Without the argument, the aspect will be applied to all methods
    //   With the argument, the aspect will be applied to the specified method
    #[ Around ]
    public function measure ( AroundMethodInvocation $ invocation ): void
    {
        $ start = microtime ( true );
        $ invocation -> proceed ();
        $ end = microtime ( true );

        $ executionTime = $ end - $ start ;

        $ class  = $ invocation -> getClassName ();
        $ method = $ invocation -> getMethodName ();

        $ logMessage = sprintf (
            " Method %s::%s executed in %.2f seconds. " ,
            $ class ,
            $ method ,
            $ executionTime ,
        );

        $ logger = Logger :: getInstance ();
        $ logger -> log ( $ logMessage );
    }
}

目标类

 // Customer Service

<?php

class CustomerService
{
    #[ PerformanceAspect ]
    public function createCustomer (): void
    {
        // Logic to create a customer
    }
}

初始化内核

 // Initialize the kernel early in the application lifecycle
// Preferably after the autoloader is registered

// The kernel must still be initialized, even if it has no Aspects

<?php

use MyKernel ;

require_once __DIR__ . ' /vendor/autoload.php ' ;

// Initialize the AOP Kernel
$ kernel = MyKernel :: init ();

结果

 <?php

// Just use your classes as usual

$ customerService = new CustomerService ();
$ customerService -> createCustomer ();



$ logger = Logger :: getInstance ();
$ logs   = $ logger -> getLogs ();

// Value: Method CustomerService::createCustomer executed in 0.01 seconds.
$ firstLog = $ logs [ 0 ];

特征

建议类型： “之前”，“周围”和“之后”
拦截“私人”和“受保护”方法（将显示IDE中的错误）
访问该主题的“私人”和“受保护”属性和方法（将显示IDE中的错误）
拦截“最终”方法和类
使用内核中“ OKAPI/CODE-TRANSFORMER”软件包中的“ okapi/code-transformer”软件包的变压器来修改和转换已加载的PHP类的源代码（有关更多信息，请参见“ OKAPI/CODE-TRANSEFFORMER”软件包“请参阅“ OKAPI/CODE-TRASSFORMER”软件包）

限制

内部“私人”和“受保护”方法无法截获

它如何工作

该软件包扩展了带有依赖项注入和AOP功能的“ Okapi/Code-Transformer”软件包
AopKernel注册多个服务
- TransformerManager服务存储方面及其配置列表
- CacheStateManager服务管理缓存状态
- StreamFilter Service登记一个PHP流滤波器，该过滤器允许在PHP加载之前修改源代码
- AutoloadInterceptor服务超载作曲家自动加载器，该加载器处理类的加载

一般工作流程加载时

AutoloadInterceptor服务拦截了类的加载
AspectMatcher将类和方法名称与方面列表及其配置匹配
如果类和方法名称匹配一个方面，请查询缓存状态以查看源代码是否已缓存
- 检查缓存是否有效：
  - 缓存过程的修改时间小于源文件的修改时间或方面文件的修改时间
  - 检查缓存文件，源文件和方面文件是否存在
- 如果缓存有效，请从缓存加载代理类
- 如果AutoloadInterceptor
StreamFilter通过应用方面修改源代码
- 将原始源代码转换为代理类（myClass-> myclass__aopproxied）
- 代理类应具有与原始类相同数量的行（因为调试器将指向原始类）
- 代理类扩展了一个编织类，其中包含应用方面的逻辑
- 编织类将包括在代理类的底部
- 编织课也将被缓存

测试

运行composer run-script test
或者
运行composer run-script test-coverage

贡献

为了为该项目做出贡献，请在任何有效或拥有100％工作测试的应用程序中启动一个方面，并将每个类和方法与“*”与任何建议类型匹配。
如果应用程序引发错误，则是一个错误。
例子：

 <?php

use Okapi  Aop  Attributes  After ;
use Okapi  Aop  Attributes  Aspect ;
use Okapi  Aop  Invocation  AfterMethodInvocation ;

#[ Aspect ]
class EverythingAspect
{
    #[ After (
        class: ' * ' ,
        method: ' * ' ,
    )]
    public function everything ( AfterMethodInvocation $ invocation ): void
    {
        echo $ invocation -> getClassName () . "n" ;
        echo $ invocation -> getMethodName () . "n" ;
    }
}

表示您的支持

如果这个项目对您有帮助！

谢谢

非常感谢Lisachenko在旅途中的开创性工作！ PHP面向方面的框架。该项目从他们的创新方法中汲取了灵感，并为该项目提供了基础。

执照

展开

附加信息

版本 Release 1.2.15
类型其他源码
更新时间 2025-02-04
大小 2MB
来自于 Github