发表更新Php10 分钟读完 (大约1533个字)

php反射实现Ioc-Di及注解

PHP5之后提供了完整的反射API，添加了对类、接口、函数、方法和扩展进行反向工程的能力。此外，反射API提供了方法来取出函数、类和方法的文档注释。

Ioc/Di大家应该都不陌生，但是对小白来说呢听起来就挺高大上的，下面就用代码来实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
<?php
/**
 * @author gaobinzhan <gaobinzhan@gmail.com>
 */

class Foo
{
    public function getClassName()
    {
        return 'this is Foo';
    }
}

class Bar
{
    public function getClassName()
    {
        return 'this is Bar';
    }
}

class Test
{
    public function __construct(Foo $foo, Bar $bar)
    {
        var_dump($foo->getClassName());
        var_dump($bar->getClassName());
    }

    public function index(Foo $foo)
    {
        var_dump($foo->getClassName());
    }
}

// 反射Test
$reflect = new ReflectionClass(Test::class);
// 获取是否有构造函数
$constructor = $reflect->getConstructor();
if ($constructor) {
    // 如果存在构造 获取参数
    $constructorParams = $constructor->getParameters();
    // 初始化注入的参数
    $args = [];
    // 循环去判断参数
    foreach ($constructorParams as $param) {
        // 如果为class 就进行实例化
        if ($param->getClass()) {
            $args[] = $param->getClass()->newInstance();
        } else {
            $args[] = $param->getName();
        }
    }
    // 实例化注入参数
    $class = $reflect->newInstanceArgs($args);
} else {
    $class = $reflect->newInstance();
}


// 假设我们要调用index方法 在此之前自己判断下方法是否存在 我省略了
$reflectMethod = new ReflectionMethod($class, 'index');
// 判断方法修饰符是否为public
if ($reflectMethod->isPublic()) {
    // 以下代码同等上面
    $args = [];
    $methodParams = $reflectMethod->getParameters();
    foreach ($methodParams as $param) {
        if ($param->getClass()) {
            $args[] = $param->getClass()->newInstance();
        } else {
            $args[] = $param->getName();
        }
    }
    $reflectMethod->invokeArgs($class, $args);
}

以上就简单的实现了依赖注入，下面我们接着封装一下。

Ioc.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
<?php
/**
 * @author gaobinzhan <gaobinzhan@gmail.com>
 */

class Ioc
{
    public static function getInstance($className)
    {
        $args = self::getMethodParams($className);
        return (new ReflectionClass($className))->newInstanceArgs($args);
    }

    public static function make($className, $methodName, $params = []) {

        // 获取类的实例
        $instance = self::getInstance($className);

        // 获取该方法所需要依赖注入的参数
        $args = self::getMethodParams($className, $methodName);

        return $instance->{$methodName}(...array_merge($args, $params));
    }

    protected static function getMethodParams($className, $methodsName = '__construct')
    {

        // 通过反射获得该类
        $class = new ReflectionClass($className);
        $args = []; // 记录注入的参数

        // 判断该类是否有构造函数
        if ($class->hasMethod($methodsName)) {
            // 构造函数存在 进行获取
            $construct = $class->getMethod($methodsName);

            // 获取构造函数的参数
            $params = $construct->getParameters();

            // 构造函数无参数 直接返回
            if (!$params) return $args;

            // 判断参数类型
            foreach ($params as $param) {

                // 假设参数为类
                if ($paramClass = $param->getClass()) {

                    // 获得参数类型名称
                    $paramClassName = $paramClass->getName();
                    // 如果注入的这个参数也是个类 就要继续判断是否存在构造函数
                    $methodArgs = self::getMethodParams($paramClassName);

                    // 存入数组中
                    $args[] = (new ReflectionClass($paramClass->getName()))->newInstanceArgs($methodArgs);
                }
            }
        }
        // 返回参数
        return $args;
    }
}

以上代码实现了构造函数的依赖注入及方法的依赖注入，下面进行测试。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
class Bar
{
    public function getClassName()
    {
        return 'this is Bar';
    }
}

class Test
{
    public function __construct(Foo $foo, Bar $bar)
    {
        var_dump($foo->getClassName());
        var_dump($bar->getClassName());
    }

    public function index(Foo $foo)
    {
        var_dump($foo->getClassName());
    }
}
Ioc::getInstance(Test::class);
Ioc::make(Test::class,'index');

以上呢，就简单的通过php的反射机制实现了依赖注入。

继基于swoole的微服务框架出现，注解呢就开始慢慢出现在我们的视角里。据说php8也加入了注解支持：

1
2
3
4
5
6
7
8
9
10
use \Support\Attributes\ListensTo;

class ProductSubscriber
{
    <<ListensTo(ProductCreated::class)>>
    public function onProductCreated(ProductCreated $event) { /* … */ }

    <<ListensTo(ProductDeleted::class)>>
    public function onProductDeleted(ProductDeleted $event) { /* … */ }
}

就类似这样的，哈哈哈。

而我们现在的注解则是通过反射拿到注释去做到的解析。

接下来我们去用别人写好的组件去实现annotations

编写我们的composer.json：

