分享到：微信新浪微博QQ好友QQ空间腾讯微博复制网址

面向方面编程（AOP）对于PHP来说是一个新的概念。现在PHP对于 AOP 并没有官方支持，但有很多扩展和库实现了这个特性。本课中，我们将使用 Go! PHP library 来学习 PHP 如何进行 AOP 开发，或者在需要的时候，可以回来看一眼。

AOP简史

Aspect-Oriented programming is like a new gadget for geeks.

面向方面编程的思想在二十世纪90年代中期，于施乐帕洛阿尔托研究中心（PARC）成型。同很多有趣的新技术一样，由于缺少明确的定义，起初 AOP 备受争议。因此相关小组决定将未完成的想法公之于众，以便接受广大社区的反馈。关键问题在于“关注点分离（Separation of Concerns)”的概念。AOP 是一种可以分离关注的可行系方案。

AOP 于90年代末趋于成熟，标识为施乐 AspectJ 的发布，IBM 紧随其后，于2001年发布了 Hyper/J。现在，AOP是一种对于常用编程语言来说都是一种成熟的技术。

基本词汇

AOP 的核心就是“方面”，但在我们定义「方面『aspect』」之前，我们需要先讨论两个术语；「切点 『 point-cut』 」和「通知『advise』」。切点代表我们代码中的一个时间点，特指运行我们代码的某个时间。在切点运行代码被称为通知，结合一个活多个切点及通知的即为方面。

通常，每个类都会有一个核心的行为或关注点，但有时，类可能存在次要的行为。例如，类可能会调用一个日志记录器或是通知一个观察员。因为类中的这些功能是次要的，其行为通常都是相同的。这种行为被称为“交叉关注点”；使用 AOP 可以避免。

PHP的各种AOP工具

Chris Peters 已经讨论过在PHP中实现 AOP 的Flow 框架。 Lithium 框架也提供了对AOP的实现。

另一个框架采用了不同的方法，创建了一个 C/C++ 编写的PHP扩展，在PHP解释器的层级上宣示着它的魔力。名为AOP PHP Extension，我会在后续文章中讨论它。

但正如我之前所言，本文将检阅Go! AOP-PHP 库。

安装并配置 Go!

Go! 库并未扩展；它完全由PHP编写，并为PHP5.4或更高版本使用。作为一个纯PHP库，它部署简易，即使是在不允许编译安装你自己的PHP扩展的受限及共享主机环境，也可以轻易安装。

使用 Composer 安装 Go!

Composer 是安装 PHP 包的首选方法。如果你没有使用过 Composer，你可以在Go! GitHub repository下载。

首先，将下面几行加入你的 composer.json 文件。

1 {
2     “require”: {
3         “lisachenko/go-aop-php”: “*”
4     }
5 }

之后，使用 Composer 安装 go-aop-php。在终端中运行下面命令:

1 $ cd /your/project/folder
2 $ php composer.phar update lisachenko/go-aop-php

Composer 将会在之后数秒中内安装引用的包以及需求。如果成功，你将看到类似下面的输出：

01 Loading composer repositories with package information
02 Updating dependencies
03   – Installing doctrine/common (2.3.0)
04     Downloading: 100%
05  
06   – Installing andrewsville/php-token-reflection (1.3.1)
07     Downloading: 100%
08  
09   – Installing lisachenko/go-aop-php (0.1.1)
10     Downloading: 100%
11  
12 Writing lock file
13 Generating autoload files

在安装完成后，你可以在你的代码目录中发现名为 vendor 的文件夹。Go! 库及其需求就安装在这。

01 $ ls -l ./vendor
02 total 20
03 drwxr-xr-x 3 csaba csaba 4096 Feb  2 12:16 andrewsville
04 -rw-r–r– 1 csaba csaba  182 Feb  2 12:18 autoload.php
05 drwxr-xr-x 2 csaba csaba 4096 Feb  2 12:16 composer
06 drwxr-xr-x 3 csaba csaba 4096 Feb  2 12:16 doctrine
07 drwxr-xr-x 3 csaba csaba 4096 Feb  2 12:16 lisachenko
08  
09 $ ls -l ./vendor/lisachenko/
10 total 4
11 drwxr-xr-x 5 csaba csaba 4096 Feb  2 12:16 go-aop-php

