注解解析器Annotations Parser

这是第一个为PHP用C语言写的注解解析器。 Phalcon\Annotations是一个通用组件，为应用中的PHP类提供易于解析和缓存注解的功能。

It is the first time that an annotations parser component is written in C for the PHP world. Phalcon\Annotations is a general purpose component that provides ease of parsing and caching annotations in PHP classes to be used in applications.

注解内容是读自类，方法和属性的注解区域。一个注解单元可以放在注解区域的任何位置。

Annotations are read from docblocks in classes, methods and properties. An annotation can be placed at any position in the docblock:

  1. <?php
  3. /**
  4.  * This is the class description
  5.  *
  6.  * @AmazingClass(true)
  7.  */
  8. class Example
  9. {
  11.     /**
  12.      * This a property with a special feature
  13.      *
  14.      * @SpecialFeature
  15.      */
  16.     protected $someProperty;
  18.     /**
  19.      * This is a method
  20.      *
  21.      * @SpecialFeature
  22.      */
  23.     public function someMethod()
  24.     {
  25.         // ...
  26.     }
  28. }

在上面的例子中，我们发现注解块中除了注解单元，还可以有注解内容，一个注解单元语法如下：

In the above example we find some annotations in the comments, an annotation has the following syntax:

@注解名称[(参数1, 参数2, …)]

@Annotation-Name[(param1, param2, …)]

当然，一个注解单元可以放在注解内容里的任意位置：

Also, an annotation could be placed at any part of a docblock:

  1. <?php
  3. /**
  4.  * This a property with a special feature
  5.  *
  6.  * @SpecialFeature
  7.  *
  8.  * More comments
  9.  *
  10.  * @AnotherSpecialFeature(true)
  11.  */

这个解析器是高度灵活的，下面这样的注解单元是合法可解析的：

The parser is highly flexible, the following docblock is valid:

  1. <?php
  3. /**
  4.  * This a property with a special feature @SpecialFeature({
  5. someParameter="the value", false
  7.  })  More comments @AnotherSpecialFeature(true) @MoreAnnotations
  8.  **/

然而，为了使代码更容易维护和理解，我们推荐把注解单元放在注解块的最后：

However, to make the code more maintainable and understandable it is recommended to place annotations at the end of the docblock:

  1. <?php
  3. /**
  4.  * This a property with a special feature
  5.  * More comments
  6.  *
  7.  * @SpecialFeature({someParameter="the value", false})
  8.  * @AnotherSpecialFeature(true)
  9.  */

读取注解Reading Annotations

实现反射器（Reflector）可以轻松获取被定义在类中的注解，使用一个面向对象的接口即可：

A reflector is implemented to easily get the annotations defined on a class using an object-oriented interface:

  1. <?php
  3. $reader = new \Phalcon\Annotations\Adapter\Memory();
  5. //Reflect the annotations in the class Example
  6. $reflector = $reader->get('Example');
  8. //Read the annotations in the class' docblock
  9. $annotations = $reflector->getClassAnnotations();
  11. //Traverse the annotations
  12. foreach ($annotations as $annotation) {
  14.     //Print the annotation name
  15.     echo $annotation->getName(), PHP_EOL;
  17.     //Print the number of arguments
  18.     echo $annotation->numberArguments(), PHP_EOL;
  20.     //Print the arguments
  21.     print_r($annotation->getArguments());
  22. }

虽然这个注解的读取过程是非常快速的，然而，出于性能原因，我们建议使用一个适配器储存解析后的注解内容。 适配器把处理后的注解内容缓存起来，避免每次读取都需要解析一遍注解。

The annotation reading process is very fast, however, for performance reasons it is recommended to store the parsed annotations using an adapter. Adapters cache the processed annotations avoiding the need of parse the annotations again and again.

Phalcon\Annotations\Adapter\Memory 被用在上面的例子中。这个适配器只在请求过程中缓存注解（译者注：请求完成后缓存将被清空），因为这个原因，这个适配器非常适合用于开发环境中。当应用跑在生产环境中还有其他适配器可以替换。

Phalcon\Annotations\Adapter\Memory was used in the above example. This adapter only caches the annotations while the request is running, for this reason th adapter is more suitable for development. There are other adapters to swap out when the application is in production stage.

注解类型Types of Annotations

注解单元可以有参数也可以没有。参数可以为简单的文字(strings, number, boolean, null)，数组，哈希列表或者其他注解单元：

Annotations may have parameters or not. A parameter could be a simple literal (strings, number, boolean, null), an array, a hashed list or other annotation:

  1. <?php
  3. /**
  4.  * Simple Annotation
  5.  *
  6.  * @SomeAnnotation
  7.  */
  9. /**
  10.  * Annotation with parameters
  11.  *
  12.  * @SomeAnnotation("hello", "world", 1, 2, 3, false, true)
  13.  */
  15. /**
  16.  * Annotation with named parameters
  17.  *
  18.  * @SomeAnnotation(first="hello", second="world", third=1)
  19.  * @SomeAnnotation(first: "hello", second: "world", third: 1)
  20.  */
  22. /**
  23.  * Passing an array
  24.  *
  25.  * @SomeAnnotation([1, 2, 3, 4])
  26.  * @SomeAnnotation({1, 2, 3, 4})
  27.  */
  29. /**
  30.  * Passing a hash as parameter
  31.  *
  32.  * @SomeAnnotation({first=1, second=2, third=3})
  33.  * @SomeAnnotation({'first'=1, 'second'=2, 'third'=3})
  34.  * @SomeAnnotation({'first': 1, 'second': 2, 'third': 3})
  35.  * @SomeAnnotation(['first': 1, 'second': 2, 'third': 3])
  36.  */
  38. /**
  39.  * Nested arrays/hashes
  40.  *
  41.  * @SomeAnnotation({"name"="SomeName", "other"={
  42.  *      "foo1": "bar1", "foo2": "bar2", {1, 2, 3},
  43.  * }})
  44.  */
  46. /**
  47.  * Nested Annotations
  48.  *
  49.  * @SomeAnnotation(first=@AnotherAnnotation(1, 2, 3))
  50.  */