1
2
3
4
5
6
7
8
9
10
11
{
    "require": {
        "doctrine/annotations": "^1.8"
    },
    "autoload": {
        "psr-4": {
            "app\\": "app/",
            "library\\": "library/"
        }
    }
}

接下来要执行啥？？？这个你要是再不会，真的我劝你回家种地吧！！哈哈哈 闹着玩呢！

composer install

然后我们接下来去创建目录：

1
2
3
4
5
6
7
8
9
10
11
12
- app // app目录
	- Http
		- HomeController.php
- library // 核心注解库
	- annotation
		- Mapping
			- Controller.php
			- RequestMapping.php
		- Parser
- vendor
- composer.json
- index.php // 测试文件

php-annotation目录

害 图片有点大。。。。。咋整。。。算了，就这样吧！！！

温馨提示：在phpstrom里面，安装插件PHP Annotation写代码会更友好啊！！

创建library\Mapping\Controller.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?php
/**
 * @author gaobinzhan <gaobinzhan@gmail.com>
 */


namespace library\annotation\Mapping;


use Doctrine\Common\Annotations\Annotation\Attribute;
use Doctrine\Common\Annotations\Annotation\Attributes;
use Doctrine\Common\Annotations\Annotation\Required;
use Doctrine\Common\Annotations\Annotation\Target;

/**
 * Class Controller
 * @package library\annotation\Mapping
 * @Attributes({
 *     @Attribute("prefix", type="string"),
 * })
 * @Annotation
 * @Target("CLASS")
 */
final class Controller
{
    /**
     * @Required()
     * @var string
     */
    private $prefix = '';
    public function __construct(array $value)
    {
        if (isset($value['value'])) $this->prefix = $value['value'];
        if (isset($value['prefix'])) $this->prefix = $value['prefix'];
    }

    public function getPrefix(){
        return $this->prefix;
    }
}

@Annotation表示这是个注解类，让IDE提示更加友好！

@Target表示这个注解类只能被类使用！

@Required表示这个属性是必须填写的！

@Attributes表示这个注解类有多少个属性！

创建library\Mapping\RequestMapping.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?php
/**
 * @author gaobinzhan <gaobinzhan@gmail.com>
 */


namespace library\annotation\Mapping;


use Doctrine\Common\Annotations\Annotation\Required;
use Doctrine\Common\Annotations\Annotation\Target;

/**
 * Class RequestMapping
 * @package library\annotation\Mapping
 * @Annotation
 * @Attributes({
 *     @Attribute("route", type="string"),
 * })
 * @Target("METHOD")
 */
final class RequestMapping
{
    /**
     * @Required()
     */
    private $route;
    public function __construct(array $value)
    {
        if (isset($value['value'])) $this->route = $value['value'];
        if (isset($value['route'])) $this->route = $value['route'];
    }

    public function getRoute(){
        return $this->route;
    }
}

这里的代码就不用再重复解释了吧！我偏不解释了！哈哈哈

创建app\Http\HomeController.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?php
/**
 * @author gaobinzhan <gaobinzhan@gmail.com>
 */


namespace app\Http;


use library\annotation\Mapping\Controller;
use library\annotation\Mapping\RequestMapping;

/**
 * Class HomeController
 * @package app\Http
 * @Controller(prefix="/home")
 */
class HomeController
{
    /**
     * @RequestMapping(route="/test")
     */
    public function test(){
        echo 111;
    }
}

这里代码没啥解释的。。。

哈哈，下面来测试我们的结果！

index.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<?php
/**
 * @author gaobinzhan <gaobinzhan@gmail.com>
 */

$loader = require './vendor/autoload.php';

// 获取一个反射类
$refClass = new \ReflectionClass('\app\Http\HomeController');

// 注册load
\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader([$loader, 'loadClass']);

// new 我们的注解读取器
$reader = new \Doctrine\Common\Annotations\AnnotationReader();

// 获取该类上的所有注解
$classAnnotations = $reader->getClassAnnotations($refClass);

// 这是个循环 说明$classAnnotations是个数组
foreach ($classAnnotations as $annotation){
    // 因为我们定义了Controller注解类 要判断好啊
    if ($annotation instanceof \library\annotation\Mapping\Controller){
        // 获取我们的 prefix 这地方能看懂吧。。。
        echo $routePrefix = $annotation->getPrefix().PHP_EOL;
        // 获取类中所有方法
        $refMethods = $refClass->getMethods();
    }

    // 进行循环
    foreach ($refMethods as $method){
        // 获取方法上的所有注解
        $methodAnnotations = $reader->getMethodAnnotations($method);
        // 循环
        foreach ($methodAnnotations as $methodAnnotation){
            if ($methodAnnotation instanceof \library\annotation\Mapping\RequestMapping){
                // 输出我们的route
                echo $methodAnnotation->getRoute().PHP_EOL;
            }
        }
    }
}

执行结果：

1
2
/home
/test

之前我们不是建立了个Parser的目录嘛，可以在里面创建对应的解析类，然后去解析，把它们封装一下子！！

php反射实现Ioc-Di及注解

https://stitch.cn/2020/06/08/php反射实现Ioc-Di及注解.html

作者

stitch

发布于

2020-06-08

更新于

2021-10-11

许可协议

关注我

分类

归档

最新文章

×