Dagger基本使用

依赖

annotationProcessor 'com.google.dagger:dagger-compiler:2.41'
implementation 'com.squareup.retrofit2:retrofit:2.9.0'

一、快速实现

1、构造方法使用Inject注

public class User {
    public String name;
    @Inject
  //使用Inject注解在构造方法上，就是告知dagger可以通过构造方法来创建获取到User的实例
    public User(){
        this.name = "Lee";
    }
}

2、创建ApplicationComponent

@Component
public interface ApplicationComponent {
    void inject(MainActivity mainActivity); //选择需要在哪里注入
}

3、在MainActivity中执行依赖注入动作（*）

public class MainActivity extends AppCompatActivity {
		@Inject
    User user;
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
      	//DaggerApplicationComponent是ApplicationComponent的实现类
        DaggerApplicationComponent.create().inject(this);
    }
}

二、使用Module提供对象实例

场景： 使用 Retrofit 处理网络请求

1、创建 NetworkModule对象

@Module
public class NetWorkModule {
    //第二种方式告知dagger，可以通过该方法来获取需要注入的对象
    @Provides
    public Retrofit provideRetrofit(OkHttpClient okHttpClient){
        return new Retrofit.Builder()
                .client(okHttpClient)
                .baseUrl("https://www.baidu.com")
                .build();
    }
    @Provides
    public ApiService provideApiService(Retrofit retrofit){
        return  retrofit.create(ApiService.class);
    }

    @Provides
    public OkHttpClient provideOKHttpClient(){
        return  new OkHttpClient.Builder().build();
    }
}

2、Component关联Module

在AppliationComponent的注解上添加module

@Component(modules = {NetWorkModule.class})
public interface AppComponent {
  void inject(MainActivity mainActivity); // * 
}

3、在MainActivity中执行依赖注入动作

跟上面的例子类似

三、使用作用域实现单例

使用作用域注解，可以将某个对象的生命周期限定为其组件的生命周期。这样也就意味着，在作用域范围内，使用到的是同一实例

@Singleton是dagger提供的一种默认的作用域注解，其意义表示一个单例对象。也就是实例的生命周期和程序运行的生命周期保护一致

在@Provides注解的基础上，添加@Singleton注解

@Singleton
@Provides
public Retrofit provideRetrofit(OkHttpClient okHttpClient){
    return new Retrofit.Builder()
            .client(okHttpClient)
            .baseUrl("https://www.baidu.com")
            .build();
}

同时需要在 Applicationomponent上添加@Singleton

@Singleton
@Component(modules = {NetWorkModule.class})
public interface AppComponent {
}

如果在同一个Activity多次使用 @Inject 的对象，可以发现是属于同一个实例

但是在不同的Activity中使用注入相同的对象,发现属于不同的实例

解决办法,在Application中构造相同的 ApplicationComponent对象

public class MyApplication extends Application {
    public static AppComponent getAppComponent() {
        return appComponent;
    }
    static AppComponent appComponent = DaggerAppComponent.create();
}

在不同的Activity中使用

@Singleton
@Component(modules = {NetWorkModule.class})
public interface AppComponent {
    void inject(MainActivity mainActivity);
    void inject(SecondActivity secondActivity);
}

public class SecondActivity extends AppCompatActivity {
    @Inject
    ApiService apiService;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        //从Application中获取实例
        MyApplication.appComponent.inject(this);
        System.out.println("apiService = " + apiService);
    }
}