Dagger2从入门到熟练

Posted 2021-09-06 Jason_Lee155

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Dagger2从入门到熟练相关的知识，希望对你有一定的参考价值。

Dagger2是什么？

是一个依赖注入框架，butterknife也是一个依赖注入框架。不过butterknife，最多叫奶油刀，Dagger2被叫做利器啊，他的主要作用，就是对象的管理，无需显示调用new Object()，其目的是为了降低程序耦合。

来看一个例子：

public class A {
 public void eat() {
 System.out.print("吃饭了");
 }
}

使用的时候我们就要

A a = new A();
a.eat();

如果现在改了，在A的构造方法中必须传入B对象

 public class A {
 private B b;
 public A(B b) {
 this.b = b;
 }
 public void eat() {
 System.out.print("吃饭了");
 }
}

那么使用的时候

A a = new A(new B());
a.eat();

可能就有人说了，不就加一个对象么，这里只是我举的一个很简单的例子，看起感觉很简单，但是在实际开发中，如果现在改了一个这个构造方法。是不是意味着，整个项目中的都的改，一不小心，就是BUG 。

因此，为了避免这种动不动就要传一个对象进入的情况，出现了dagger。看到这篇文章的同学，多少都有点了解dagger了。还是直接介绍怎么使用吧。使用之前，先开局一张图：

简单说一下几个概念，有个认知，在往下看，会好很多，Dagger 是通过@Inject使用具体的某个对象，这个对象呢，是由@Provides注解提供，但是，这个@Provides只能在固定的模块中，也就是@Module注解，我们查找的时候，不是直接去找模块，而是去找@Component。

@Inject
A a

想要获取a对象的示例的时候，Dagger2 会先去找，当前Activity或者Fragment所连接的桥梁，例如上图中，连接的只有一个桥梁，实际上可以有多个，这个桥梁，会去寻找他所依赖的模块，如图中，依赖了模块A，和模块B，然后在模块中，会去寻找@Providers注解，去寻找A的实例化对象。

1.@Inject

提供实例的类的是默认的构造函数

1. @Inject 注解在一个 Filed 域. 表示在 MainActivity类中需要注入一个 Engine 对象

public class MainActivity extends AppCompatActivity {

    // 这个 @Inject 表示要注入一个 Engine对象
    @Inject Engine mEngine;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerMainComponent.create().inject(this);

    }

    public void onClick(View view) {
        Toast.makeText(this,mEngine.toString(),Toast.LENGTH_SHORT).show();
    }
}

2. @Inject 注解在一个构造函数中,表示可以提供该类的实例供注入别的类中 ,有且只有一个Engine 的构造函数能被 @Inject 标注

public class Engine {
    private String model;
    private int age;

    // 提供 Engine 对象
    @Inject
    public Engine() {
        model = "xxxx";
        age = 1990;
    }
    
    public Engine(String model, int age) {
        this.model = model;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Engine{" +
                "model='" + model + '\\'' +
                ", age=" + age +
                '}';
    }
}

3. 定义一个接口并用 @Component 标注

用来把 Engine 注入到 MainActivity 中

@Component
public interface MainComponent {
    /**
     * 必须让Component知道需要往哪个类中注入,这个方法名可以是其它的，但是推荐用inject
     * 目标类MainActivity必须精确，不能用它的父类
     */
    void inject(MainActivity activity);
}

4. 在 MainActivity 中 onCreate 方法中调用

// DaggerMainComponent 这个类是 Dagger 框架自动生成的辅助类,
DaggerMainComponent.create().inject(this);

之后就可以使用 mEngine 这个对象了,框架是通过调用 Engine 的构造函数生成了一个 Engine 对象并注入了 MainActivity。

注入的对象构造函数有参数,也需要提供参数对象

public class MainActivity extends AppCompatActivity {

    @Inject Car mCar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerMainComponent.create().inject(this);

    }

    public void onClick(View view) {
        Toast.makeText(this,mCar.toString(),Toast.LENGTH_SHORT).show();
    }
}

dagger 框架会直接通过 Engine Tire的被 @Inject 的构造函数提供 Car 构造函数的参数对象。

public class Car {
    private Engine mEngine;
    private Tire mTire;

