Dagger学习笔记

1.理解依赖注入

依赖注入（Dependency Injection，简称 DI）
是用于实现控制反转（Inversion of Control，缩写为 IoC）最常见的方式之一，控制反转是面向对象编程中的一种设计原则，用以降低计算机代码之间耦合度。
控制反转的基本思想是：借助“第三方”实现具有依赖关系的对象之间的解耦。一开始是对象 A 对对象 B 有个依赖，对象 A 主动地创建对象 B，对象 A 有主动控制权，实现了 Ioc 后，对象 A 依赖于 Ioc 容器，对象 A 被动地接受容器提供的对象 B 实例，由主动变为被动，因此称为控制反转。
注意，控制反转不等同于依赖注入，控制反转还有一种实现方式叫“依赖查找”（Denpendency Lookup）
Alt text

2.使用方式

2-1用@inject来提供依赖

创建两个实体类，Food构造方法不需要传参数，但是我们也用@Inject标注了，这是因为在Person构造方法中需要传入Food.

->Food类(构造方法用@inject标注)

   public class Food {
      @Inject
      public Food(){
          
      }
          
      public String getApple(){
         return "苹果";
      }
   }

*->Person类(构造方法用@inject标注)

     public class Person {
        public Food food;
        @Inject
        public Person(Food food){
            this.food = food;
        }      
            
        public String eated(){
            return food.getApple();
        }        
     }

Component作为桥梁，将MainActivity与Food连接

  @Component
  public interface FoodComponent {
      void injectFood(MainActivity mainActivity);
  }

创建Component后，build项目，会生成一个DaggerComponent。这个实现类提供了将实例化好的对象注入到所需的MainActivity中

  public class MainActivity extends AppCompatActivity {
      @Inject
      Person person;
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
  
          DaggerFoodComponent
                  .builder()
                  .build().injectFood(this);
          Log.d("caesar","------------------------>"+person.eated());
      }
  }

2-2用@Module来提供依赖 [用于提供大量的依赖]

生产实例的工厂，他掌握各个需要注入的类的实例化方法，当 Dagger 需要为某个类注入实例时，会到 @Module 注解的类中，查找这个类的实例化方法。当然这一过程是需要通过使用 @Provides 注解的有返回值的方法，来告知 Dagger 的

->Food类(构造方法去除@Inject标注)

  public class Food {
      public Food(){
      
      }
      
      public String getApple(){
              return "苹果";
      }
  }

->Person类(构造方法去除@Inject标注)

  public class Person {
      public Food food;
      
      public Person(Food food){
          this.food = food;
      }
      
      public String eated(){
          return food.getApple();
      }
  }

->Module类
注：
(1)不能使用@Inject标注构造函数来提供依赖的对象实例:
(2)接口没有构造函数第三方库的类不能被标注
(3)构造函数中的参数必须配置

@Provides标注的方法来提供依赖实例，方法的返回值就是依赖的对象实例
@Module标注Module类
```
  @Module
  public class FoodModule {
  
      @Provides
      public Food provideFood(){
          return new Food();
      }
  
      @Provides
      public Person providePerson(Food food){
          return new Person(food);
      }
  }
```

->Component桥梁,注：@Component(modules = {FoodModule.class})把可以提供依赖实例的 Module 告诉 Component

  @Component(modules = {FoodModule.class})
  public interface FoodComponent {
      void injectFood(MainActivity mainActivity);
  }

3.作用域scope

1.@ActivityScope 【自定义scope注解】
保证引用与Activity的生命周期一致
(举个例子我们可以在这个Activity中持有的所有fragment之间分享一个任何类的单例)
具体代码：
```
  @Scope
  @Documented
  @Retention(RUNTIME)
  public @interface ActivityScope {}
```