Aspect-oriented programming in PHP, PHP-oriented programming_PHP tutorial

Aspect-oriented programming in PHP, PHP-oriented programming

Aspect-oriented programming (AOP) is a new concept for PHP. Currently, PHP does not have official support for AOP, but there are many extensions and libraries that implement this feature. In this lesson, we will use the Go! PHP library to learn how to use PHP for AOP development, or you can come back and take a look if needed.

A brief history of AOP

<p>Aspect-Oriented programming is like a new gadget for geeks.</p>

The idea of ​​aspect-oriented programming took shape at the Xerox Palo Alto Research Center (PARC) in the mid-1990s. Like many interesting new technologies, AOP was initially controversial due to a lack of clear definition. So the group decided to make the unfinished idea public to receive feedback from the wider community. The key issue is the concept of "Separation of Concerns". AOP is a viable system solution for separation of concerns.

AOP matured in the late 1990s, marked by the release of Xerox AspectJ, followed by IBM with the release of Hyper/J in 2001. Today, AOP is a mature technology for commonly used programming languages.

Basic Vocabulary

　The core of AOP is "aspect", but before we define "aspect", we need to discuss two terms; "point-cut『 point-cut』" and "Notification『advise』". A pointcut represents a point in time in our code, specifically a time when our code is running. Running code at a pointcut is called an advice. Combining one or multiple pointcuts and advice is an aspect .

Usually, each class will have a core behavior or focus, but sometimes, a class may have secondary behaviors. For example, a class might call a logger or notify an observer. Because these functions within a class are secondary, their behavior is usually the same. This behavior is called "Crossing Concerns"; it can be avoided using AOP.

Various AOP tools for PHP

Chris Peters has discussed the Flow framework for implementing AOP in PHP. The Lithium framework also provides implementation of AOP.

Another framework takes a different approach and creates a PHP extension written in C/C++ that asserts its magic at the level of the PHP interpreter. It's called AOP PHP Extension, and I'll discuss it in a follow-up article.

But as I said before, this article will review the Go! AOP-PHP library.

Install and configure Go!

The Go! library is not extended; it is written entirely in PHP and is intended for use with PHP 5.4 or higher. As a pure PHP library, it is easy to deploy and can be easily installed even in restricted and shared hosting environments that do not allow you to compile and install your own PHP extensions.

Use Composer to install Go!

Composer is the preferred method for installing PHP packages. If you haven't used Composer, you can download it from the Go! GitHub repository.

First, add the following lines to your composer.json file.

After that, use Composer to install go-aop-php. Run the following command in the terminal:

Composer will install the referenced packages and requirements within a few seconds. If successful, you will see output similar to the following:

After the installation is complete, you can find a folder named vendor in your code directory. The Go! library and its requirements are installed here.

Integrated into our project

We need to create a call between the route/entry point of the application. The autoloader class is then included automatically. Let’s get started! Reference as an aspect kernel.

现在，AOP是一种在通用编程语言中相当成熟的技术。

　　例如，我创建了一个目录，调用应用程序，然后添加一个类文件: ApplicationAspectKernel.php 。

　　我们开始切面扩展！AcpectKernel 类提供了基础的方法用于完切面内核的工作。有两个方法，我们必须知道：configureAop()用于注册页面特征，和 getApplicationLoaderPath() 返回自动加载程序的全路径。

　　现在，一个简单的建立一个空的 autoload.php 文件在你的程序目录。和改变 getApplicationLoaderPath() 方法。如下：

Don’t worry about autoload.php and that’s it. We will fill in the omitted fragments.

When we installed the Go language for the first time! And to get to this point in my process, I felt the need to run some code. So start building a small application.

Create a simple logger

Our “aspect” is a simple logger, but there is some code to look at before moving on to the main part of our application.

Create a minimal application

Our little application is an electronic broker capable of buying and selling stocks.

The code is very simple. The Broker class has two private fields that store the broker’s name and ID.

This class also provides two methods, buy() and sell(), which are used to purchase and sell stocks respectively. Each method accepts three parameters: stock ID, number of shares, and price per share. The sell() method sells the stock and calculates the total return. Accordingly, the buy() method buys the stock and calculates the total payout.

Test our agents

Through the PHPUnit test program, we can easily test our broker. Create a subdirectory within the application directory called Test and add the BrokerTest.php file there. and add the following code:

This checker checks the return value of the broker method. We can run this checker to verify that our code is at least syntactically correct.

Add an autoloader

Let’s create an autoloader that loads classes when the application needs them. This is a simple loader, based on PSR-0 autoloader.

That’s all in our autoload.php file. Now, change BrokerTest.php to reference Broker.php to reference the autoloader.

Run BrokerTest to verify the code operation.

Connect to the application core

The last thing we need to do is configure Go!. To do this, we need to connect all the components so that they work harmoniously. First, create a php file AspectKernelLoader.php with the following code:

<p>我们需要连接所有的组件让们能和谐工作！</p>