    @Inject
    public Car(Engine engine,Tire tire) {
        mEngine = engine;
        mTire = tire;

    }

    @Override
    public String toString() {
        return "Car{" +
                "mEngine=" + mEngine +
                ", mTire='" + mTire + '\\'' +
                '}';
    }
}

Engine对象见前文2处；

public class Tire {

    private int radius;

    // 提供 Car 构造函数的 Tire 对象
    @Inject
    public Tire() {
        radius = 80;
    }

    @Override
    public String toString() {
        return "Tire{" +
                "radius=" + radius +
                '}';
    }
}

@Inject无法满足所有的要求 :

接口无法被构造.
引用的第三方框架对象无法被注解.
可配置的对象无法被配置,只能使用构造函数构造

2. 使用 @Module @Provides

@Inject的局限性, Dagger 提供了另外一套提供实例的办法

@Module
public class TireModule {

    //可以提供一个 Tire 对象实例
    @Provides
    public static Tire provideTire()
    {
        return new Tire();
    }
}

@Module
public class EngineModule {

    // 可以提供一个 Engine 对象实例
    @Provides
    public static Engine provideEngine()
    {
       return new Engine("F1234",2018);
    }
}

@Component(modules = {TireModule.class,EngineModule.class})
public interface MainComponent {
    void inject(MainActivity activity);
}

当要注入 Car 现在构造函数有两个地方可以提供 Engine / Tire对象作为 Car 构造函数的参数

@Inject 标注的构造函数提供
@Module @Provides 提供

Dagger 优先使用 @Module @Provides 提供的对象.

3. @Scope:作用域并不使用在类中，用于定义注解

@Scope的作用主要是在组织Component和Module的时候起到一个实例作用范围的提醒（类似是生命周期）

已经定义好的作用域 @Singleton

@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

@Provides 加上 @Singleton 表明会使用相同的 Car 对象去初始化所有需要 Car 对象的客户端：

@Module
public class CarModule {
    @Provides
    @Singleton
    public static Car provideCar1()
    {
        return new Car(new Engine("F-7890",2020),new Tire());
    }
}

Component的也必须标注 @Singleton 不然会编译报错,作用域不匹配：

@Component(modules = CarModule.class)
@Singleton
public interface MainComponent {
    Car maker();
}

public class MainActivity extends AppCompatActivity {
    private Car car1;
    private Car car2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MainComponent component = DaggerMainComponent.create();
        car1=component.maker();
        car2=component.maker();
    }

    public void onClick(View view) {
        Toast.makeText(this," car1==car2 : "+(car1==car2),Toast.LENGTH_SHORT).show();
    }
}

car1 = car : true

若去掉 @Singleton 注解结果为 false。

@Singleton并不是我们传统单例模式的那种作用，只能保证在一个Component当中只提供同一个实例对象但并不是整个的应用全局只有一个对象，调用DaggerMainComponent.create()两次产生两个 MainComponent对象也会产生两个Car对象,要保证应用全局单例可以配合android中application的特殊性，就可以实现应用全局单例

Module中的方法使用@Singleton标注后，那对应的Component也必须采用@Singleton标注，表明它们的作用域一致，否则编译的时候会报作用域不同的错误。

自定义作用域

@ActivityScoped是一个自定义的作用域注解，作用是允许对象被记录在正确的组件Activity中，当然这些对象的生命周期应该遵循activity的生命周期

@Documented
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface ActivityScoped {
}

@FragmentScoped是一个自定义的作用域注解，作用是允许对象被记录在正确的组件Fragment中，当然这些对象的生命周期应该遵循Fragment的生命周期

@Scope
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface FragmentScoped {}

4. @Qualifier:限定符并不使用在类中，用于定义注解

定义好的限定符 @Named

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {

    /** The name. */
    String value() default "";
}

 @Named("provideCar2")
 @Inject Car mCar;

在宿主中使用时，可以通过 @Named 来选择所需要的那个实例

@Module
public class CarModule {
    @Provides
    public static Car provideCar1()
    {
        return new Car(new Engine("F-7890",2020),new Tire());
    }
    @Provides
    @Named("provideCar2")
    public static Car provideCar2()
    {
        return new Car(new Engine("X-7890",2030),new Tire());
    }
}

