Dagger2基本使用2之子组件

2023-12-16 11:54:00
  • 一,基本使用,完成一个注入

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);
    }
}

?运行代码

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

三,@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实现

文章来源:https://blog.csdn.net/luck_xiang/article/details/135028933
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。