├── .gitignore
├── src
    ├── Annotation
    │   ├── Autowire.php
    │   ├── Validator.php
    │   ├── Transaction.php
    │   ├── RequestParam.php
    │   └── DataCache.php
    ├── AnnotationInterceptor.php
    ├── Blocker.php
    ├── ModelAnnotationScaner.php
    ├── ControllerAnnotationScaner.php
    ├── Proxy.php
    └── AnnotationScaner.php
├── composer.json
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | /.idea
2 | /.vscode
3 | /vendor
4 | composer.lock
5 | 


--------------------------------------------------------------------------------
/src/Annotation/Autowire.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fairy\Annotation;
 4 | 
 5 | use Doctrine\Common\Annotations\Annotation\Target;
 6 | 
 7 | /**
 8 |  * 属性自动注入对象
 9 |  * @Annotation
10 |  * @Target("PROPERTY")
11 |  */
12 | class Autowire
13 | {
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/src/AnnotationInterceptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Fairy;
 5 | 
 6 | 
 7 | interface AnnotationInterceptor
 8 | {
 9 |     public function beforeAction($methodName, $arguments, Proxy $proxy);
10 | 
11 |     public function afterAction($result, $methodName, $arguments, Proxy $proxy);
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Blocker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Fairy;
 5 | 
 6 | 
 7 | class Blocker
 8 | {
 9 |     /**
10 |      * 是否需要阻断
11 |      * @var bool
12 |      */
13 |     public $block;
14 | 
15 |     /**
16 |      * 处理好的数据
17 |      * @var mixed
18 |      */
19 |     public $data;
20 | 
21 |     public function __construct($block = false, $data = null)
22 |     {
23 |         $this->block = $block;
24 |         $this->data = $data;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/ModelAnnotationScaner.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fairy;
 4 | 
 5 | trait ModelAnnotationScaner
 6 | {
 7 |     /**
 8 |      * @return static
 9 |      * @throws \ReflectionException
10 |      */
11 |     public static function __make()
12 |     {
13 |         /**@var $annotationScaner AnnotationScaner */
14 |         $annotationScaner = app(AnnotationScaner::class);
15 |         $modelObj = new static();
16 |         $annotationScaner->readPropertiesAnnotation($modelObj);
17 | 
18 |         return $modelObj;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/ControllerAnnotationScaner.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fairy;
 4 | 
 5 | class ControllerAnnotationScaner
 6 | {
 7 |     /**
 8 |      * @param array $call
 9 |      * @throws \ReflectionException
10 |      */
11 |     public function run(array $call)
12 |     {
13 |         /**@var $annotationScaner AnnotationScaner */
14 |         $annotationScaner = app(AnnotationScaner::class);
15 |         list($instance, $action) = $call;
16 |         $annotationScaner->readMethodAnnotation($instance, $action);
17 |         $annotationScaner->readPropertiesAnnotation($instance);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Annotation/Validator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Fairy\Annotation;
 5 | 
 6 | use Doctrine\Common\Annotations\Annotation\Required;
 7 | use Doctrine\Common\Annotations\Annotation\Target;
 8 | 
 9 | /**
10 |  * 控制器方法前自动校验
11 |  * @Annotation
12 |  * @Target("METHOD")
13 |  */
14 | class Validator
15 | {
16 |     /**
17 |      * 验证器类名
18 |      * @Required()
19 |      * @var string
20 |      */
21 |     public $class;
22 | 
23 |     /**
24 |      * 验证场景
25 |      * @var string
26 |      */
27 |     public $scene;
28 | 
29 |     /**
30 |      * 是否批量验证
31 |      * @var bool
32 |      */
33 |     public $batch;
34 | 
35 |     /**
36 |      * 验证失败是否抛出异常
37 |      * @var bool
38 |      */
39 |     public $throw;
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Annotation/Transaction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Fairy\Annotation;
 5 | 
 6 | 
 7 | use Fairy\AnnotationInterceptor;
 8 | use Fairy\Proxy;
 9 | use think\Db;
10 | use think\facade\Log;
11 | 
12 | /**
13 |  * 事务管理
14 |  * @Annotation
15 |  * @Target("METHOD")
16 |  */
17 | class Transaction implements AnnotationInterceptor
18 | {
19 |     public function beforeAction($methodName, $arguments, Proxy $proxy)
20 |     {
21 |         Db::startTrans();
22 |         Log::sql('[ DB ] START TRANSACTION');
23 |     }
24 | 
25 |     public function afterAction($result, $methodName, $arguments, Proxy $proxy)
26 |     {
27 |         if ($result) {
28 |             Db::commit();
29 |             Log::sql('[ DB ] COMMIT TRANSACTION');
30 |         } else {
31 |             Db::rollback();
32 |             Log::sql('[ DB ] ROLLBACK TRANSACTION');
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "cshaptx4869/thinkphp-annotation",
 3 |     "description": "thinkphp5.1 注解插件",
 4 |     "type": "library",
 5 |     "license": [
 6 |         "Apache-2.0"
 7 |     ],
 8 |     "authors": [
 9 |         {
10 |             "name": "cshaptx4869",
11 |             "email": "994774638@qq.com"
12 |         }
13 |     ],
14 |     "require": {
15 |         "php": ">=5.6",
16 |         "ext-json": "*",
17 |         "topthink/framework": "5.1.*",
18 |         "doctrine/annotations": "1.4.0",
19 |         "nikic/php-parser": "v3.1.5"
20 |     },
21 |     "autoload": {
22 |         "psr-4": {
23 |             "Fairy\\": "src"
24 |         }
25 |     },
26 |     "repositories": [
27 |         {
28 |             "type": "composer",
29 |             "url": "https://mirrors.aliyun.com/composer/"
30 |         },
31 |         {
32 |             "type": "composer",
33 |             "url": "https://packagist.phpcomposer.com"
34 |         }
35 |     ]
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Annotation/RequestParam.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Fairy\Annotation;
 5 | 
 6 | use Doctrine\Common\Annotations\Annotation\Enum;
 7 | use Doctrine\Common\Annotations\Annotation\Target;
 8 | 
 9 | /**
10 |  * @Annotation
11 |  * @Target("METHOD")
12 |  */
13 | class RequestParam
14 | {
15 |     /**
16 |      * 要获取的字段名
17 |      * @var array
18 |      */
19 |     public $fields;
20 | 
21 |     /**
22 |      * 字段映射关系
23 |      * @var array
24 |      */
25 |     public $mapping;
26 | 
27 |     /**
28 |      * 格式化json数据
29 |      *
30 |      * 使用示例：
31 |      * json:{field1,field2,...fieldn}
32 |      * 表示格式化field1,field2,...字段的json数据
33 |      *
34 |      * 支持json一维和二维字段的涮选
35 |      * json:{field1:{childField1,childField2...}}
36 |      * 表示格式化field1字段的json数据，并只获取field1字段下的childField1和childField2下标的值
37 |      *
38 |      * @var array
39 |      */
40 |     public $json;
41 | 
42 |     /**
43 |      * 获取参数的方法 不填默认是param形式获取
44 |      * @Enum({"get","post","put","delete"})
45 |      * @var string
46 |      */
47 |     public $method;
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Annotation/DataCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Fairy\Annotation;
 5 | 
 6 | 
 7 | use Doctrine\Common\Annotations\Annotation\Target;
 8 | use Fairy\AnnotationInterceptor;
 9 | use Fairy\Proxy;
10 | use Fairy\Blocker;
11 | use think\facade\Cache;
12 | 
13 | /**
14 |  * 方法数据缓存
15 |  * @Annotation
16 |  * @Target("METHOD")
17 |  */
18 | class DataCache implements AnnotationInterceptor
19 | {
20 |     /**
21 |      * 键名 支持变量模板的形式
22 |      * 如 ${0} 表示方法的第一个参数
23 |      * @var string
24 |      */
25 |     public $name;
26 | 
27 |     /**
28 |      * 生存周期(s,m,h,d) 默认0
29 |      * @var string
30 |      */
31 |     public $expire;
32 | 
33 |     public function beforeAction($methodName, $arguments, Proxy $proxy)
34 |     {
35 |         $result = Cache::get($this->getKeyName($proxy->getClass(), $methodName, $arguments));
36 | 
37 |         return new Blocker($result ? true : false, $result);
38 |     }
39 | 
40 |     public function afterAction($result, $methodName, $arguments, Proxy $proxy)
41 |     {
42 |         Cache::set($this->getKeyName($proxy->getClass(), $methodName, $arguments), $result, $this->transExpire());
43 |     }
44 | 
45 |     protected function getKeyName($className, $methodName, $arguments)
46 |     {
47 |         $key = $this->name ? preg_replace_callback('/\${(\d)}/', function ($matches) use ($arguments) {
48 |             return isset($arguments[$matches[1]]) ? $arguments[$matches[1]] : $matches[0];
49 |         }, $this->name) : $methodName;
50 | 
51 |         return $className . ':' . $methodName . ':' . $key;
52 |     }
53 | 
54 |     protected function transExpire()
55 |     {
56 |         $pattern = '/^(\d+)([a-zA-Z]*)$/';
57 |         if (!preg_match($pattern, $this->expire, $matches)) {
58 |             return 0;
59 |         }
60 | 
61 |         $result = $matches[1];
62 |         if (!$matches[2]) {
63 |             return $result;
64 |         }
65 | 
66 |         switch ($matches[2]) {
67 |             case 'm':
68 |                 $result *= 60;
69 |                 break;
70 |             case 'h':
71 |                 $result *= 60 * 60;
72 |                 break;
73 |             case 'd':
74 |                 $result *= 24 * 60 * 60;
75 |                 break;
76 |         }
77 | 
78 |         return $result;
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/Proxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Fairy;
 5 | 
 6 | 
 7 | class Proxy
 8 | {
 9 |     private $bean;
10 | 
11 |     public function __construct($bean)
12 |     {
13 |         $this->bean = $bean;
14 |     }
15 | 
16 |     public function __call($methodName, $arguments)
17 |     {
18 |         /**@var $annotationScaner AnnotationScaner */
19 |         $annotationScaner = app(AnnotationScaner::class);
20 |         $interceptorAnnotationObjs = $annotationScaner->readMethodAnnotation($this->bean, $methodName);
21 | 
22 |         return $this->callMethod($methodName, $arguments, $interceptorAnnotationObjs);
23 |     }
24 | 
25 |     /**
26 |      * 执行拦截器并返回方法执行的结果
27 |      * @param $methodName
28 |      * @param $arguments
29 |      * @param array $annotations
30 |      * @return bool|mixed
31 |      */
32 |     private function callMethod($methodName, $arguments, $annotations = [])
33 |     {
34 |         $isBlocked = false;
35 |         $data = null;
36 | 
37 |         foreach ($annotations as $annotation) {
38 |             $beforeActionData = call_user_func_array([$annotation, 'beforeAction'], [$methodName, $arguments, $this]);
39 |             if ($beforeActionData !== null && $beforeActionData instanceof Blocker) {
40 |                 if (isset($beforeActionData->data)) {
41 |                     $data = $beforeActionData->data;
42 |                 }
43 |                 if ($beforeActionData->block) {
44 |                     $isBlocked = true;
45 |                     break;
46 |                 }
47 |             }
48 |         }
49 | 
50 |         if ($isBlocked) {
51 |             $result = $data;
52 |         } else {
53 |             try {
54 |                 $result = call_user_func_array([$this->bean, $methodName], $arguments);
55 |             } catch (\Exception $e) {
56 |                 $result = false;
57 |             }
58 |             foreach (array_reverse($annotations) as $annotation) {
59 |                 $afterActionData = call_user_func_array([$annotation, 'afterAction'], [$result, $methodName, $arguments, $this]);
60 |                 if ($afterActionData) {
61 |                     $result = $afterActionData;
62 |                 }
63 |             }
64 |         }
65 | 
66 |         return $result;
67 |     }
68 | 
69 |     public function getBean()
70 |     {
71 |         return $this->bean;
72 |     }
73 | 
74 |     public function getClass()
75 |     {
76 |         return get_class($this->bean);
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # thinkphp-annotation
  2 | 
  3 | 
  4 | 
  5 | 前言:
  6 | -------
  7 | 
  8 | thinkphp5.1中用注解的方式实现：
  9 | 
 10 | - 请求数据验证
 11 | - 请求数据过滤、格式化
 12 | - 属性对象自动注入
 13 | - 自动事务
 14 | 
 15 | > 最新文档地址：https://www.cnblogs.com/cshaptx4869/p/12178960.html 
 16 | 
 17 | 
 18 | 
 19 | 安装
 20 | ------------
 21 | 
 22 | ```bash
 23 | composer require cshaptx4869/thinkphp-annotation
 24 | ```
 25 | 
 26 | 
 27 | 
 28 | ## 配置
 29 | 
 30 | `tags.php `添加行为，用于控制器注解扫描
 31 | 
 32 | ```php
 33 | 'action_begin' => [
 34 |      \Fairy\ControllerAnnotationScaner::class
 35 | ]
 36 | ```
 37 | 
 38 | 模型中使用属性注解的话，需要在模型中引入 \Fairy\ModelAnnotationScaner 的trait
 39 | 
 40 | ```php
 41 | use \Fairy\ModelAnnotationScaner;
 42 | ```
 43 | 
 44 | 添加 `system.php` 配置文件（可选）
 45 | 
 46 | ```php
 47 | return [
 48 |     'annotation' => [
 49 |         'cache' => false,// 是否开启注解读取缓存，默认false
 50 |         'writelist' => []// 注解读取白名单，默认[]
 51 |         'interceptor' => [// 注解拦截器相关配置
 52 |             'enable' => true,// 默认开启注解拦截器
 53 |             'whitelist' => []// 注解拦截器白名单，默认[]
 54 |         ],
 55 |         'validate' => [
 56 |             'callback' => function($msg) {
 57 |             	// 自定义验证错误信息后续处理
 58 |             }
 59 |         ]
 60 |     ]
 61 | ]
 62 | ```
 63 | 
 64 | > PS：默认验证器注解验证不通过会终止程序运行并返回`json`格式的验证错误信息。可通过配置 callback函数自定义后续处理。请注意，不同版本使用上会有些许差别。
 65 | >
 66 | 
 67 | 
 68 | 
 69 | ## 支持的注解
 70 | 
 71 | ###### v0.1.0版：
 72 | 
 73 | | 注解名           | 申明范围 | 作用                         |
 74 | | ---------------- | -------- | ---------------------------- |
 75 | | @Autowire        | 属性     | 自动注入类对象               |
 76 | | @DynamicAutowire | 方法     | 声明当前方法允许属性注入的类 |
 77 | | @IgnoreAutowire  | 方法     | 声明当前方法忽略属性注入的类 |
 78 | | @RequestParam    | 方法     | 过滤、格式化请求参数         |
 79 | | @Validator       | 方法     | 验证器验证                   |
 80 | 
 81 | ###### v0.1.1版：
 82 | 
 83 | | 注解名        | 申明范围 | 作用                 |
 84 | | ------------- | -------- | -------------------- |
 85 | | @RequestParam | 方法     | 过滤、格式化请求参数 |
 86 | | @Validator    | 方法     | 验证器验证           |
 87 | | @Autowire     | 属性     | 自动注入类对象       |
 88 | | @Transaction  | 方法     | 自动事务             |
 89 | 
 90 | > #### 版本差异：
 91 | >
 92 | > v0.1.1新增：
 93 | >
 94 | > **Transaction 注解**
 95 | >
 96 | > Transaction 注解根据当前方法返回值自动判断事务后续处理，如返回值等价于true就会自动commit，否则rollback。 
 97 | >
 98 | > Transaction 注解需要搭配 Autowire注解使用，且不支持在控制器中使用，推荐在模型中使用。
 99 | >
100 | > **ModelAnnotationScaner**  
101 | >
102 | > 支持模型中使用属性注解
103 | >
104 | > 
105 | >
106 | > Autowire 注解改动：
107 | >
108 | > v0.1.0 版本中 Autowire 注解必须写class属性，如 Autowire(class=ArticleModel::class)，而在v0.1.1版本中 Autowire 注解则没有class属性而是通过@var ArticleModel 注解来自动识别。
109 | 
110 | 
111 | 
112 | ## v0.1.0版本使用示例
113 | 
114 | `ArticleController` 控制器：
115 | 
116 | ```php
117 | <?php
118 | 
119 | namespace app\index\controller;
120 | 
121 | use app\index\validate\Article\SaveValidate;
122 | use app\common\model\ArticleModel;
123 | // 引入对应的注解
124 | use Fairy\Annotation\Autowire;
125 | use Fairy\Annotation\RequestParam;
126 | use Fairy\Annotation\Validator;
127 | use think\Request;
128 | 
129 | class ArticleController
130 | {
131 |     /**
132 |      * 属性对象注入
133 |      * @Autowire(class=ArticleModel::class)
134 |      */
135 |     public $articleModel;
136 |     
137 |     /**
138 |      * 数据验证
139 |      * clsss: thinkphp定义的验证器类名(必填) string类型
140 |      * scene: 验证场景名 string类型
141 |      * batch：是否批量验证 bool类型
142 |      * throw: 验证失败是否抛出异常 bool类型
143 |      * @Validator(
144 |      *     class=SaveValidate::class,
145 |      *     scene="save",
146 |      *     batch=false,
147 |      *     throw=false
148 |      * )
149 |      *
150 |      * 获取参数
151 |      * fields: 定义要获取的字段名，可批量设置默认值 array类型
152 |      * mapping: 转换前台传递的字段名为自定义的字段名 array类型
153 |      * method: 获取参数的方法,支持get、post、put、delte string类型
154 |      * json: 格式化json字段的数据 array类型
155 |      * 
156 |      * json使用示例：
157 |      * json:{field1,field2,...fieldn}
158 |      * 表示格式化field1,field2,...,字段的json数据
159 |      *
160 |      * 支持json一维和二维字段的涮选，如
161 |      * json:{field1:{childField1,childField2...}}
162 |      * 表示格式化field1字段的json数据，并只获取field1字段下的childField1和childField2下标的值(支持深度一维和二维,会自动识别)
163 |      *
164 |      * @RequestParam(
165 |      *     fields={"title","image_url","content","category_id","is_temporary","extra":"默认值"},
166 |      *     json={"category_id"},
167 |      *     mapping={"image_url":"img_url"},
168 |      *     method="post"
169 |      * )
170 |      */
171 |     public function save(Request $request)
172 |     {
173 |         //获取过滤过后的参数
174 |         $postData = $request->requestParam;
175 | 
176 |         return MyToolkit::success($this->articleModel->store($postData));
177 |     }
178 | ```
179 | 
180 | 
181 | 
182 | ## v0.1.1版本使用示例
183 | 
184 | `ArticleController` 控制器：
185 | 
186 | ```php
187 | <?php
188 | 
189 | namespace app\index\controller;
190 | 
191 | use app\index\validate\Article\SaveValidate;
192 | use app\common\model\ArticleModel;
193 | // 引入对应的注解
194 | use Fairy\Annotation\Autowire;
195 | use Fairy\Annotation\RequestParam;
196 | use Fairy\Annotation\Validator;
197 | use think\Request;
198 | 
199 | class ArticleController
200 | {
201 |     /**
202 |      * 属性对象注入
203 |      * @Autowire()
204 |      * @var ArticleModel
205 |      */
206 |     public $articleModel;
207 |     
208 |     /**
209 |      * 数据验证
210 |      * clsss: thinkphp定义的验证器类名(必填) string类型
211 |      * scene: 验证场景名 string类型
212 |      * batch：是否批量验证 bool类型
213 |      * throw: 验证失败是否抛出异常 bool类型
214 |      * @Validator(
215 |      *     class=SaveValidate::class,
216 |      *     scene="save",
217 |      *     batch=false,
218 |      *     throw=false
219 |      * )
220 |      *
221 |      * 获取参数
222 |      * fields: 定义要获取的字段名，可批量设置默认值 array类型
223 |      * mapping: 转换前台传递的字段名为自定义的字段名 array类型
224 |      * method: 获取参数的方法,支持get、post、put、delte string类型
225 |      * json: 格式化json字段的数据 array类型
226 |      * 
227 |      * json使用示例：
228 |      * json:{field1,field2,...fieldn}
229 |      * 表示格式化field1,field2,...,字段的json数据
230 |      *
231 |      * 支持json一维和二维字段的涮选，如
232 |      * json:{field1:{childField1,childField2...}}
233 |      * 表示格式化field1字段的json数据，并只获取field1字段下的childField1和childField2下标的值(支持深度一维和二维,会自动识别)
234 |      *
235 |      * @RequestParam(
236 |      *     fields={"title","image_url","content","category_id","is_temporary","extra":"默认值"},
237 |      *     json={"category_id"},
238 |      *     mapping={"image_url":"img_url"},
239 |      *     method="post"
240 |      * )
241 |      */
242 |     public function save(Request $request)
243 |     {
244 |         //获取过滤过后的参数
245 |         $postData = $request->requestParam;
246 | 
247 |         return MyToolkit::success($this->articleModel->store($postData));
248 |     }
249 | }
250 | ```
251 | 
252 | `ArticleModel` 模型：
253 | 
254 | ```php
255 | <?php
256 | 
257 | namespace app\common\model;
258 | 
259 | use Fairy\Annotation\Autowire;
260 | use Fairy\Annotation\Transaction;
261 | use Fairy\ModelAnnotationScaner;
262 | use think\Db;
263 | use think\Model;
264 | 
265 | class ArticleModel extends Model
266 | {
267 |     // 引入支持模型的属性使用注解的trait
268 |     use ModelAnnotationScaner;
269 | 
270 |     /**
271 |      * 注入对象
272 |      * @Autowire()
273 |      * @var ArticleCategoryRelationModel
274 |      */
275 |     public $articleCategoryRelationModel;
276 |     
277 |     /**
278 |      * 注解控制事务
279 |      * 返回值等价于true 事务自动 commit 否则 rollback
280 |      * @Transaction()
281 |      */
282 |     public function store(array $params)
283 |     {
284 |         $categoryIds = $params['category_id'];
285 |         unset($params['category_id']);
286 |         $articleId = Db::name('article')->insertGetId($params);
287 |         $realtion = array_map(function ($categoryId) use ($articleId) {
288 |             return [
289 |                 'article_id' => $articleId,
290 |                 'category_id' => $categoryId
291 |             ];
292 |         }, $categoryIds);
293 | 
294 |         return $this->articleCategoryRelationModel->store($realtion);
295 |     }
296 | }
297 | ```
298 | 
299 | 
300 | 
301 | ## IDE 注解插件支持
302 | 
303 | 一些ide已经提供了对注释的支持，推荐安装，以便提供注解语法提示
304 | 
305 | - Eclipse via the [Symfony2 Plugin](http://symfony.dubture.com/)
306 | - PHPStorm via the [PHP Annotations Plugin](http://plugins.jetbrains.com/plugin/7320) or the [Symfony2 Plugin](http://plugins.jetbrains.com/plugin/7219)
307 | 
308 | 


--------------------------------------------------------------------------------
/src/AnnotationScaner.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fairy;
  4 | 
  5 | use Doctrine\Common\Annotations\AnnotationReader;
  6 | use Doctrine\Common\Annotations\AnnotationRegistry;
  7 | use Doctrine\Common\Annotations\FileCacheReader;
  8 | use Fairy\Annotation\Autowire;
  9 | use Fairy\Annotation\RequestParam;
 10 | use Fairy\Annotation\Validator;
 11 | use PhpParser\Node\Stmt\Namespace_;
 12 | use PhpParser\Node\Stmt\Use_;
 13 | use PhpParser\Parser;
 14 | use PhpParser\ParserFactory;
 15 | use think\exception\ValidateException;
 16 | use think\Validate;
 17 | 
 18 | class AnnotationScaner
 19 | {
 20 |     /**
 21 |      * @var $annotationReader FileCacheReader|AnnotationReader
 22 |      */
 23 |     protected $annotationReader;
 24 | 
 25 |     /**
 26 |      * @var Parser
 27 |      */
 28 |     protected $parser;
 29 | 
 30 |     protected $proxy = [];
 31 | 
 32 |     /**
 33 |      * 注解读取白名单
 34 |      * @var array
 35 |      */
 36 |     protected $whitelist = [
 37 |         "author", "var", "after", "afterClass", "backupGlobals", "backupStaticAttributes", "before", "beforeClass", "codeCoverageIgnore*",
 38 |         "covers", "coversDefaultClass", "coversNothing", "dataProvider", "depends", "doesNotPerformAssertions",
 39 |         "expectedException", "expectedExceptionCode", "expectedExceptionMessage", "expectedExceptionMessageRegExp", "group",
 40 |         "large", "medium", "preserveGlobalState", "requires", "runTestsInSeparateProcesses", "runInSeparateProcess", "small",
 41 |         "test", "testdox", "testWith", "ticket", "uses"
 42 |     ];
 43 | 
 44 |     public function __construct()
 45 |     {
 46 |         $this->init();
 47 |     }
 48 | 
 49 |     protected function init()
 50 |     {
 51 |         AnnotationRegistry::registerLoader('class_exists');
 52 | //        AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Route.php'); //注册文件
 53 | //        AnnotationRegistry::registerAutoloadNamespace('Faily\\Annotation'); //注册命名空间
 54 | //        AnnotationRegistry::registerAutoloadNamespaces(['Faily\\Annotation' => null]); //注册多个命名空间
 55 |         // 注解读取白名单
 56 |         $this->setWhiteList();
 57 |         // 注解读取器
 58 |         $this->annotationReader = config('system.annotation.cache') ?
 59 |             new FileCacheReader(new AnnotationReader(), env('runtime_path') . DIRECTORY_SEPARATOR . "annotation", true) :
 60 |             new AnnotationReader();
 61 |         $this->parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP5);
 62 |     }
 63 | 
 64 |     /**
 65 |      * 读取类的所有属性的注解
 66 |      * @param $instance
 67 |      * @throws \ReflectionException
 68 |      */
 69 |     public function readPropertiesAnnotation($instance)
 70 |     {
 71 |         $reflectionClass = new \ReflectionClass($instance);
 72 |         $reflectionProperties = $reflectionClass->getProperties();
 73 |         foreach ($reflectionProperties as $reflectionProperty) {
 74 |             $propertyAnnotations = $this->annotationReader->getPropertyAnnotations($reflectionProperty);
 75 |             foreach ($propertyAnnotations as $propertyAnnotation) {
 76 |                 if ($propertyAnnotation instanceof Autowire) {
 77 |                     if ($reflectionProperty->isPublic() && !$reflectionProperty->isStatic()) {
 78 |                         if ($class = $this->getPropertyType($reflectionClass->getFileName(), $reflectionClass->getNamespaceName(), $reflectionProperty->getDocComment())) {
 79 |                             if (isset($this->proxy[$class])) {
 80 |                                 $reflectionProperty->setValue($instance, $this->proxy[$class]);
 81 |                             } else {
 82 |                                 $proxyObj = new Proxy(app($class));
 83 |                                 $this->proxy[$class] = $proxyObj;
 84 |                                 $reflectionProperty->setValue($instance, $proxyObj);
 85 |                             }
 86 |                         }
 87 |                     }
 88 |                 }
 89 |             }
 90 |         }
 91 |     }
 92 | 
 93 |     /**
 94 |      * 读取当前方法的注解 如果有拦截器注解则返回拦截器注解对象数组
 95 |      * @param $instance
 96 |      * @param $method
 97 |      * @return array
 98 |      * @throws \ReflectionException
 99 |      */
100 |     public function readMethodAnnotation($instance, $method)
101 |     {
102 |         $reflectionMethod = new \ReflectionMethod($instance, $method);
103 |         $methodAnnotations = $this->annotationReader->getMethodAnnotations($reflectionMethod);
104 |         $interceptorEnable = config('?system.annotation.interceptor.enable') ? config('system.annotation.interceptor.enable') : true;
105 |         $interceptorWhitelist = config('?system.annotation.interceptor.whitelist') ? config('system.annotation.interceptor.whitelist') : [];
106 |         $validateErrorMsgCallback = config('?system.annotation.validate.callback') ? config('system.annotation.validate.callback') : [];
107 |         $interceptorAnnotationObjs = [];
108 |         foreach ($methodAnnotations as $methodAnnotation) {
109 |             if (!$methodAnnotation instanceof AnnotationInterceptor) {
110 |                 if ($methodAnnotation instanceof Validator) {// 验证器
111 |                     /**@var $validate \think\validate */
112 |                     $validate = app($methodAnnotation->class);
113 |                     if (!$validate instanceof Validate) {
114 |                         throw new \Exception('class ' . $methodAnnotation->class . ' is not a thinkphp validate class');
115 |                     }
116 |                     if ($methodAnnotation->batch) {
117 |                         $validate->batch();
118 |                     }
119 |                     if ($methodAnnotation->scene) {
120 |                         $validate->scene($methodAnnotation->scene);
121 |                     }
122 |                     if (!$validate->check(app('request')->param())) {
123 |                         if ($methodAnnotation->throw) {
124 |                             throw new ValidateException($validate->getError());
125 |                         } else {
126 |                             if ($validateErrorMsgCallback && $validateErrorMsgCallback instanceof \Closure) {
127 |                                 call_user_func($validateErrorMsgCallback, $validate->getError());
128 |                             } else {
129 |                                 exit($this->formatErrorMsg($validate->getError()));
130 |                             }
131 |                         }
132 |                     }
133 |                 } else if ($methodAnnotation instanceof RequestParam) {// 参数获取器
134 |                     $requestParams = app('request')->only($methodAnnotation->fields, $methodAnnotation->method ?: 'param');
135 |                     if ($formatRules = $methodAnnotation->json) {
136 |                         $this->formatRequestParams($formatRules, $requestParams);
137 |                     }
138 |                     if ($methodAnnotation->mapping) {
139 |                         $mapping = [];
140 |                         foreach ($requestParams as $key => $value) {
141 |                             if (isset($methodAnnotation->mapping[$key])) {
142 |                                 $mapping[$methodAnnotation->mapping[$key]] = $value;
143 |                             } else {
144 |                                 $mapping[$key] = $value;
145 |                             }
146 |                         }
147 |                         $requestParams = $mapping;
148 |                     }
149 |                     app('request')->requestParam = $requestParams;
150 |                 }
151 |             } else {
152 |                 if ($interceptorEnable && !in_array(get_class($methodAnnotation), $interceptorWhitelist)) {
153 |                     $interceptorAnnotationObjs[] = $methodAnnotation;
154 |                 }
155 |             }
156 |         }
157 | 
158 |         return $interceptorAnnotationObjs;
159 |     }
160 | 
161 |     /**
162 |      * 设置注解读取白名单
163 |      * @return array
164 |      */
165 |     protected function setWhiteList()
166 |     {
167 |         if ($whitelist = config('system.annotation.whitelist')) {
168 |             $this->whitelist = array_merge($this->whitelist, $whitelist);
169 |         }
170 |         foreach ($this->whitelist as $v) {
171 |             AnnotationReader::addGlobalIgnoredName($v);
172 |         }
173 |     }
174 | 
175 |     /**
176 |      * 格式化错误信息
177 |      * @param string $msg
178 |      * @return false|string
179 |      */
180 |     protected function formatErrorMsg($msg = '')
181 |     {
182 |         return json_encode([
183 |             'code' => 422, 'data' => '', 'msg' => $msg, 'time' => request()->time()
184 |         ]);
185 |     }
186 | 
187 |     /**
188 |      * 格式化请求参数
189 |      * @param array $rules
190 |      * @param $requestParams
191 |      * @throws \Exception
192 |      */
193 |     protected function formatRequestParams(array $rules, &$requestParams)
194 |     {
195 |         foreach ($rules as $field => $rule) {
196 |             if (is_int($field)) {
197 |                 $field = (string)$rule;
198 |             }
199 |             if (isset($requestParams[$field])) {
200 |                 $data = json_decode($requestParams[$field], true);
201 |                 if (is_null($data)) {
202 |                     throw new \Exception($field . '字段的值无法json反序列化');
203 |                 }
204 |                 // 过滤json数据的字段
205 |                 if (is_array($rule) && $rule) {
206 |                     foreach ($data as $k => $v) {
207 |                         if (is_string($k)) {//一维数组
208 |                             if (!in_array($k, $rule)) {
209 |                                 unset($data[$k]);
210 |                             }
211 |                         } else if (is_int($k) && is_array($v)) {//二维数组
212 |                             foreach ($v as $kk => $vv) {
213 |                                 if (!in_array($kk, $rule)) {
214 |                                     unset($data[$k][$kk]);
215 |                                 }
216 |                             }
217 |                         }
218 |                     }
219 |                 }
220 |                 $requestParams[$field] = $data;
221 |             }
222 |         }
223 |     }
224 | 
225 |     /**
226 |      * 获取属性声明的var类型
227 |      * @param $filepath
228 |      * @param $namespace
229 |      * @param $doc
230 |      * @return bool|mixed|string
231 |      */
232 |     protected function getPropertyType($filepath, $namespace, $doc)
233 |     {
234 |         if (!preg_match('/@var\s+(\S+)\s+/', $doc, $matches)) {
235 |             return false;
236 |         }
237 |         $type = $matches[1];
238 |         if (!(strpos($type, '\\') === 0)) {
239 |             $stmts = $this->parser->parse(file_get_contents($filepath));
240 |             $uses = $this->getUses($stmts);
241 |             if (array_key_exists($type, $uses)) {
242 |                 $type = $uses[$type];
243 |             } else {
244 |                 $type = $namespace . '\\' . $type;
245 |             }
246 |         }
247 | 
248 |         return $type;
249 |     }
250 | 
251 |     /**
252 |      * 获取类中的use信息
253 |      * @param $stmts
254 |      * @return array
255 |      */
256 |     protected function getUses($stmts)
257 |     {
258 |         $uses = [];
259 |         foreach ($stmts as $v) {
260 |             if ($v instanceof Namespace_) {
261 |                 foreach ($v->stmts as $vv) {
262 |                     if ($vv instanceof Use_) {
263 |                         foreach ($vv->uses as $vvv) {
264 |                             $name = implode('\\', $vvv->name->parts);
265 |                             if ($vvv->alias) {
266 |                                 $alias = $vvv->alias;
267 |                             } else {
268 |                                 $pos = strrpos($name, '\\');
269 |                                 $alias = substr($name, $pos ? $pos + 1 : 0);
270 |                             }
271 |                             $uses[$alias] = $name;
272 |                         }
273 |                     }
274 |                 }
275 |             }
276 |         }
277 | 
278 |         return $uses;
279 |     }
280 | }
281 | 


--------------------------------------------------------------------------------