　　这个文件位于前端控制器和自动加载器之间。他使用AOP框架初始化并在需要时调用autoload.php

　　第一行，我明确地载入AspectKernel.php和ApplicationAspectKernel.php，因为，要记住，在这个点我们还没有自动加载器。

　　接下来的代码段，我们调用ApplicationAspectKernel对象init()方法，并且给他传递了一个数列参数：

• autoload 定义了初始化AOP类库的路径。根据你实际的目录机构调整为相应的值。
• appDir 引用了应用的目录
• cacheDir 指出了缓存目录（本例中中我们忽略缓存）。
• includePaths 对aspects的一个过滤器。我想看到所有特定的目录，所以设置了一个空数组，以便看到所有的值。
• debug  提供了额外的调试信息，这对开发非常有用，但是对已经要部属的应用设置为false。

　　为了最后实现各个不同部分的连接，找出你工程中autoload.php自动加载所有的引用并且用AspectKernelLoader.php替换他们。在我们简单的例子中，仅仅test文件需要修改：

　　对大一点的工程，你会发现使用bootstrap.php作为单元测试但是非常有用；用require_once()做为autoload.php，或者我们的AspectKernelLoader.php应该在那载入。

　　记录Broker的方法

　　创建BrokerAspect.php文件，代码如下：

　　我们在程序开始指定一些有对AOP框架有用的语句。接着，我们创建了自己的方面类叫BrokerAspect，用它实现Aspect。接着，我们指定了我们aspect的匹配逻辑。

• @Before 给出合适应用建议. 可能的参数有@Before,@After,@Around和@After线程.
• "execution(public Broker->*(*))" 给执行一个类所有的公共方法指出了匹配规则，可以用任意数量的参数调用Broker,语法是:                 

　　　请注意匹配机制不可否认有点笨拙。你在规则的每一部分仅可以使用一个星号‘*‘。例如public Broker->匹配一个叫做Broker的类；public Bro*->匹配以Bro开头的任何类；public *ker->匹配任何ker结尾的类。

<p>public *rok*->将匹配不到任何东西；你不能在同一个匹配中使用超过一个的星号。</p>

　　　紧接着匹配程序的函数会在有时间发生时调用。在本例中的方法将会在每一个Broker公共方法调用之前执行。其参数$invocation(类型为MethodInvocation)子自动传递到我们的方法的。这个对象提供了多种方式获取调用方法的信息。在第一个例子中，我们使用他获取了方法的名字，并且输出。

　　注册切面

　　仅仅定义一个切面是不够的；我们需要把它注册到AOP架构里。否则，它不会生效。编辑ApplicationAspectKernel.php同时在容器上的configureAop()方法里调用registerAspect()：

　　运行测试和检查输出。你会看到类似下面的东西：

Just like that we have managed to make the code execute whenever something happens on the broker.

Find parameters and match @After

Let’s add another method to BrokerAspect.

This method runs after a public method is executed (note the @After matcher). To taint we add another line to print out the parameters used to call the method. Our test now outputs:

Get the return value and manipulate the operation

So far, we have learned how to run additional code before and after a method is executed. While this nice implementation is implemented, it's not very useful if we can't see what the method returns. We add another method to the aspect and modify the existing code:

<p>仅仅定义一个aspect是不够的；我们需要将它注册到AOP基础设施。</p>

　　这个新的代码把参数信息移动到@Before方法。我们也增加了另一个特殊的@Around匹配器方法。这很整洁，因为原始的匹配方法调用被包裹于aroundMethodExecution()函数之内，有效的限制了原始的调用。在advise里，我们要调用$invocation->proceed()，以便执行原始的调用。如果你不这么做，原始的调用将不会发生。

　　这种包装也允许我们操作返回值。advise返回的就是原始调用返回的。在我们的案例中，我们没有修改任何东西，输出应该看起来像这样：

We add a little change and assign a discount to a specific broker. Return to the test class and write the following test:

This will fail:

Next, we need to modify the broker to provide its ID. Just implement the agetId() method as shown below:

Now, modify the aspect to adjust the purchase price of the broker with ID value 2.

There is no need to add new methods, just modify the aroundMethodExecution() function. Now it matches the method, called 'buy', and triggers $invocation->getThis(). This effectively returns the original Broker object so that we can execute its code. So we did it! We ask the broker for its ID and provide a discount if the ID is equal to 2. The test now passes.

Matching exception

We can now execute additional procedures after the start and execution of a method, when bypassing. But what about when a method throws an exception?

Add a test method to buy a large amount of Microsoft stock:

Now, create an exception class. We need it because the built-in exception classes cannot be caught by Go!AOP or PHPUnit.

Modify the broker class and throw an exception for large values:

Run the tests and make sure they produce failure messages:

Now, expect exceptions (in tests) and make sure they pass:

Create a new method in our "aspect" to match @AfterThrowing, don't forget to specify Use GoLangAnnotationAfterThrowing;