PHP
6 minutes read (About 878 words)

依赖注入和IOC

依赖注入

依赖注入 (Dependency Injection，简称DI）
Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式的new一个B的对象。
采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。

而我们通常注入依赖的方式有两种：

  • 通过构造函数传入依赖，实现特定参数的构造函数，在新建对象时传入所依赖类型的对象。

  • 通过setter方法注入依赖，实现特定属性的public set方法，来让外部容器调用传入所依赖类型的对象。

    控制反转

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency
Injection，简称DI），还有一种方式叫“依赖查找”（Dependency
Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

控制反转是一种思想，而依赖注入是这种思想的一种实现。

下面是一段IOC容器的实现代码。

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
<?php
    class Bim
    {
        public function doSomething()
        {
            echo __METHOD__, '|';
        }
    }
    
    class Bar
    {
        private $bim;
    
        public function __construct(Bim $bim)
        {
            $this->bim = $bim;
        }
    
        public function doSomething()
        {
            $this->bim->doSomething();
            echo __METHOD__, '|';
        }
    }
    
    class Foo
    {
        private $bar;
    
        public function __construct(Bar $bar)
        {
            $this->bar = $bar;
        }
    
        public function doSomething()
        {
            $this->bar->doSomething();
            echo __METHOD__;
        }
    }
    
    class Container
    {
        private $s = array();
    
        public function __set($k, $c)
        {
            $this->s[$k] = $c;
        }
    
        public function __get($k)
        {
            // return $this->s[$k]($this);
            return $this->build($this->s[$k]);
        }
    
        /**
         * 自动绑定（Autowiring）自动解析（Automatic Resolution）
         *
         * @param string $className
         * @return object
         * @throws Exception
         */
        public function build($className)
        {
            // 如果是匿名函数（Anonymous functions），也叫闭包函数（closures）
            if ($className instanceof Closure) {
                // 执行闭包函数，并将结果
                return $className($this);
            }
    
            /** @var ReflectionClass $reflector */
            $reflector = new ReflectionClass($className);
    
            // 检查类是否可实例化, 排除抽象类abstract和对象接口interface
            if (!$reflector->isInstantiable()) {
                throw new Exception("Can't instantiate this.");
            }
    
            /** @var ReflectionMethod $constructor 获取类的构造函数 */
            $constructor = $reflector->getConstructor();
    
            // 若无构造函数，直接实例化并返回
            if (is_null($constructor)) {
                return new $className;
            }
    
            // 取构造函数参数,通过 ReflectionParameter 数组返回参数列表
            $parameters = $constructor->getParameters();
    
            // 递归解析构造函数的参数
            $dependencies = $this->getDependencies($parameters);
    
            // 创建一个类的新实例，给出的参数将传递到类的构造函数。
            return $reflector->newInstanceArgs($dependencies);
        }
    
        /**
         * @param array $parameters
         * @return array
         * @throws Exception
         */
        public function getDependencies($parameters)
        {
            $dependencies = [];
    
            /** @var ReflectionParameter $parameter */
            foreach ($parameters as $parameter) {
                /** @var ReflectionClass $dependency */
                $dependency = $parameter->getClass();
    
                if (is_null($dependency)) {
                    // 是变量,有默认值则设置默认值
                    $dependencies[] = $this->resolveNonClass($parameter);
                } else {
                    // 是一个类，递归解析
                    $dependencies[] = $this->build($dependency->name);
                }
            }
    
            return $dependencies;
        }
    
        /**
         * @param ReflectionParameter $parameter
         * @return mixed
         * @throws Exception
         */
        public function resolveNonClass($parameter)
        {
            // 有默认值则返回默认值
            if ($parameter->isDefaultValueAvailable()) {
                return $parameter->getDefaultValue();
            }
    
            throw new Exception('I have no idea what to do here.');
        }
    }
    
    // ----
    $c = new Container();
    $c->bar = 'Bar';
    $c->foo = function ($c) {
        return new Foo($c->bar);
    };
    // 从容器中取得Foo
    $foo = $c->foo;
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething
    
    // ----
    $di = new Container();
    
    $di->foo = 'Foo';
    
    /** @var Foo $foo */
    $foo = $di->foo;
    
    var_dump($foo);
    /*
    Foo#10 (1) {
      private $bar =>
      class Bar#14 (1) {
        private $bim =>
        class Bim#16 (0) {
        }
      }
    }
    */
    
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething
?>
设计模式
4 minutes read (About 639 words)

适配器模式

读了《设计模式之蝉》之适配器模式后的总结。

C适配器模式的定义：
onvert the interface of a class into another interface clients expect.Adapter lets classes work togeher that couldn’t otherwise because of incompatible interfaces.(将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无发在一起工作的两个类能够在一起工作)

类适配器

原有公司的内部员工形象有这么一个接口（target）

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
<?php 
interface IuserInfo{
    public function getUserName();
    public function getHomeAdress();
    public function getMobileNumber();
    public function getOfficeTelNumber();
    public function getJobPosition();
    public function getHomeNumber();
    }

public class UserInfo implements IuserInfo{
    public function getUserName(){
        echo "名字是...."
    };
    public function getHomeAdress(){
        echo "家庭住址是...."
    };
    public function getMobileNumber(){
        echo "手机号码是...."
    };
    public function getOfficeTelNumber(){
        echo "办公室号码是..."
    };
    public function getHomeNumber(){
        echo "家里的号码是..."
    };
    
    public function getJobPosition(){
        echo "办公室位置式..."
    };

}
public class clients{
    public main function(){
        $user = new UserInfo();
        $user->getUserName();
    }
}

一切看上去都没有什么问题，但是可能处于某种原因，公司需要从其他公司租用的员工的信息。而其他公司租用的员工信息的接口是这个样子的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
    interface IouterUserInfo(){
        public function userNumber();
        public function userAddress();
    }
    public class OuterUser implements IouterUserInfo{
        public function userNumber(){
            $telnumber = ['moblie_number' => '135...',
                'office_mobile_number' =>'001-12..',
                'home_tel_number' => '002-22'
            ];
            return $telnumber;
        }
        public function baseInfo(){
            $info = ['name' => 'steve',
                'office_address' => '办公室位置...',
                'home_address' => '家的位置是...'
            ];
            return $info;
        }
    }

这和我们原先的接口完全不同，我们希望还是希望以自己接口设计去获取信息，因为这样就不需要大修改原先已经写好的客户端类。
我们这里就可以用到适配器模式。

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
    //类适配器 OuterUserInfo
    public class OuterUserInfo extends OuterUser implements UserInfo{
        public function getUserName(){
            echo $this->baseInfo()['name'];
        };
        public function getHomeAdress(){
        };
        public function getMobileNumber(){
        };
        public function getOfficeTelNumber(){
        };
        public function getHomeNumber(){
        };
        public function getJobPosition(){
        };
    }
    //客户端相对于之前只是改了实例其他不变。
    public class clients{
        public main function(){
            $user = new OuterUserInfo();
            $user->getUserName();
        }
}

对象适配器

如果是多个不同的接口则可以用对象适配器
对象适配器和类适配器的不同就是，对象适配器是把对象注入到适配器内部而不是通过继承直接使用。假如我们把IouterUserInfo一分为二，mobile归IouterUserMobile（通讯录），IouterUserInfo接口则是基本信息（姓名和地址）。那么类适配器是不能继承两个类的，所以采用对象适配器来解决。

1
2
3
4
5
6
7
8
9
<?php 
    public class OuterUserInfo implements UserInfo{
        private $outerUserMobile;
        private $outerUserInfo;
        public function __construct(OuterUserInfo $outrUserInfo,OuterUserMoblie $outerUserMobile) {
        $this->outerUserMobile =  $outerUserMobile;
        $this->outerUserInfo =  $outerUserInfo;
    }
    }
Follow

Categories

Tag Cloud

C&数据结构 leetcode 协议 总结 数据结构 设计模式

Recent

Recent

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×