@Component(modules = CarModule.class)
public interface MainComponent {
    void inject(MainActivity activity);
}

自定义限定符

@Qualifier
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface ForTest {
}

5. @Binds

@Binds 可以用于当需要一个父类对象时,用子类对象进行替代 (接口同理)

public class Car {

}

public class BenzCar extends Car {

    @Inject
    public BenzCar() {
    }
}

@Module
public abstract class CarModule {
    
    @Binds
    abstract Car provideCar(BenzCar car);
}

@Component(modules = CarModule.class)
public interface MainComponent {
    Car maker();
}

public class MainActivity extends AppCompatActivity {
    @Inject
    Car car;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        car=DaggerMainComponent.create().maker();
    }

    public void onClick(View view) {
        Toast.makeText(this,car.getClass().getSimpleName(),Toast.LENGTH_SHORT).show();
    }

}

结果为 :

BenzCar

通过 @Binds 当需要注入一个 Car 对象可以使用子类对象 BenzCar 进行绑定注入.

6. @BindsInstance

上述注入对象都是通过 Dagger 自动注入的,如果我们需要 new 一个对象传入 Dagger 就可以使用 @BindsInstance

public class Car {
    private Engine mEngine;
    private Tire mTire;
    // 提供一个 Car 对象,但是需要 Engine / Tire对象作为参数
    @Inject 
    public Car( Engine engine, Tire tire) {
        mEngine = engine;
        mTire = tire;

    }
    
}

public class Engine {
    private String model;
    private int age;
    public Engine(String model, int age) {
        this.model = model;
        this.age = age;
    }
}

public class Tire {


    private int radius;
    // Tire 不提供对象,手动注入
    public Tire(int radius) {
        this.radius = radius;
    }
}

@Component.Builder 注明一个 MainComponent builder @BindsInstance 定义一个传入手动对象的方法

@Component(modules = EngineModule.class)
public interface MainComponent {
    Car maker();

    @Component.Builder
    interface Builder {
        @BindsInstance
        Builder tire(Tire tire);
        MainComponent build();
    }
}

要构造 Car 对象需要 Engine Tire对象 ,Engine对象框架自动生成, Tire对象由我们手动传入

public class MainActivity extends AppCompatActivity {
    @Inject
    Car car;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 手动注入 Tire 对象
        car=DaggerMainComponent.builder().tire(new Tire(90)).build().maker();
    }

    public void onClick(View view) {
        Toast.makeText(this,car.toString(),Toast.LENGTH_SHORT).show();
    }

}

7. Lazy<T> 和 Provider<T>

Lazy<T>

@Module
public class CarModule {
    @Provides
    public static Car provideCar1()
    {
        return new Car(new Engine("F-7890",2020),new Tire());
    }

}

@Component(modules = CarModule.class)
public interface MainComponent {
    Lazy<Car> maker();
}

public class MainActivity extends AppCompatActivity {
    private Car car1;
    private Car car2;

    @Inject
    Lazy<Car> mCarLazy;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mCarLazy=DaggerMainComponent.create().maker();
        car1=mCarLazy.get();
        car2=mCarLazy.get();
    }

    public void onClick(View view) {
        Toast.makeText(this," car1==car2 : "+(car1==car2),Toast.LENGTH_SHORT).show();
    }

}

car1 = car : true

当注入 Lazy<Car>对象的时候只有在调用 get 方法的时候才会去调用 provideCar1 初始化 Car 对象,实现懒加载且会缓存 Car 对象每次进行 get()的时候返回的是同一个 Car 对象.

Provider<T>

**把上述的代码的 Lazy<Car> 改为 Provider<Car>,其他不变 **

car1 = car : false

当注入 Provider<Car> 对象的时候每次调用 get 方法的时候才会去调用 provideCar1去创建一次新的 Car 对象.

如果 Provider<Car> 注入过程中给 @Provides ,@Component 加上 @Singleton结果会如何呢 ?

@Module
public class CarModule {
    @Provides
    @Singleton
    public static Car provideCar1()
    {
        return new Car(new Engine("F-7890",2020),new Tire());
    }

}

@Component(modules = CarModule.class)
@Singleton
public interface MainComponent {
    Provider<Car> maker();
}

结果为 :