实际使用Practical Usage

接下来我们将解释PHP应用程序中的注解的一些实际的例子：

Next we will explain some practical examples of annotations in PHP applications:

注解开启缓存Cache Enabler with Annotations

我们假设一下，假设我们接下来的控制器和开发者想要建一个插件，如果被执行的方法被标记为可缓存的话，这个插件可以自动开启缓存。首先，我们先注册这个插件到Dispatcher服务中，这样这个插件将被通知当控制器的路由被执行的时候：

Let’s pretend we’ve the following controller and the developer wants to create a plugin that automatically start the cache if the latest action executed is marked as cacheable. First off all we register a plugin in the Dispatcher service to be notified when a route is executed:

  1. <?php
  3. $di['dispatcher'] = function() {
  5.     $eventsManager = new \Phalcon\Events\Manager();
  7.     //Attach the plugin to 'dispatch' events
  8.     $eventsManager->attach('dispatch', new CacheEnablerPlugin());
  10.     $dispatcher = new \Phalcon\Mvc\Dispatcher();
  11.     $dispatcher->setEventsManager($eventsManager);
  12.     return $dispatcher;
  13. };

CacheEnablerPlugin 这个插件拦截每一个被dispatcher执行的action，检查如果需要则启动缓存：

CacheEnablerPlugin is a plugin that intercept every action executed in the dispatcher enabling the cache if needed:

  1. <?php
  3. /**
  4.  * Enables the cache for a view if the latest
  5.  * executed action has the annotation @Cache
  6.  */
  7. class CacheEnablerPlugin extends \Phalcon\Mvc\User\Plugin
  8. {
  10.     /**
  11.      * This event is executed before every route is executed in the dispatcher
  12.      *
  13.      */
  14.     public function beforeExecuteRoute($event, $dispatcher)
  15.     {
  17.         //Parse the annotations in the method currently executed
  18.         $annotations = $this->annotations->getMethod(
  19.             $dispatcher->getActiveController(),
  20.             $dispatcher->getActiveMethod()
  21.         );
  23.         //Check if the method has an annotation 'Cache'
  24.         if ($annotations->has('Cache')) {
  26.             //The method has the annotation 'Cache'
  27.             $annotation = $annotations->get('Cache');
  29.             //Get the lifetime
  30.             $lifetime = $annotation->getNamedParameter('lifetime');
  32.             $options = array('lifetime' => $lifetime);
  34.             //Check if there is an user defined cache key
  35.             if ($annotation->hasNamedParameter('key')) {
  36.                 $options['key'] = $annotation->getNamedParameter('key');
  37.             }
  39.             //Enable the cache for the current method
  40.             $this->view->cache($options);
  41.         }
  43.     }
  45. }

现在，我们可以使用注解单元在控制器中：

Now, we can use the annotation in a controller:

  1. <?php
  3. class NewsController extends \Phalcon\Mvc\Controller
  4. {
  6.     public function indexAction()
  7.     {
  9.     }
  11.     /**
  12.      * This is a comment
  13.      *
  14.      * @Cache(lifetime=86400)
  15.      */
  16.     public function showAllAction()
  17.     {
  18.         $this->view->article = Articles::find();
  19.     }
  21.     /**
  22.      * This is a comment
  23.      *
  24.      * @Cache(key="my-key", lifetime=86400)
  25.      */
  26.     public function showAction($slug)
  27.     {
  28.         $this->view->article = Articles::findFirstByTitle($slug);
  29.     }
  31. }

选择渲染模版Choose template to render

在这个例子中，当方法被执行的时候，我们将使用注解单元去告诉:doc:PhalconMvcViewSimple <views>，哪一个模板文件需要渲染：

In this example we’re going to use annotations to tell Phalcon\Mvc\View\Simple what template must me rendered once the action has been executed:

注解适配器Annotations Adapters

这些组件利用了适配器去缓存或者不缓存已经解析和处理过的注解内容，从而提升了性能或者为开发环境提供了开发/测试的适配器：

This component makes use of adapters to cache or no cache the parsed and processed annotations thus improving the performance or providing facilities to development/testing:

NameDescriptionAPI
MemoryThe annotations are cached only in memory. When the request ends the cache is cleaned reloading the annotations in each request. This adapter is suitable for a development stagePhalcon\Annotations\Adapter\Memory
FilesParsed and processed annotations are stored permanently in PHP files improving performance. This adapter must be used together with a bytecode cache.Phalcon\Annotations\Adapter\Files
APCParsed and processed annotations are stored permanently in the APC cache improving performance. This is the faster adapterPhalcon\Annotations\Adapter\Apc
XCacheParsed and processed annotations are stored permanently in the XCache cache improving performance. This is a fast adapter tooPhalcon\Annotations\Adapter\Xcache

自定义适配器Implementing your own adapters

为了建立自己的注解适配器或者继承一个已存在的适配器，这个 Phalcon\Annotations\AdapterInterface 接口都必须实现。

The Phalcon\Annotations\AdapterInterface interface must be implemented in order to create your own annotations adapters or extend the existing ones.

外部资源External Resources