dagger2系列之依赖方式dependencies、包含方式(从属方式)SubComponent

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

本篇是实战文章，从代码的角度分析这两种方式。本文参考自下列文章：

http://www.jianshu.com/p/1d42d2e6f4a5

http://www.jianshu.com/p/94d47da32656

一般在项目中我们需要全局使用app或者其他，这个时候就需要有一个全局的Component作为桥梁，提供给使用方使用。一个Component可以依赖一个或多个Component，并拿到被依赖Component 暴露出来的实例。

<一>依赖关系

全局提供App实例类、上下文Context

@Module
public class AppModule5 { private App5 app; public AppModule5(App5 app) {
this.app = app;
} @Provides
public App5 provideApp() {
return app;
} @Provides
Context provideApplicationContext() {
return app.getApplicationContext();
}
}

提供全局提供App实例类、上下文Context桥梁，该Component会被其他Component依赖

@Component(modules = {AppModule5.class})
public interface AppComponent5 {
void inject(App5 app); //因为AppComponent会被dependencies，所以此处Module中提供的内容，我们需要在此处声明一下
App5 getApp();
Context getApplicationContext();
}

由于AppComponent5会被其他Component依赖，所以此处需要显示地声明AppModule5中提供的东西，此处的方法名任意！！！

App被全局提供

public class App5 extends Application { private AppComponent5 mAppComponent5; @Override
public void onCreate() {
super.onCreate();
mAppComponent5 = DaggerAppComponent5.builder().appModule5(new AppModule5(this)).build();
mAppComponent5.inject(this);
} public AppComponent5 getAppComponent5(){
return mAppComponent5;
}}

若Module的构造器需要参数，我们就需要在这里appModule5(new AppModule5())，若Module的构造器中不需要参数，此处可以省略！！！需要通过这种方式将参数传递进去。

提供被依赖类：

@Module
public class ActivityModule5 { @Provides
public DependencyPresenter getDependencyPresenter(App5 app){
return new DependencyPresenter(app);
}
}

桥梁：

@Component(dependencies = AppComponent5.class,modules = ActivityModule5.class)
public interface ActivityComponent {
void inject(TargetActivity5 activity5);
}

使用了Component的dependencies属性，ActivityModule5提供被依赖类，AppComponent5提供被依赖类的参数(全局提供)。

被依赖类：此处没用@inject修饰构造器

public class DependencyPresenter { public DependencyPresenter(App5 app){
Log.d("Dagger.class","DependencyPresenter-----构造器------(app == null)?????："+(app == null));
} public void printMethod(){
Log.d("Dagger.class","DependencyPresenter-----printMethod()-----");
}}

目标类

public class TargetActivity5 extends AppCompatActivity { @Inject
DependencyPresenter mDependencyPresenter; @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main); App5 app5 = (App5) this.getApplication(); DaggerActivityComponent.builder().appComponent5(app5.getAppComponent5()).build().inject(this); mDependencyPresenter.printMethod();
}
}

由于ActivityComponent依赖AppComponent，所以需要在此处添加声明appComponent(app5.getAppComponent)。

由此得到结论：需要在Component中显示的声明提供被依赖类的方法(方法名任意)

1 同一个Component的两个Module之间，当ModuleA需要ModuleB提供参数,在Component中需要提供获取参数的方法

2 ComponentA和它所依赖的ComponentB之间，若ComponentA需要ComponentB提供参数，在ComponentB中需要显示声明方法

<二>包含方式（从属方式）@SubComponent

当我们的Component需要依赖全局的Component提供的实例或者参数的时候，我们上面的实现方式是选择Component的dependencies属性，此时需要在被依赖的Component中有显示的声明。这里介绍另一种方法，包含方式。相比于依赖方式，包含方式不需要在父Component中显示的提供方法，就可以拿到想要的东西。下面看一下代码：

使用@Subcomponent注解标注ActivityModule6，代表它是子Component

@Subcomponent(modules = ActivityModule6.class)
public interface ActivityComponent6 {
void inject(TargetActivity6 activity5);
}

父Component：

@Component(modules = {AppModule6.class})
public interface AppComponent6 {
void inject(App6 app); ActivityComponent6 getSubComponent();
}

需要在父Component中声明自己的子Component，方法名任意。如果ActivityComponent6中的Module的构造器需要参数，则在此处传递进去，譬如：

ActivityComponent6 getSubComponent(new ActivityModule6("参数"));

目标类：使用方式上也有区别

public class TargetActivity6 extends AppCompatActivity { @Inject
DependencyPresenter6 mDependencyPresenter; @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main); App6 app6 = (App6) this.getApplication();
app6.getAppComponent6().getSubComponent().inject(this);
mDependencyPresenter.printMethod();
}
}

其他类均没有变化。依赖方式、包含方式介绍到此为止～更多的内容请参看上面的链接！！！