整合到我们的项目

我们需要创建一个调用,介于路由/应用程序的入口点。自动装弹机的然后自动包括类。开始吧!引用作为一个切面内核。

01 use Go\Core\AspectKernel;
02 use Go\Core\AspectContainer;
03  
04 class ApplicationAspectKernel extends AspectKernel {
05  
06     protected function configureAop(AspectContainer $container) {
07  
08     }
09  
10     protected function getApplicationLoaderPath() {
11  
12     }
13  
14 }

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

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

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

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

01 // […]
02 class ApplicationAspectKernel extends AspectKernel {
03  
04     // […]
05  
06     protected function getApplicationLoaderPath() {
07         return __DIR__ . DIRECTORY_SEPARATOR . ‘autoload.php’;
08     }
09  
10 }

别担心 autoload.php 就是这样。我们将会填写被省略的片段。

当我们第一次安装 Go语言！和达到这一点我的过程中,我觉得需要运行一些代码。所以开始构建一个小应用程序。

创建一个简单的日志记录器

我们的「方面」为一个简单的日志记录器，但在继续我们应用的主要部分之前，有些代码需要看一下。

创建一个最小的应用

我们的小应用是一个电子经纪人，能够购买和出售股票。

01 class Broker {
02  
03     private $name;
04     private $id;
05  
06     function __construct($name, $id) {
07         $this->name = $name;
08         $this->id = $id;
09     }
10  
11     function buy($symbol, $volume, $price) {
12         return $volume * $price;
13     }
14  
15     function sell($symbol, $volume, $price) {
16         return $volume * $price;
17     }
18  
19 }

这些代码非常简单，Broker 类拥有两个私有字段，储存经纪人的名称和 ID。

这个类同时提供了两个方法，buy() 和 sell()，分别用于收购和出售股票。每个方法接受三个参数：股票标识、股票数量、每股价格。sell() 方法出售股票，并计算总收益。相应的，buy()方法购买股票并计算总支出。

考验我们的经纪人

通过PHPUnit 测试程序，我们可以很容易的考验我们经纪人。在应用目录内创建一个子目录，名为 Test，并在其中添加 BrokerTest.php 文件。并添加下面的代码：

01 require_once ‘../Broker.php’;
02  
03 class BrokerTest extends PHPUnit_Framework_TestCase {
04  
05     function testBrokerCanBuyShares() {
06         $broker = new Broker(‘John’, ‘1’);
07         $this->assertEquals(500, $broker->buy(‘GOOGL’, 100, 5));
08     }
09  
10     function testBrokerCanSellShares() {
11         $broker = new Broker(‘John’, ‘1’);
12         $this->assertEquals(500, $broker->sell(‘YAHOO’, 50, 10));
13     }
14  
15 }

这个检验程序检查经纪人方法的返回值。我们可以运行这个检查程序检验我们的代码，至少是不是语法正确。

添加一个自动加载器

让我们创建一个自动加载器，在应用需要的时候加载类。这是一个简单的加载器，基于PSR-0 autoloader.

