Laravel核心原理学习:依赖注入、IOC容器

Laravel核心原理学习:依赖注入、IOC容器

欢迎指正内容不严谨或有误的地方!

使用Laravel的过程中经常会遇到一些名词(服务提供者、依赖注入、IOC容器之类的概念),每次都是匆匆扫俩眼手册,没有机会深究。今天就花些时间学习,若有不足,后续补充。

Reference

  1. Laravel 的生命周期
  2. php/laravel底层核心代码分析之依赖注入

前言

1.Laravel的特点和优势
  1. 集成了 composer
  2. 实现了依赖注入,更好的管理类与类之间的关系,使得框架具有更好的扩展性;
  3. 实现了一些高级特性 console/event/queue/middleware/facades...

Laravel的缺点:加载文件太多导致速度变慢;
优化方式:

  1. 缓存配置方式 php artisan config:cache
  2. 去掉一些不必要的加载文件(主要是_serviceProvider_);
  3. 开启 opcache (省略编译过程);
2.Laravel的启动流程(生命周期)
<?php
use Illuminate\Contracts\Http\Kernel;
use Illuminate\Http\Request;
// 定义了请求开始的时间
define('LARAVEL_START', microtime(true));
// 维护模式
if (file_exists($maintenance = __DIR__.'/../storage/framework/maintenance.php')) {
    require $maintenance;
}
// 1. composer 自动加载机制,加载项目依赖的第三方文件
require __DIR__.'/../vendor/autoload.php';
// 2. 生成服务容器(也就是IOC容器)
$app = require_once __DIR__.'/../bootstrap/app.php';
// 3. 创建一个 Kernel::class 的服务提供者
$kernel = $app->make(Kernel::class);
// 4. 获取 Request 对象,返回一个 Response 对象
// 也就是处理请求
$response = $kernel->handle(
  // 创建请求实例  
  $request = Request::capture()
  // 发送响应
)->send();
// 5. 终止程序
$kernel->terminate($request, $response);
  1. 包含自动加载文件(composer);
  2. 生成服务容器:①注册基础的 bindings (构建);②注册基础的 serviceProvider(通过bind)、event服务、路由服务、日志服务;
  3. 获取 request 对象;
  4. 逻辑处理:①加载/解析基本的启动项(包括基础服务和serviceProvider),如路由、异常处理、facades、serviceProvider;②通过管道模式,使用中间件过滤用户请求数据,处理业务逻辑;
  5. 返回 response 对象;

Laravel依赖注入/控制反转

  1. 依赖注入: 将组件间的依赖关系从程序内部提到外部进行管理;
  2. 控制反转: 组件间的依赖通过外部以参数或其他形式的注入;
1. 代码示例

正转代码示例:

class A
{
    // 当B中依赖其他类时,就会导致层级依赖出现,维护成本高
    public function __construct() {
        $this->b = new B();
    }
    public function aMethod(){
        return $this->b->bMethod();
    }
}
class B 
{
    public function __construct() {}
    public function bMethod(){
        return "Hello World!";
    }
}
$b = (new A)->aMethod();

控制反转代码示例:

class A
{
    protected $b;
    public function __construct(B $b) {
        $this->b = $b;
    }
    public function getB(){
        return $this->b->bMethod();
    }
}
class B 
{
    public function __construct() {}
    public function bMethod(){
        return "Hello World!";
    }
}
// IOC容器类
class Ioc
{
    protected $instances = [];
    public function __construct() {
        $this->instances['B'] = new B();
        $this->instances['C'] = new C();
        $this->instances['D'] = new D();
    }
    public function make($abstract){
        return $this->instances[$abstract];
    }
}
// 控制反转:类与类的依赖关系不再在类A中创建,
// 而是通过IOC容器生成类B后通过参数的形式传入类A中;
$ioc = new Ioc();
$b   = $ioc->make('B');
$a   = new A($b);
$a->getB();

控制反转即将创建对象的控制权进行了转移,以前创建对象 B 的主动权和创建时机都由自己 A 把控,而控制反转就是将这样的权利转移给第三方(IOC容器);而IOC容器就是一个专门用来创建对象的工厂,IOC 的存在导致依赖关系的变化,以前是A依赖于B,反转后是依赖于IOC容器,通过IOC容器建立和 B 的关系。所以对于 A 来说发生了控制反转,而对于 IOC 容器来说,组件间的依赖关系都是通过 IOC 容器生产后注入到所需要的类中,这就叫做依赖注入。
上述IOC容器的缺点:

  1. 无法提前生成所有的实例化对象;
  2. 没有解决多层依赖的问题,仅仅是将依赖关系提到外部管理。

优化后的控制反转:

class A
{
    protected $b;
    public function __construct(B $b) {
        $this->b = $b;
    }
    public function getB(){
        return $this->b->bMethod();
    }
}
class B 
{
    public function __construct(C $c, D $d) {}
    public function bMethod(){
        return "Hello World!";
    }
}
class C
{
    public function __construct() {}
    public function cMethod(){}
}
class D 
{
    public function __construct() {}
    public function dMethod(){}
}
class Ioc
{
    protected $instances = [];
    public function __construct() {}
    public function getInstance($abstract) {
        // 获取类的反射信息,也就是类的所有信息
        $reflector = new ReflectionClass($abstract);
        // 获取反射类的构造函数信息
        $constructor = $reflector->getConstructor();
        // 获取反射类构造函数的参数,此处获取到的参数应该是B
        $dependencies = $constructor->getParameters();
        // 判断反射类是否有依赖其他类,不依赖(无参)则直接返回该类
        if (!$dependencies) return new $abstract();
        // 遍历反射类的参数
        foreach ($dependencies as $dependency) {
            // 若存在依赖类,则递归依赖类
            if (!is_null($dependency->getClass())) {
                $p[] = $this->make($dependency->getClass()->name);
                // 递归是从最底层向上层执行,
                // 所以示例此处$p[0]是C的实例化对象,$p[1]是D的实例化对象
            }
        }
        // 创建一个类的新的实例,将给出的参数(依赖类数组)传递到类的构造函数
        return $reflector->newInstanceArgs($p);
    }
    public function make($abstract){
        return $this->getInstance($abstract);
    }
}
$ioc = new Ioc();
$a   = $ioc->make('A');
$a->getB();
2.依赖注入的优点
  1. 依赖注入的优点就是更好的管理类与类之间的依赖关系,降低了编码的复杂性;
  2. MVC 的所有逻辑代码都写在 controller 层,无法很好的做到代码复用,扩展性不强(即分层不够,模块细分还可以继续下去,常见的就是创建一个 service 层用来处理可复用的代码,最好是 controller 只需关注 request对象);
  3. Laravel 中通过 namespaceuse 实现了自动加载机制,能够找到对应的类的文件,然后通过反射获取类的实例化对象。

PHP程序运行的本质:包含文件和获取实例化对象

  1. 传统框架:通过 spl_autoload_register()/__autoload() 方法去指定目录来寻找文件,然后 include()/require() 实现管理类与类之间的依赖;
  2. Laravel:通过 namespaceuse ,实现自动加载,再加上反射实现了依赖注入来管理类和类之间的依赖关系。
                       

点击阅读全文

上一篇 2023年 5月 27日 am10:45
下一篇 2023年 5月 27日 am10:47