Dagger2基本使用2之子组件

一，基本使用，完成一个注入

1，创建作用域

//自定义作用域，作用域只是一个名称，随便起啥名字都可以，这里取一个全局单利的名字
@Scope
@Documented
@Retention(RUNTIME)
public @interface GlobalSingleton {
}

2，创建一个module

public interface ApiService {
}

//调用dagger的@Component注解，这个里面可以创建多个注解
@Module
public class NetModule {
    //作用域的范围是DaggerMainComponent.create()执行的在哪里就是那个范围
    @GlobalSingleton
    //外部引用的类无法在构造方法上增加@Inject，通过@Privides方法进行创建对象
    @Provides
    public Retrofit provideRetrofit() {
        Retrofit retrofit = new Retrofit.Builder().baseUrl("http://www.baidu.com").build();
        Log.e("NetModule", "new Retrofit" + retrofit);
        return retrofit;
    }

    @GlobalSingleton
    //通过参数传入在Module中创建的值，这里代码执行相当于provideApiService(provideRetrofit()),调用了provideRetrofit()
    //方法传入参数
    @Provides
    public ApiService provideApiService(Retrofit retrofit) {
        ApiService apiService = retrofit.create(ApiService.class);
        Log.e("NetModule", "new ApiService  retrofit " + retrofit);
        Log.e("NetModule", "new ApiService " + apiService);
        return apiService;
    }
}

3，创建 Component组件

//modules中有指定作用域的，Componet上必须是同一个作用域
@GlobalSingleton
//调用dagger的@Component注解，这个里面可以创建多个注解
@Component(modules = {NetModule.class})
public interface ApplicationComponent {
    //哪个个类需要注入，这里是MainActivity需要注入含有@Inject的类
    void inject(MainActivity mainActivity);

}

4，初始化一个全局Component

public class DaggerApplication  extends Application {
    //这里可以直接定义为static，应为Application生命周期是整个app，这里是在Application创建，告诉Dagger的作用域
    //为整个app
    private static final ApplicationComponent applicationComponent=DaggerApplicationComponent.create();

    public static ApplicationComponent getApplicationComponent() {
        return applicationComponent;
    }
}

5，注入实例化类

public class MainActivity extends AppCompatActivity {

    @Inject
    Retrofit retrofit;
    @Inject
    ApiService apiService;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.e("MainActivity", "new onCreate");
        //dagger会自动生成一个Dagger+创建的接口名称的类，初始化注入器
        DaggerApplication. getApplicationComponent().inject(this);
        startActivity(new Intent(this,MainActivity2.class));
    }
}

 二，实现子组件，完成子组件局部单利

按照上面的写法，装载到Component上module只能是全局单利，想要注入的类是在是局部单利，就要使用到子组件才行

1，定义子组件作用域

//创建一个子组件的作用域
@Scope
@Documented
@Retention(RUNTIME)
public @interface LocalSingleton {
}

2，创建子组件module

public class User {
    public User() {
        Log.e("User", "new User()");
    }
}

@Module
public class UserModule {
    //使用局部单利必须要有作用域
    @LocalSingleton
    @Provides
    public User provideUser(){
        return new User();
    }
}

3，创建字组件component，并装载父组件到子组件上

//父组件有作用域，子组件必须有作用域
//dependencies = ApplicationComponent.class这里将父组件装载到子组件上，相当于继承了
//父组件的功能
@LocalSingleton
@Component(modules = UserModule.class, dependencies = ApplicationComponent.class)
public interface UserComponent {
    //
    void inject(MainActivity2 mainActivity2);
}

4，父组件显示声明

这种写法子组件需要用到父组件中提供的provide注入实例，就需要显示在父组件中显示声明才行

//modules中有指定作用域的，Componet上必须是同一个作用域
@GlobalSingleton
//调用dagger的@Component注解，这个里面可以创建多个注解
@Component(modules = {NetModule.class})
public interface ApplicationComponent {
    //哪个个类需要注入，这里是MainActivity需要注入含有@Inject的类
    void inject(MainActivity mainActivity);

    //子组件需要用到父组件的类，必须在父组件中申明
    Retrofit retrofit();
}

5，注入实例到类中

public class MainActivity2 extends AppCompatActivity {

    @Inject
    Retrofit retrofit;
    @Inject
    User user;
    @Inject
    User user2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        Log.e("MainActivity2", "new onCreate MainActivity2");
        //UserComponent实例只能通过build获取到
        UserComponent userComponent=  DaggerUserComponent.builder().applicationComponent(
                DaggerApplication.getApplicationComponent()).build();
        //开始注入实例
        userComponent.inject(this);
    }
}

 6，运行代码

从打印中可以看到，子组件注入的实例类只创建了一个，也注入了父组件的实例类

三，@Subcomponent注解实现组件依赖

修改第二条中一些类

修改UserComponent名字为UserSubComponent，修改内容如下

@LocalSingleton
//创建子组件的注解
@Subcomponent(modules = UserModule.class)
public interface UserSubComponent {
    //创建Factory，后续在父组件上调用，告诉父组件这个组件为子组件
    @Subcomponent.Factory
    interface Factory{
        UserSubComponent create();
    }
    void inject(MainActivity2 mainActivity2);
}

修改ApplicationComponent

//modules中有指定作用域的，Componet上必须是同一个作用域
@GlobalSingleton
//调用dagger的@Component注解，这个里面可以创建多个注解
@Component(modules = {NetModule.class})
public interface ApplicationComponent {
    //哪个个类需要注入，这里是MainActivity需要注入含有@Inject的类
    void inject(MainActivity mainActivity);

    //绑定子组件到父组件上
    UserSubComponent.Factory userSubComponent();

    //Subcomponent创建的子组件使用父组件实例类，不需要显示声明
//    Retrofit retrofit();

}

修改注入类代码

public class MainActivity2 extends AppCompatActivity {

    @Inject
    Retrofit retrofit;
    @Inject
    User user;
    @Inject
    User user2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        Log.e("MainActivity2", "new onCreate MainActivity2");
        //UserSubComponent实例获取
        UserSubComponent userSubComponent = DaggerApplication.getApplicationComponent()
                .userSubComponent().create();
        //开始注入实例
        userSubComponent.inject(this);
    }
}

运行代码

+

代码打印和之前的一样，这就是用Subcomponent实现