laravel核心Ioc容器

laravel容器和依赖注入

---

• 啥是Ioc容器，方便我们实现依赖注入的一种实现，也就是说依赖注入不一定需要控制反转容器，只不过使用容器可能会方便些。

• laravel通过向容器中绑定接口的具体实现，可实现不同实现的快速切换，接口在laravel中有个好听的名字叫契约。

• 面向接口编程和容器结合使用，可以轻松实现代码解耦，实现了关注分离。

• 面向接口开发的好处：除了可以快速切换实现了相同契约的实现，对开发测试同步进行，以及对单元测试都是非常有好的。

• 下面是一个简单的使用示例，为了相对好理解没有加入service层。

  1 创建文章接口
  <?php
  
  namespace App\Repository;
  
  interface ArticleRepository
  {
      // 返回文章列表
      public function getList(): array;
  }
  
  2 创建一个文章具体实现类
  <?php
  
  namespace App;
  
  use App\Repository\ArticleRepository;
  use App\Models\Article;
  
  class DbArticle implements ArticleRepository
  {
      public function getList(): array
      {
          return Article::all()->toArray();
      }
  }
  
  3 在容器中进行绑定
  <?php
  
  namespace App\Providers;
  
  use App\DbArticle;
  use Illuminate\Support\ServiceProvider;
  use App\Repository\ArticleRepository;
  use App\DbArticle;
  
  class AppServiceProvider extends ServiceProvider
  {
      /**
       * Register any application services.
       *
       * @return void
       */
      public function register()
      {
          $this->app->bind(ArticleRepository::class, function () {
              return new DbArticle();
          });
      }
  
  4 在控制器中使用
  <?php
  
  namespace App\Http\Controllers\Test;
  
  use App\Http\Controllers\Controller;
  use Illuminate\Http\Request;
  use App\Repository\ArticleRepository;
  
  class ArticleController extends Controller
  {
      protected $articles;
  
      public function __construct(ArticleRepository $articles)
      {
          $this->articles = $articles;
      }   
  
      public function index()
      {
          $articles = $this->articles->getList();
          return view('article.index', compact('articles'));
      }
  }
  
  以上便是一个比较标准的依赖注入的使用方式，其实还有很多使用方式，比如通过app()函数或者App门面直接获取依赖等等。看到这里应该能感觉到依赖注入为开发者带来的方便了，上述例子中文章是从ORM中取出，当需求改变要求文章从mongodb或者redis中取出的时候，我们只需要编写单独的实现类，然后在服务提供者中绑定新的实现，业务代码完全不需要改变，就能快速实现切换。
  

• 下面讲解laravel如何实现的依赖注入 laravel版本6.12

  从bootstrap/app.php开始
  
  // 实例化app容器类 并传递项目根目录给构造函数
  $app = new Illuminate\Foundation\Application(
      $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
  );
  
  Illuminate\Foundation\Application中
  public function __construct($basePath = null)
  {
      if ($basePath) {
          // 注册基本路径 调用container的instance方法 添加路径实例到容器
          // 结果就是app实例的instances属性下多了几条路径映射 可直接打印$this查看
          $this->setBasePath($basePath);
      }
      // 注册基本绑定 跳转到下面的registerBaseBindings方法
      $this->registerBaseBindings();
      $this->registerBaseServiceProviders();
      $this->registerCoreContainerAliases();
  }
  
  protected function registerBaseBindings()
  {
      static::$instance = $this;
  	// 绑定自身到容器
      $this->instance('app', $this);
  	// 依然还是绑定
      $this->instance(Container::class, $this);
      // 重点来了！！！ 跳转到下面的singleton方法
      $this->singleton(Mix::class);
      $this->instance(PackageManifest::class, new PackageManifest(
          new Filesystem,
          $this->basePath(),
          $this->getCachedPackagesPath()
      ));
  }
  
  Illuminate\Container\Container中
  // 绑定共享实例 就是单例绑定  可以看到singleton方法就是调用了bind方法
  public function singleton($abstract, $concrete = null)
  {
      $this->bind($abstract, $concrete, true);
  }
  
  /**
   * Register a binding with the container.
   *
   * @param  string  $abstract
   * @param  \Closure|string|null  $concrete 注意参数类型
   * @param  bool  $shared
   * @return void
   */
  public function bind($abstract, $concrete = null, $shared = false)
  {
      // 此处的$abstract = Illuminate\Foundation\Mix
      // 删除老的实例绑定
      $this->dropStaleInstances($abstract);
  
      // laravel默认的如果没传递对应抽象的实例，那么就认为实例应该是传递的抽象的一个实例
      if (is_null($concrete)) {
          // 如果concrete为null
          $concrete = $abstract;
      }
  
      // 如果传递的不是一个闭包
      if (!$concrete instanceof Closure) {
          // laravel会试图根据传递进来的抽象得到一个闭包
          // 跳转到getClosure方法
          //
          $concrete = $this->getClosure($abstract, $concrete);
      }
  
      // 将返回的闭包和是否shared标志保存到bindings数组下
      $this->bindings[$abstract] = compact('concrete', 'shared');
  
      if ($this->resolved($abstract)) {
          $this->rebound($abstract);
      }
  }
  
  /**
   * Get the Closure to be used when building a type.
   *
   * @param  string  $abstract
   * @param  string  $concrete
   * @return \Closure
   */
  // 值得注意的是此时生成的闭包不会立即执行，触发条件官方在注释中写的很清楚，当要使用时才会执行此闭包
  protected function getClosure($abstract, $concrete)
  {
      // 此时的$abstract $concrete都是Illuminate\Foundation\Mix
      return function ($container, $parameters = []) use ($abstract, $concrete) {
          // 如果调用bind方法只传入了abstract
          if ($abstract == $concrete) {
              // 返回容器的build方法返回的实例
              return $container->build($concrete);
          }
  		// 否则直接调用contaner的resolve方法进行解析
          return $container->resolve(
              $concrete,
              $parameters,
              $raiseEvents = false
          );
      };
  }
  
  // 什么时候使用到这些绑定呢(如何从容器中解析需要的实例呢) 来看make方法 调用方式app()->make($yourAbstract)
  /**
   * Resolve the given type from the container.
   *
   * @param  string  $abstract
   * @param  array  $parameters
   * @return mixed
   *
   * @throws \Illuminate\Contracts\Container\BindingResolutionException
   */
  public function make($abstract, array $parameters = [])
  {
      // 跳转到resolve方法
      return $this->resolve($abstract, $parameters);
  }
  
  /**
   * Resolve the given type from the container.
   *
   * @param  string  $abstract
   * @param  array  $parameters
   * @param  bool  $raiseEvents
   * @return mixed
   *
   * @throws \Illuminate\Contracts\Container\BindingResolutionException
   */
  protected function resolve($abstract, $parameters = [], $raiseEvents = true)
  {
      $abstract = $this->getAlias($abstract);
  
      $needsContextualBuild = !empty($parameters) || !is_null(
          $this->getContextualConcrete($abstract)
      );
  
      // 如果要解析的类名instances中已经有了 并且不需要临时build  那么就返回已经存在的实例
      if (isset($this->instances[$abstract]) && !$needsContextualBuild) {
          // dd(123, $abstract);
          // dd($this->instances);
          return $this->instances[$abstract];
      }
  
      $this->with[] = $parameters;
  
      // getConcrete方法 拿到之前可能绑定过的binding 绑定过就是一个闭包
      // 没绑定过返回自身，即通过容器make可一个自定义的类
      $concrete = $this->getConcrete($abstract);
  
      if ($this->isBuildable($concrete, $abstract)) {
  		// 当concrete === abstract 或者 concrete是一个闭包的时候 直接调用build方法
          // 跳转到build方法
          $object = $this->build($concrete);
      } else {
          // 当concrete是一个类名的时候 调用make方法
          $object = $this->make($concrete);
      }
  
      foreach ($this->getExtenders($abstract) as $extender) {
          $object = $extender($object, $this);
      }
  
      // 如果是共享的实例 或者 不需要临时build 那么就将实例存放到容器的instances数组中
      if ($this->isShared($abstract) && !$needsContextualBuild) {
          $this->instances[$abstract] = $object;
      }
  
      if ($raiseEvents) {
          $this->fireResolvingCallbacks($abstract, $object);
      }
  
      $this->resolved[$abstract] = true;
  
      array_pop($this->with);
  
      // 返回实例
      return $object;
  }
  
  public function build($concrete)
  {
      // 如果传递进来的是一个闭包 (通过之前bind方法绑定得到的闭包)
      // 直接调用闭包返回实例
      if ($concrete instanceof Closure) {
          return $concrete($this, $this->getLastParameterOverride());
      }
  
      // 如果传递进来的是一个可能的类名 那么调用反射api解析依赖
      try {
          $reflector = new ReflectionClass($concrete);
      } catch (ReflectionException $e) {
          throw new BindingResolutionException("Target class [$concrete] does not exist.", 0, $e);
      }
  
      // 不能实例化就抛出异常
      if (!$reflector->isInstantiable()) {
          return $this->notInstantiable($concrete);
      }
  
      $this->buildStack[] = $concrete;
  
      // 拿到构造方法
      $constructor = $reflector->getConstructor();
  
      // 没有构造方法直接new实例
      if (is_null($constructor)) {
          array_pop($this->buildStack);
          return new $concrete;
      }
  
      // 拿到构造方法中的依赖
      $dependencies = $constructor->getParameters();
  
      try {
          // 解析依赖
          // 跳转到resolveDependencies方法
          $instances = $this->resolveDependencies($dependencies);
      } catch (BindingResolutionException $e) {
          array_pop($this->buildStack);
  
          throw $e;
      }
  
      array_pop($this->buildStack);
  
      // 返回实例
      return $reflector->newInstanceArgs($instances);
  }
  
  protected function resolveDependencies(array $dependencies)
  {
      $results = [];
  
      foreach ($dependencies as $dependency) {
          if ($this->hasParameterOverride($dependency)) {
              // 如果存在临时重写 则获取
              $results[] = $this->getParameterOverride($dependency);
  
              continue;
          }
  
          // 如果构造方法中不存在类型提示 那么会返回null
          // 跳转到resolvePrimitive方法
          $results[] = is_null($dependency->getClass())
              ? $this->resolvePrimitive($dependency)
              // 如果存在类型提示 根据类型尝试解析出依赖实例 getClass能拿到一个确切的类名
              // 跳转到resolveClass方法
              : $this->resolveClass($dependency);
      }
  
      return $results;
  }
  
  protected function resolvePrimitive(ReflectionParameter $parameter)
  {
  	// 首先尝试获取闭包
      if (!is_null($concrete = $this->getContextualConcrete('$' . $parameter->name))) {
          return $concrete instanceof Closure ? $concrete($this) : $concrete;
      }
  
      // 尝试获取默认值
      if ($parameter->isDefaultValueAvailable()) {
          return $parameter->getDefaultValue();
      }
  
      // 如果上面都不符合那么就直接抛出异常
      $this->unresolvablePrimitive($parameter);
  }
  
  protected function resolveClass(ReflectionParameter $parameter)
  {
      try {
          // 又回到了make方法 进行了递归调用
          // 至此一切形成了闭环 完美！！！
          return $this->make($parameter->getClass()->name);
      }
  
      catch (BindingResolutionException $e) {
          if ($parameter->isOptional()) {
              return $parameter->getDefaultValue();
          }
  
          throw $e;
      }
  }
  
  可以看到：
  1 当从laravel中解析对象的时候，实际调用的是build方法，而build方法首先会尝试从之前的绑定中获取，如果未找到绑定那么就通过反射机制尝试解析，当然解析依赖的过程依然存在尝试获得之前绑定的过程。
  2 laravel的容器解析依赖需要使用其固定的规则，直接调用app()函数或者App门面从容器中解析。
  3 建议使用容器进行解析自定义类的时候，一定要加上依赖的类型
  4 绑定的时候尽量使用闭包形式
  

其中的临时绑定等需要配合laravel容器的when with等api使用，还有解析时的事件等，本文都没进行讲解。

下期预告：Application类实例化时剩下的两个方法