我们定义两个类:class Supperman 和 class Power,现在我们要使用Supperman ,而Supperman 依赖了Power
class Supperman {
private $power;
public function __construct(){
$this->power = new Power;
}
}
一旦Power发生了变化,Supperman 不得不修改,这种就叫耦合程度太高,所以面临的问题是解耦,就需要用到控制反转.
只要不是由内部生产(比如初始化、构造函数 __construct 中通过工厂方法、自行手动 new 的),而是由外部以参数或其他形式注入的,都属于 依赖注入(DI)
方式1、用一个方法把依赖类引入进来。俗称setter方法。
class Supperman{
public $newPower;
public function setNew($Power){
$this->newPower=$Power;
}
public function show(){
$this->newPower->use();
}
}
方式2、用构造器引入依赖类。
class Supperman{
public $newPower;
public function __construct($Power){
$this->newPower=$Power;
}
public function show(){
$this->newPower->use();
}
}
方式3、直接设置属性
class Supperman{
public $newPower=new Power();
public function show(){
$this->newPower->use();
}
}
#超人类
class Superman {
protected $power;
public function __construct() {
$this->power = new Power(999, 100);
}
}
#超能力制造类
class Power {
protected $ability;//能力值
protected $range; //能力范围
public function __construct($ability, $range) {
$this->ability = $ability; $this->range = $range;
}
}
“超人”和“超能力”之间不可避免的产生了一个依赖。
其实超人是有多种超能力:我们将power细分为flight,force,shot
我们创建了如下类:
class Flight {
protected $speed;
protected $holdtime;
public function __construct($speed, $holdtime) {
}
}
class Force {
protected $force;
public function __construct($force) {
}
}
class Shot {
protected $atk;
protected $range;
protected $limit;
public function __construct($atk, $range, $limit) {
}
}
现在我们要实例化一个超人就需要把各种能力都传给超人,这些都要超人自己做
class Superman {
protected $power;
public function \_\_construct() {
$this->power = new Fight(9, 100);
// $this->power = new Force(45);
// $this->power = new Shot(99, 50, 2);
}
}
上面要实例化很多次,我们现在引入一个工厂
class SuperModuleFactory {
public function makeModule($moduleName, $options) {
switch ($moduleName) {
case 'Fight': return new Fight($options[0], $options[1]);
case 'Force': return new Force($options[0]);
case 'Shot': return new Shot($options[0], $options[1], $options[2]);
}
}
}
有了这个工厂,直接调用工厂里面的方法,超人就不用自己去实例化超能力了
class Superman {
protected $power;
public function \_\_construct() {
// 初始化工厂 $factory = new SuperModuleFactory;
// 通过工厂提供的方法制造需要的模块
$this->power = $factory->makeModule('Fight', \[9, 100\]);
// $this->power = $factory->makeModule('Force', \[45\]);
// $this->power = $factory->makeModule('Shot', \[99, 50, 2\]);
}
}
不过这样和以前好像差不多,只是没有那么多new关键字,我们稍微改造下超人,就可以很方便的使用超人了
class Superman {
protected $power;
public function __construct(array $modules) {
// 初始化工厂
$factory = new SuperModuleFactory;
// 通过工厂提供的方法制造需要的模块
foreach ($modules as $moduleName => $moduleOptions) {
$this->power[] = $factory->makeModule($moduleName, $moduleOptions);
}
}
}
// 创建超人
$superman = new Superman([ 'Fight' => [9, 100], 'Shot' => [99, 50, 2] ]);
现在我们可以在超人类外面自由控制生产出何种能力的超人了,我们再也不用关心超人类中需要提前写入需要何种能力了(以前超人类中需要自己new 超能力或者$factory->make超能力),这就是控制反转
我们不应该手动在 “超人” 类中固化了他的 “超能力” 初始化的行为,而转由外部负责,由外部创造超能力模组、装置或者芯片等(我们后面统一称为 “模组”),植入超人体内的某一个接口,这个接口是一个既定的,只要这个 “模组” 满足这个接口的装置都可以被超人所利用,可以提升、增加超人的某一种能力。这种由外部负责其依赖需求的行为,我们可以称其为 “控制反转(IoC)”。
到此为止我们发现,我们可以很灵活的制造超人,超人对超能力的依赖都转嫁到工厂中了,但是如果我们的超能力有几百种或者更多,工厂就会很臃肿,就像下面
class SuperModuleFactory {
public function makeModule($moduleName, $options) {
switch ($moduleName) {
case 'Fight': return new Fight($options[0], $options[1]);
case 'Force': return new Force($options[0]);
case 'Shot': return new Shot($options[0], $options[1], $options[2]);
// case 'more': …….
// case 'and more': …….
// case 'and more': …….
// case 'oh no! its too many!': …….
}
}
}
下一步就是我们今天的主要配角 —— DI (依赖注入)
为了约束超能力,我们制定了超能力的规范,接口SuperModuleInterface,
interface SuperModuleInterface {
public function activate(array $target);
}
各种类型的超能力继承超能力接口
//超能力X
class XPower implements SuperModuleInterface {
public function activate(array $target) {
// 这只是个例子。。具体自行脑补
}
}
//超能力炸弹
class UltraBomb implements SuperModuleInterface {
public function activate(array $target) {
// 这只是个例子。。具体自行脑补
}
}
我们再改造一下超人类,所有超能想要超能力,必须遵循超能力制造接口的规范
class Superman {
protected $module;
public function __construct(SuperModuleInterface $module) {
$this->module = $module
}
}
我们现在要制造一个超人
// 超能力模组
$superModule = new XPower;
// 初始化一个超人,并注入一个超能力模组依赖
$superMan = new Superman($superModule);
以前我们制造超人还要手动,先实例化超能力,再用它实例化超人,既然是科技时代,这显然是不方便的
首先我们制造一个容器,容器中有两个方法,一个是方法是向容器中绑定各种脚本,另一个是利用容器生产超人的方法
class Container {
protected $binds; protected $instances;
//绑定生产脚本
public function bind($abstract, $concrete) {
if ($concrete instanceof Closure) {
$this->binds[$abstract] = $concrete;
} else {
$this->instances[$abstract] = $concrete;
}
}
//生产出超人
public function make($abstract, $parameters = []) {
if (isset($this->instances[$abstract])) {
return $this->instances[$abstract];
}
array_unshift($parameters, $this);
return call_user_func_array($this->binds[$abstract], $parameters);
}
}
看看我们应该怎样使用这个容器
// 创建一个容器(后面称作超级工厂)
$container = new Container;
// 向该 超级工厂 添加 超人 的生产脚本
$container->bind('superman', function($container, $moduleName) {
return new Superman($container->make($moduleName));
}
);
// 向该 超级工厂 添加 超能力模组 的生产脚本
$container->bind('xpower', function($container) {
return new XPower;
});
// 同上
$container->bind('ultrabomb', function($container) {
return new UltraBomb;
});
// ****************** 华丽丽的分割线 ********************** // 开始启动生产
$superman_1 = $container->make('superman', 'xpower');
$superman_2 = $container->make('superman', 'ultrabomb');
$superman_3 = $container->make('superman', 'xpower');
// …随意添加
通过最初的 绑定(bind) 操作,我们向 超级工厂 注册了一些生产脚本,这些生产脚本在生产指令下达之时便会执行。发现没有?我们彻底的解除了 超人 与 超能力模组 的依赖关系,更重要的是,容器类也丝毫没有和他们产生任何依赖!我们通过注册、绑定的方式向容器中添加一段可以被执行的回调(可以是匿名函数、非匿名函数、类的方法)作为生产一个类的实例的 脚本 ,只有在真正的 生产(make) 操作被调用执行时,才会触发。
这样一种方式,使得我们更容易在创建一个实例的同时解决其依赖关系,并且更加灵活。当有新的需求,只需另外绑定一个“生产脚本”即可。
几乎所有的服务容器绑定都会注册至服务提供者(下一篇总结中会介绍)中
singleton 方法绑定一个只会被解析一次的类或接口至容器中,且后面的调用都会从容器中返回相同的
// 绑定方式:定义服务
//实例:
$this->app->singleton('service_id', function () {
return new Service();
})
// 获取服务,以下方式等价
$this->app->make('service_id'); $this->app['service_id'];
需要像下边这样:bind 方法注册一个绑定,传递我们希望注册的类或接口名称,并连同返回该类实例的闭包:
// 绑定方式:绑定接口到实例
$this->app->bind('Namespace\To\Your\Interface\Pay', 'Namespace\To\Your\Class\Weixin');
//解析方式:服务容器(Service Container)
//如果你需要注入服务的对象是通过服务容器(Service Container)来解析的,才可以使用类型提示(Type Hint)来进行自动解析并注入服务。
像上边这样,通过绑定接口到实例,只能自动解析为一个实例,也就是你绑定的实例;如果你想要的结果是,不同的类,构造器通过类型提示(Type Hint)相同的接口,注入不同的实例,可以像下边这样(上下文绑定,Context Binding):
$this->app->when('Namespace\To\Your\Class\A') ->needs('Namespace\To\Your\Interface\Pay') ->give('Namespace\To\Your\Class\Weixin');
$this->app->when('Namespace\To\Your\Class\B') ->needs('Namespace\To\Your\Interface\Pay') ->give('Namespace\To\Your\Class\Ali');
通过上下文绑定,A的实例会注入Weixin的实例,而B的实例会注入Ali的实例。像下边:
class A {
public functions __construct(Pay $pay) {
var_dump($pay instanceof Weixin); // True
}
}
class B {
public functions __construct(Pay $pay) {
var_dump($pay instanceof Ali); // True
}
}
本文超人的例子整理自: https://www.insp.top/article/learn-laravel-container
手机扫一扫
移动阅读更方便
你可能感兴趣的文章