前言
本文对将系统的对 Laravel 框架知识点进行总结，如果错误的还望指出
- 阅读书籍
- 《Laravel框架关键技术解析》 陈昊
- 学习课程
- Laravel5.4快速开发简书网站 轩脉刃
- Laravel重构企业级电商项目 檀梵
服务容器
1.什么是IoC
IOC 模式，不是一种技术，而是一种设计思想。在应用程序开发中，IoC 意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制，也是一种面向接口编程的思想。
当我们以面向接口编程的时候，程序中实例之间的耦合将上升到接口层次，而不是代码实现层次，使用配置文件来实现类的耦合。
容器的作用很简单，将在代码中使用像（new object）这样语法进行耦合的方式，改为配置文件来管理耦合，通过这种改变，从而保证系统重构或者业务逻辑改变时，不会发生“牵一发而动全身”的效果，从而有更好的可扩展性、可维护性。
总结：借助于“第三方”实现具有依赖关系的对象之间的解耦。
举个栗子
在日常开发应用中，我们要实现一个功能，在用户处理模块中调用获取用户信息Model，通常是使用像（new object）这样的语法，在用户处理模块中将对象创造出来，这时代码依赖耦合就出现了，在获取用户信息 Model时则需要修改用户处理模块里的代码。
而调用 IoC 容器则将依赖耦合上升到接口层次，只需要修改容器注册时所绑定的服务即可。
其中涉及到 依赖注入、控制反转、反射 的思想
2.控制反转
控制反转是将组件间的依赖关系从程序内部提到外部容器来管理，那么就会出现，谁控制谁？反转是什么？有正转吗？
上述流程图中
-
应用程序自身调用
用户处理模块 创建了 获取用户信息Model ，那么 用户处理模块 控制了 获取用户信息Model ，这种创建过程称为 正转
-
IoC 模式调用
创建权 交给了 IoC容器，由 Ioc 容器去创建 获取用户信息Model ，那么 Ioc 容器 控制了 获取用户信息Model ，这种创建过程称为 反转
正转：由程序本身在对象中主动控制去直接获取依赖对象
反转：由容器来帮忙建立及注入依赖对象
3.依赖注入（DI）
理解依赖注入我们需要先理解什么是依赖，再理解依赖注入
依赖
在应用程序开发中由于某客户类依赖于某个服务类称为依赖
例：
// 实现不同交通工具类
// 腿着
class Leg
{
public function go()
{
echo 'walk to Tibet！！！';
}
}
// 开车
class Car
{
public function go()
{
echo 'drive car to Tibet！！！';
}
}
// 列车
class Train
{
public function go()
{
echo 'go to Tibet！！！';
}
}
// 设计旅游者类，该类在实现游西藏的功能时要依赖交通工具类
class Traveller
{
private $trafficTool;
public function __construct()
{
$this->trafficTool = new Leg();
}
public function viisitTibet()
{
$this->trafficTool->go();
}
}
$app = new Traveller();
$app->viisitTibet();
上述实例就是一个依赖的过程，当创建一个 Traveller 实例的时候，构造函数中获取了（new Object）其中一个交通工具服务类，这时依赖就产生了，客户类（Traveller）依赖于服务类（Leg），在实际开发中需求经常改动，那么如果直接修改客户类的代码就非常繁琐并且不利于维护。
依赖注入
动态的向某个对象提供它所需要的其他对象，指组件的依赖通过外部以参数或其他形式注入，不在客户类里面用 （new object）的方式去实例化服务类而转由外部来负责，并且面向接口编程，将参数转为接口类，而不是具体的某个实现类，拓展性更强。
例：
// 设计公共接口
interface Visit
{
public function go();
}
// 实现不同交通工具类
// 腿着
class Leg implements Visit
{
public function go()
{
echo 'walk to Tibet！！！';
}
}
// 开车
class Car implements Visit
{
public function go()
{
echo 'drive car to Tibet！！！';
}
}
// 列车
class Train implements Visit
{
public function go()
{
echo 'go to Tibet！！！';
}
}
// 设计旅游者类，该类在实现游西藏的功能时要依赖交通工具类
class Traveller
{
private $trafficTool;
public function __construct( Visit $trafficTool)
{
$this->trafficTool = $trafficTool;
}
public function visitTibet()
{
$this->trafficTool->go();
}
}
// 生成的交通工具依赖
$trafficTool = new Leg();
// 依赖注入的方式解决依赖问题
$app = new Traveller($trafficTool);
$app->visitTibet();
上述实例就是一个依赖注入的过程，当创建一个 Traveller 实例的时候，构造函数依赖一个外部的具有 Visit 接口的实例，我们传递一个 Leg 实例，即通过依赖注入的方式解决依赖问题。
这里要注意的是，依赖注入需要通过接口来限制，不能随意开放，这也体现了设计模式的另一个原则——针对接口编程，而不是针对实现编程。
4.反射
什么是反射
PHP 反射机制是指在程序运行状态中，动态获取信息以及动态调用对象。
这种动态获取信息以及动态调用对象的方法的功能称为反射 API。
PHP 中获取实例的信息是通过 Reflection 实现
反射作用
为什么要使用反射机制？直接创建（new）对象不就可以了吗？
先理解动态调用对象与静态调用对象的区别
动态调用对象
通过类的路径或别名获取关于类、方法、属性、参数等详细信息，包括注释，就算类成员定义为 private 也可以在外部访问。
静态调用对象
通过使用（new Object）的方式获取类的实例。
代码灵活性
而编译性语言区别更为明显，静态调用对象在编译时确定实例的类型，绑定对象，动态调用对象则是在运行时确定实例的类型，提高了编译性语言的灵活性，降低类之间的耦合
为什么要使用反射机制
这样就可以把调用一个实例的行为写成一个类的方法或者创建函数，然后统一接口调用创建函数来创建实例对象，有点像工厂方法模式+面向接口编程的思想，这个类的方法和创建函数则是 IoC 容器
举个栗子
<?php
class B
{
}
class A
{
public function __construct(B $args)
{
}
public function demo()
{
echo 'Hello world';
}
}
//建立class A 的反射
$reflectionClass = new ReflectionClass('A');
$b = new B();
// 创建 class A 的实例
$instance = $reflectionClass->newInstanceArgs([$b]);
// 执行实例中的方法，输出 ‘Hellow World’
$instance->demo();
// 获取class A 的构造函数相关信息
$constructor = $reflectionClass->getConstructor();
/**
* 获取class A 构造函数参数的相关信息
* 参数数组
*/
$dependencies = $constructor->getParameters();
foreach ($dependencies as $dependencie) {
var_dump($dependencie->getClass());
die;
}
// 获取class A 的构造函数
var_dump($constructor);
// 获取class A 的构造函数相关信息
var_dump($dependencies);
5.再看IoC容器
我们再来看一下 IoC 容器的概念在日常开发应用中，我们在A服务中调用B服务要实现一个功能，或者要调用一个对象时都要使用像（new object）这样的语法，将对象创造出来，这时你需要关心这个对象是什么，在哪里，如何创建，然后再创建，这时就出现了代码耦合，而IoC 容器就好比 ”大象放进冰箱，大象取进冰箱，需要几步“，需要三步
- 把冰箱门打开 2. 把大象放进去 3. 把冰箱门关上
- 把冰箱门打开 2. 把大象取出来 3. 把冰箱门关上
你不需要关心大象在哪，具体哪个大象，如何放进去，如何取出来，你只需要做到放和取这个动作就行了，这样就避免了代码耦合，而
放大象，则需要将大象放到或者注册到（bind）容器里
取大象，则需要将大象取出（make）就可以
服务容器可以理解为进阶版的工厂模式，更是一种面向接口编程的思想。
工厂模式的大量应用降低了代码重复量以及利用率，但是依然还需要调用者去定位工厂。
最理想的情况是，调用者无需关心调用者的实现，也无需定位工厂，而面向接口配置化。
6.IoC容器代码
来看一段 IoC 容器代码，下面这段代码对 Laravel 的设计方法进行了简化，不是 Laravel 的源码， 而是来自一本书《laravel 框架关键技术解析》，这段代码很好的还原了 laravel 的服务容器的核心思想，代码有点长，可以尝试运行调试一下，这样易于理解：
// 设计容器类，容器类装实例或提供实例的回调函数
class Container
{
// 容器绑定数组
// 用于装提供实例的回调函数，真正的容器还会装实例等其他内容，从而实现单例等高级功能
protected $bindings = [];
// 绑定接口和生成生成相应实例的回调函数
public function bind($abstract, $concrete = null, $shared = false)
{
if (!$concrete instanceof Closure) {
// 如果提供的参数不是回调参数，则产生默认的回调函数
$concrete = $this->getClosure($abstract, $concrete);
}
$this->bindings[$abstract] = compact('concrete', 'shared');
}
// 默认生成实例的回调函数
public function getClosure($abstract, $concrete)
{
// 生成实例的回调函数，$c 一般为 IoC 容器对象，在调用回调生成实例时提供
// 即 build 函数中的 $concrete($this)
return function ($c) use ($abstract, $concrete) {
$method = ($abstract == $concrete) ? 'build' : 'make';
// 调用的是容器的 build 或 make 方法生成实例
return $c->$method($concrete);
};
}
// 生成实例对象，首先解决接口和要实例化类之间的依赖关系
public function make($abstract)
{
$concrete = $this->getConcrete($abstract);
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete);
} else {
$object = $this->make($concrete);
}
return $object;
}
protected function isBuildable($concrete, $abstract)
{
return $concrete === $abstract || $concrete instanceof Closure;
}
// 获取绑定的回调函数
protected function getConcrete($abstract)
{
if (!isset($this->bindings[$abstract])) {
return $abstract;
}
return $this->bindings[$abstract]['concrete'];
}
// 实例化对象
public function build($concrete)
{
if ($concrete instanceof Closure) {
return $concrete($this);
}
// ReflectionClass 类报告了一个类的有关信息
$reflector = new ReflectionClass($concrete);
// 检查类是否可实例化 return bool|false
if (!$reflector->isInstantiable()) {
echo $message = "Target [$concrete] is not instantiable.";
}
// 获取类的构造函数
$constructor = $reflector->getConstructor();
if (is_null($constructor)) {
return new $concrete;
}
// 获取类构造函数的参数
$dependencies = $constructor->getParameters();
$instances = $this->getDependencies($dependencies);
return $reflector->newInstanceArgs($instances);
}
protected function getDependencies($parameters)
{
$dependencies = [];
foreach ($parameters as $parameter) {
$dependency = $parameter->getClass();
if (is_null($dependency)) {
$dependencies[] = null;
} else {
$dependencies[] = $this->resolveClass($parameter);
}
}
return (array)$dependencies;
}
protected function resolveClass(ReflectionParameter $parameter)
{
return $this->make($parameter->getClass()->name);
}
}
上面的代码就生成了一个容器，下面是如何使用容器
// 实例化 IoC 容器
$app = new Container();
// 完成容器的填充
$app->bind("traveller", "Traveller");
$app->bind("Visit", "Train");
// 通过容器实现依赖注入，完成类的实例化
$tra = $app->make("traveller");
$tra->visitTibet();
$tra = $app->make("Visit");
$tra->go();
代码解析
当实例化一个容器类（Container）后，向容器中填充服务
$app->bind("traveller", "Traveller");
$app->bind("Visit", "Train");
绑定完成后，查看容器 $bindings 绑定的值
array(2) {
["traveller"]=>
array(2) {
["concrete"]=>
object(Closure)#2 (3) {
["static"]=>
array(2) {
["abstract"]=>
string(9) "traveller"
["concrete"]=>
string(9) "Traveller"
}
["this"]=>
object(Container)#1 (1) {
["bindings":protected]=>
array(2) {
["traveller"]=>
*RECURSION*
["Visit"]=>
array(2) {
["concrete"]=>
object(Closure)#3 (3) {
["static"]=>
array(2) {
["abstract"]=>
string(5) "Visit"
["concrete"]=>
string(5) "Train"
}
["this"]=>
*RECURSION*
["parameter"]=>
array(1) {
["$c"]=>
string(10) "<required>"
}
}
["shared"]=>
bool(false)
}
}
}
["parameter"]=>
array(1) {
["$c"]=>
string(10) "<required>"
}
}
["shared"]=>
bool(false)
}
["Visit"]=>
array(2) {
["concrete"]=>
object(Closure)#3 (3) {
["static"]=>
array(2) {
["abstract"]=>
string(5) "Visit"
["concrete"]=>
string(5) "Train"
}
["this"]=>
object(Container)#1 (1) {
["bindings":protected]=>
array(2) {
["traveller"]=>
array(2) {
["concrete"]=>
object(Closure)#2 (3) {
["static"]=>
array(2) {
["abstract"]=>
string(9) "traveller"
["concrete"]=>
string(9) "Traveller"
}
["this"]=>
*RECURSION*
["parameter"]=>
array(1) {
["$c"]=>
string(10) "<required>"
}
}
["shared"]=>
bool(false)
}
["Visit"]=>
*RECURSION*
}
}
["parameter"]=>
array(1) {
["$c"]=>
string(10) "<required>"
}
}
["shared"]=>
bool(false)
}
}
当执行 $tra = $app->make("traveller"); 时，程序就会用调用 make 方法，判断是否已经绑定实例，若已绑定好则调用 build 获取已经绑定好的闭包函数，开始解析，闭包函数在 build 方法中会执行 return $concrete($this) 将当前类作为参数为闭包函数传参，最终又会执行到 build 方法，类似于递归调用，最后执行的 build 方法中 $concrete的值为字符串 Traveller，通过反射获取 class Traveller 的类有关信息，再进行下一步
$reflector->isInstantiable() // 检查类是否可实例化 return bool|false，
$reflector->getConstructor(); //获取类的构造函数
$constructor->getParameters(); // 获取类构造函数的参数
再获取构造函数中每个参数是否含依赖，$this->getDependencies($dependencies)，这个方法知道了 class Traveller 含有依赖类 Visit ，我们要做的就是解决这个依赖
// $dependency
object(ReflectionClass)#7 (1) {
["name"]=>
string(5) "Visit"
}
通过 getDependencies ($parameters) 中的 $parameter->getClass() 获取到依赖类 Visit， 再调用 resolveClass (ReflectionParameter $parameter) 就会发现之前的为什么要 bind 接口类，而不用具体实现类的原因了，因为通过接口类的名称，在容易中获得实例，会获取到所对应的具体实现类，$app->bind("Visit", "Train");
最后我们通过 return $reflector->newInstanceArgs($instances); 获取到了 Train 的具体实现类。
array(1) {
[0]=>
object(Train)#9 (0) {
}
}
到这里 IoC 的流程就结束了，这就是其中控制反转、依赖注入，闭包，反射等概念的关系及应用。