01 ini_set(‘display_errors’, true);
02  
03 spl_autoload_register(function($originalClassName) {
04     $className = ltrim($originalClassName, ‘\\’);
05     $fileName  = ”;
06     $namespace = ”;
07     if ($lastNsPos = strripos($className, ‘\\’)) {
08         $namespace = substr($className, 0, $lastNsPos);
09         $className = substr($className, $lastNsPos + 1);
10         $fileName  = str_replace(‘\\’, DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
11     }
12     $fileName .= str_replace(‘_’, DIRECTORY_SEPARATOR, $className) . ‘.php’;
13  
14     $resolvedFileName = stream_resolve_include_path($fileName);
15     if ($resolvedFileName) {
16         require_once $resolvedFileName;
17     }
18     return (bool) $resolvedFileName;
19 });

这就是我们 autoload.php 文件中的全部内容。现在，变更 BrokerTest.php， 改引用Broker.php 为引用自动加载器 。

1 require_once ‘../autoload.php’;
2  
3 class BrokerTest extends PHPUnit_Framework_TestCase {
4     // […]
5 }

运行 BrokerTest，验证代码运行情况。

连接到应用方面核心

我们最后的一件事是配置Go!.为此，我们需要连接所有的组件让们能和谐工作。首先，创建一个php文件AspectKernelLoader.php，其代码如下：

01 include __DIR__ . ‘/../vendor/lisachenko/go-aop-php/src/Go/Core/AspectKernel.php’;
02 include ‘ApplicationAspectKernel.php’;
03  
04 ApplicationAspectKernel::getInstance()->init(array(
05     ‘autoload’ => array(
06         ‘Go’               => realpath(__DIR__ . ‘/../vendor/lisachenko/go-aop-php/src/’),
07         ‘TokenReflection’  => realpath(__DIR__ . ‘/../vendor/andrewsville/php-token-reflection/’),
08         ‘Doctrine\\Common’ => realpath(__DIR__ . ‘/../vendor/doctrine/common/lib/’)
09     ),
10     ‘appDir’ => __DIR__ . ‘/../Application’,
11     ‘cacheDir’ => null,
12     ‘includePaths’ => array(),
13     ‘debug’ => true
14 ));

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

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

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

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

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

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

1 require_once ‘../AspectKernelLoader.php’;
2  
3 class BrokerTest extends PHPUnit_Framework_TestCase {
4  
5 // […]
6  
7 }

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

记录Broker的方法

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

01 use Go\Aop\Aspect;
02 use Go\Aop\Intercept\FieldAccess;
03 use Go\Aop\Intercept\MethodInvocation;
04 use Go\Lang\Annotation\After;
05 use Go\Lang\Annotation\Before;
06 use Go\Lang\Annotation\Around;
07 use Go\Lang\Annotation\Pointcut;
08 use Go\Lang\Annotation\DeclareParents;
09  
10 class BrokerAspect implements Aspect {
11  
12     /**
13      * @param MethodInvocation $invocation Invocation
14      * @Before(“execution(public Broker->*(*))”) // This is our PointCut
15      */
16     public function beforeMethodExecution(MethodInvocation $invocation) {
17         echo “Entering method ” . $invocation->getMethod()->getName() . “()\n”;
18     }
19 }

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

 
1 * @Before(“execution(public Broker->*(*))”)
  • @Before 给出合适应用建议. 可能的参数有@Before,@After,@Around和@After线程.
  • “execution(public Broker->*(*))” 给执行一个类所有的公共方法指出了匹配规则，可以用任意数量的参数调用Broker,语法是:                  
1 [operation – execution/access]([method/attribute type – public/protected] [class]->[method/attribute]([params])

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

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

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

注册切面

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

01 use Go\Core\AspectKernel;
02 use Go\Core\AspectContainer;
03  
04 class ApplicationAspectKernel extends AspectKernel
05 {
06  
07     protected function getApplicationLoaderPath()
08     {
09         return __DIR__ . DIRECTORY_SEPARATOR . ‘autoload.php’;
10     }
11  
12     protected function configureAop(AspectContainer $container)
13     {
14         $container->registerAspect(new BrokerAspect());
15     }
16 }

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

1 PHPUnit 3.6.11 by Sebastian Bergmann.
2  
3 .Entering method __construct()
4 Entering method buy()
5 .Entering method __construct()
6 Entering method sell()
7 Time: 0 seconds, Memory: 5.50Mb
8  
9 OK (2 tests, 2 assertions)

就这样我们已设法让代码无论什么时候发生在broker上时都会执行。

查找参数和匹配@After

让我们加入另外的方法到BrokerAspect。

01 // […]
02 class BrokerAspect implements Aspect {
03  
04     // […]
05  
06     /**
07      * @param MethodInvocation $invocation Invocation
08      * @After(“execution(public Broker->*(*))”)
09      */
10     public function afterMethodExecution(MethodInvocation $invocation) {
11         echo “Finished executing method ” . $invocation->getMethod()->getName() . “()\n”;
12         echo “with parameters: ” . implode(‘, ‘, $invocation->getArguments()) . “.\n\n”;
13     }
14 }

这个方法在一个公共方法执行后运行（注意@After匹配器）。染污我们加入另外一行来输出用来调用方法的参数。我们的测试现在输出：

01 PHPUnit 3.6.11 by Sebastian Bergmann.
02  
03 .Entering method __construct()
04 Finished executing method __construct()
05 with parameters: John, 1.
06  
07 Entering method buy()
08 Finished executing method buy()
09 with parameters: GOOGL, 100, 5.
10  
11 .Entering method __construct()
12 Finished executing method __construct()
13 with parameters: John, 1.
14  
15 Entering method sell()
16 Finished executing method sell()
17 with parameters: YAHOO, 50, 10.
18  
19 Time: 0 seconds, Memory: 5.50Mb
20  
21 OK (2 tests, 2 assertions)

 

获得返回值并操纵运行

目前为止，我们学习了在一个方法执行的之前和之后，怎样运行额外的代码。当这个漂亮的实现后，如果我们无法看到方法返回了什么的话，它还不是非常有用。我们给aspect增加另一个方法，修改现有的代码：

01 //[…]
02 class BrokerAspect implements Aspect {
03  
04     /**
05      * @param MethodInvocation $invocation Invocation
06      * @Before(“execution(public Broker->*(*))”)
07      */
08     public function beforeMethodExecution(MethodInvocation $invocation) {
09         echo “Entering method ” . $invocation->getMethod()->getName() . “()\n”;
10         echo “with parameters: ” . implode(‘, ‘, $invocation->getArguments()) . “.\n”;
11     }
12  
13     /**
14      * @param MethodInvocation $invocation Invocation
15      * @After(“execution(public Broker->*(*))”)
16      */
17     public function afterMethodExecution(MethodInvocation $invocation) {
18         echo “Finished executing method ” . $invocation->getMethod()->getName() . “()\n\n”;
19     }
20  
21     /**
22      * @param MethodInvocation $invocation Invocation
23      * @Around(“execution(public Broker->*(*))”)
24      */
25     public function aroundMethodExecution(MethodInvocation $invocation) {
26         $returned = $invocation->proceed();
27         echo “method returned: ” . $returned . “\n”;
28  
29         return $returned;
30     }
31  
32 }

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

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

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

01 PHPUnit 3.6.11 by Sebastian Bergmann.
02  
03 .Entering method __construct()
04 with parameters: John, 1.
05 method returned:
06 Finished executing method __construct()
07  
08 Entering method buy()
09 with parameters: GOOGL, 100, 5.
10 method returned: 500
11 Finished executing method buy()
12  
13 .Entering method __construct()
14 with parameters: John, 1.
15 method returned:
16 Finished executing method __construct()
17  
18 Entering method sell()
19 with parameters: YAHOO, 50, 10.
20 method returned: 500
21 Finished executing method sell()
22  
23 Time: 0 seconds, Memory: 5.75Mb
24  
25 OK (2 tests, 2 assertions)

我们增加一点变化，赋以一个具体的broker一个discount。返回到测试类，写如下的测试：

01 require_once ‘../AspectKernelLoader.php’;
02  
03 class BrokerTest extends PHPUnit_Framework_TestCase {
04  
05     // […]
06  
07     function testBrokerWithId2WillHaveADiscountOnBuyingShares() {
08         $broker = new Broker(‘Finch’, ‘2’);
09         $this->assertEquals(80, $broker->buy(‘MS’, 10, 10));
10     }
11  
12 }

这会失败：

01 Time: 0 seconds, Memory: 6.00Mb
02  
03 There was 1 failure:
04  
05 1) BrokerTest::testBrokerWithId2WillHaveADiscountOnBuyingShares