- 一，基本使用，完成一个注入
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实现
