Dagger2 (二) 进阶篇
一.作用域Scope
之前了解RoboGuice的时候，我们知道它默认给我们提供了几个注解，ContextSingleton和Singleton，但是Dagger2更为灵活，只有javax包中提供的Singleton注解。更为强大的是，我们可以自定义作用域。
首先我们定义一个运行时的注解。
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface PerActivity {
}我们新增加一个Module，专门为Activity中提供依赖。
@Module
public class ActivityUtilModule {
private Activity activity;
public ActivityUtilModule(Activity activity) {
this.activity = activity;
}
@Provides
public Resources provideResource() {
return activity.getResources();
}
@Provides
@PerActivity
public Toaster provideToaster() {
return new Toaster(activity);
}
}然后我们新增一个Component来承载这个Module，注意，这里我用了dependencies，这样Component就可以传递依赖到子Component。
@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = ActivityUtilModule.class)
public interface ActivityComponent {
void inject(MainActivity activity);
}我们修改ApplicationComponent，让其不再直接注入到Activity中，而使用ActivityComponent来注入。
在MainActivity中我们这样写：
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Inject
Toaster toaster;
@Inject
@Named("app")
Context context;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ActivityComponent activityComponent = DaggerActivityComponent.
builder().
activityUtilModule(new ActivityUtilModule(this)).
applicationComponent(component()).
build();
activityComponent.inject(this);
toaster.longToast(context.getPackageName());
}
protected ApplicationComponent component() {
return ((DaggerApplication) getApplication()).Component();
}
}运行成功后，会弹出包名。相信到这里，大家还是一头雾水。
当我们去掉ActivityComponent中的PerActivity注解时，我们就会发现，编译出错了：这里告诉我们没依赖这个注解，就使用了这个模块，这是编译时期就会不通过的。这里也暴露了作用域的作用，约束一个模块的注入器组件。且在这个组件中使用这个Module时，提供的这个Provider是单例。即组件模块内单例。
Error:(10, 1) 错误: github.pedroneer.dagger2.dagger.ActivityComponent (unscoped) may not reference scoped bindings:
@Provides @github.pedroneer.dagger2.dagger.PerActivity github.pedroneer.dagger2.Toaster github.pedroneer.dagger2.dagger.ActivityUtilModule.provideToaster()好，也许到这里还是不懂，先看下这个例子。
我们将BaseActivity中注入了依赖。
public class BaseActivity extends FragmentActivity {
@Inject
Toaster toaster;
@Inject
@Named("app")
Context context;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ActivityComponent activityComponent = DaggerActivityComponent.
builder().
activityUtilModule(new ActivityUtilModule(this)).
applicationComponent(component()).
build();
activityComponent.inject(this);
toaster.longToast(context.getPackageName());
}
private ApplicationComponent component() {
return ((DaggerApplication) getApplication()).Component();
}
}此外，我们MainActivity和SecondActivity都继承自BaseActivity，这也符合我们平时的做法。
public class MainActivity extends BaseActivity {
private static final String TAG = "toaster";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
toaster.longToast(context.getPackageName());
Log.d(TAG, "onCreate: " + toaster.hashCode());
Intent intent = new Intent(this, SecondActivity.class);
startActivity(intent);
}
}public class SecondActivity extends BaseActivity {
private static final String TAG = "toaster";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
toaster.longToast(context.getPackageName());
Log.d(TAG, "onCreate: " + toaster.hashCode());
}
}那接下来我们打印的两个hashCode会是同一个么？
当然不是。
03-21 00:32:57.706 12716-12716/github.pedroneer.dagger2 D/toaster: onCreate: 531688530
03-21 00:32:57.866 12716-12716/github.pedroneer.dagger2 D/toaster: onCreate: 204017154因为我们在BaseActivity中就指定了每次创建时都会创建一个新的ActivityComponent，但ActivityComponent中依赖的ApplicationComponent确是一个，因为我们每次都是从DaggerApplication中拿这个对象注入的。
也就是说，注解了PerActivity的对象，只在一个模块的组件生命周期内单例。
再看下面的例子：
我们提供custom和the两种toaster。
@Module
public class ActivityUtilModule {
private Activity activity;
public ActivityUtilModule(Activity activity) {
this.activity = activity;
}
@Provides
public Resources provideResource() {
return activity.getResources();
}
@Provides
@PerActivity
@Named("custom")
public Toaster provideToaster() {
return new Toaster(activity);
}
@Provides
@Named("the")
public Toaster provideTheToaster() {
return new Toaster(activity);
}
}并在ActivityComponent中提供依赖。
@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = ActivityUtilModule.class)
public interface ActivityComponent {
void inject(BaseActivity activity);
@Named("custom")
Toaster theToaster();
@Named("the")
Toaster toaster();
}最后我们在MainActivity中查看下多次获取这个两个依赖的情况。
public class MainActivity extends BaseActivity {
private static final String TAG = "toaster";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(TAG, "onCreate: " + activityComponent.theToaster().hashCode());
Log.d(TAG, "onCreate: " + activityComponent.theToaster().hashCode());
Log.d(TAG, "onCreate: " + activityComponent.toaster().hashCode());
Log.d(TAG, "onCreate: " + activityComponent.toaster().hashCode());
}
}03-21 00:46:34.836 24014-24014/github.pedroneer.dagger2 D/toaster: onCreate: 1028556617
03-21 00:46:34.836 24014-24014/github.pedroneer.dagger2 D/toaster: onCreate: 1028556617
03-21 00:46:34.836 24014-24014/github.pedroneer.dagger2 D/toaster: onCreate: 857606222
03-21 00:46:34.836 24014-24014/github.pedroneer.dagger2 D/toaster: onCreate: 614825327答案很明显，我们定义了PerActivity中的custom修饰的Toaster每次都是唯一的，而the修饰的则每次创建一个对象。这就是作用域及无作用域的区别。
总结一下，当我们为一个组件打上标签作用域，那么这个组件的生命周期内，模块内的依赖也就随着组件的生命周期消亡而消亡，如果模块内存在提供作用域的Provider，而使用这个模块的组件不标注该作用域，则编译报错。Provider中提供的方法在同一模块内每次调用都会初始化，而标明了作用域的则不会。
二.绑定类型
这个上面的例子已经用过了，使用方法和RoboGuice相同，Dagger2也增加了Qualifier的概念，即可以自定义注解标示组件提供需要的注入类型。这里不做赘述。
三.懒加载
Dagger2支持Lazy Load，即在我们真正使用对象的时候才回去初始化。
public class MainActivity extends BaseActivity {
@Inject
@Named("the")
Lazy<Toaster> toasterLazy;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if (something()) {
toasterLazy.get().longToast("hello");
}
}
private boolean something() {
return new Random().nextBoolean();
}
}这样大大的提高了我们的效率，比如在BaseActivity中注入了多种依赖，如果不希望创建的时候即初始化，可以使用懒加载，只有在使用的时候初始化。