世界是普遍联系的，任何事物和个体都直接或间接相互依赖，在时空长河中共同发展。在面向对象的世界中，更是如此，类与类之间的依赖，关联关系，模块（亦或是分层架构中的层）之间的耦合关系，都是我们在软件开发实践中，时刻在处理着的联系。
在软件开发中，我们一直尝试弱化这种联系，以便让软件程序更健壮，更灵活，便于维护和升级。从面向过程遍程中提倡方法的分离（过程分离），到面向对象开发中的减少类依赖，层间低耦合，层内高类聚，无一不体现了这一点。正因为在面向对象的世界中，我们更容易处理类（对象），模块（或层）之间的关系，所以面向对象开发才成为了更受欢迎的开发方式。
为了处理代码中的依赖关系，依赖注入框架应运而生。在Java的世界中，开源的依赖注入框架更是不胜枚举，如PicoContainer ，google-guice，Butterfly Container 。。。。。而正如上一篇文章中提到的，Dagger2是第一个使用生成代码的方式实现依赖注入的框架，它完全依赖Java的注解处理和编译时检查来分析和验证依赖，在代码执行效率上拥有无可比拟的优势，而大部分的依赖注入框架都有依赖XML、运行期验证依赖或者影响应用启动速度的问题，所以它依然是我们今天要介绍的主角。
关于Dagger2，已在上一篇文章中详细介绍，在Android开发中，我们可以使用ButterKnife来进行控件注入（但是在子module中使用会有问题），使用Dagger2来进行依赖注入。下面我们来看看在Android开发中，如何使用Dagger2来处理依赖关系。
原理
使用依赖注入是为了降低类之间的依赖关系，从而达到被依赖的类（被依赖者）可以相对独立的变化而不影响其使用者（依赖者），同时在开发和测试过程中，也方便使用mocking object替代原有的被依赖类型，适应不同的开发环境和测试。如何处理好关系，关键在于划分二字，我们通常所说的责任、功能的划分，层、模块、类、方法的划分，都是为了更好的处理各种各样的关系。在Dagger2的使用中，我们依然需要良好划分它的各个组件以便更好的使用它。
下图是Android中推荐的组件级别划分，不熟悉Component，Provide和Module的小伙伴请看上一篇文章。
Application component/module
Application component/module一般提供和应用相同生命周期的依赖，所以通常和@Singleton关联，并暴露必要的依赖以便component dependency使用（通常application component会最为父组件或者component dependency中的dependency）。
Activity component/module
Activity component/module一般提供和Activity相同生命周期的依赖，通常和@PerActivity关联，并且一般是SubComponent或者component dependency。使用Activity component有以下几个好处：
可在Activity中注入字段（暴露inject方法在Activity中调用）。
在Activity基类中注入和使用单例对象
全局对象图不用涉及只在Activity中用到的依赖。
User component/module
User component/module用于提供User相关的依赖，一般也和@PerActivity关联，通常会扩展Activity Component，用于注入Fragment。
通常我们会建立一个包含很多接口的主Component，如果希望有多个不需要一直保留在内存中的components（例如绑定到Activity、Fragment甚至用户会话期的components），我们可以创建Dependent component。使用Dependent components需要注意这些方面：
1.两个Dependent components不能共享相同的Scope。
2.虽然Dagger2有创建Scope实例的能力，你依然有责任根据场景创建和删除（实例）应用。
3.创建Dependent components的时候，父component需要明确暴露下游组件需要的依赖对象。
Dependent components和SubComponents的差别在于：
- SubComponent需要在子组件声明工厂方法提供实例或Builder。Dependent components只需要传入父Component的实例即可正常初始化。
- SubComponent可以访问父Component的所有依赖，而Dependent components只能访问父Component声明提供的依赖。
注意
Dagger2区别于其他诸如框架的主要优势在于它严格依靠生成代码实现（而非反射），这意味着它可以适用于Android。当然，在Android应用中使用Dagger的时候仍然有一些需要考虑的地方。
因为Android应用采用Java语言来开发，从风格来说会非常不同。这种典型的区别是为了适应移动平台独特的表现考虑。
但是与其他的Java代码相反的是，很多模式在Android上都不适用，甚至《高效Java开发》中的大部分建议都被认为不适合Android。
为了同时达到代码惯用（符合语言习惯）和轻便的目标，Dagger依靠ProGuard来处理编译的字节码，这允许Dagger生成在Server和Android上看起来都很自然的代码（当使用不同的工具链来生成在这两个环境中都能高效执行的代码时）。更多的是，Dagger有明确的目标来确保生成的代码和ProGuard的优化兼容一致。
当然不是所有的问题都能以这种方式定位，但是它确实是提供Android特定兼容的主要机制。
Dagger假设Android开发者会使用ProGuard。
Talk is cheap，Show you the code
Setup
我们以AndroidStudio作为IDE，以下简称AS。AS 默认不会把Dagger2生成的代码视作合法的classes，我们可以通过添加android-apt插件将这些文件加入到IDE的class path。我们可以在Project的build.gradle中添加工程依赖：
dependencies { // other classpath definitions here classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' }
然后在用到Dagger2的Module中（如app）应用apt插件：
// add after applying plugin: 'com.android.application' apply plugin: 'com.neenbedankt.android-apt'
同时添加如下Module依赖：
dependencies { // apt command comes from the android-apt plugin apt 'com.google.dagger:dagger-compiler:2.2' compile 'com.google.dagger:dagger:2.2' provided 'javax.annotation:jsr250-api:1.0' }
Provided关键词引用的依赖只会在编译时需要，apt关键词是android-apt插件提供的，用于注解处理。
Coding
下面是一个简单的关于宠物的Demo，仅用于说明Dagger2的使用。
一般情况下，在Dagger2中，我们直接使用到的是Component，所以我们首先想到的是创建Component，按照上文的建议和一般的开发习惯，我们会先创建Application级别的Component，用于提供全局的服务或资源。
public interface AppComponent { /** * Provide your application level handler instance. * * @return */ Handler getHandler(); /** * Provide your global http requester instance. * * @return */ IHttpRequester getHttpRequester(); /** * Provide your global storage service. * * @return */ IStorage getStorage(); }
我们声明了AppComponent，大家可以发现它是一个接口文件，我们在里面我们提供了全局的Handler、HttpRequester和Storage服务，当然在实际工程中你可以提供更多的服务。
既然声明了接口，那必然需要有它的实现，但是Dagger2会为我们做这件事，我们需要做的是使用Module来为Component接口声明的方法提供实际的依赖。
/** * Created by Irwin on 2016/5/16. */ @Module public class AppModule { @Provides @Singleton public static Handler provideHandler() { return new Handler(); } @Provides @Singleton public static IHttpRequester provideHttpProvider() { return new DefaultHttpRequester(); } @Provides @Singleton public static IStorage provideStorage() { return new SqliteStorage(); } }
我们实现一个AppModule来为AppComponent提供依赖，其中提供了实际的Handler，HttpRequester和Storage。因为都是全局单例，所有都使用了Singleon关键字和static关键字。然后我们需要通过注解把AppComponent和AppModule关联起来，如下：
/** * Created by Irwin on 2016/5/16. */ @Component(modules = AppModule.class) @Singleton public interface AppComponent { ...... }
完成后我们可以编译代码，如果没有出错，可以在Build目录下找到Dagger2为我们生成的Component接口的实现代码。
接下来，我们在Application中初始化Component：
public class MyApplication extends Application { private AppComponent mAppComponent; private String TAG = "ApplicationInfo"; @Override public void onCreate() { super.onCreate(); mAppComponent = DaggerAppComponent.create(); } public AppComponent getAppComponent() { return mAppComponent; } }
为了增加趣味性，我们这个Demo是简单展示宠物的，所以接下来我们添加一个宠物类。
/** * Created by Irwin on 2016/5/16. */ public interface IPet { public int getPortrait(); public String getType(); public String getName(); public String getStatus(); public void enjoy(TextView view); }
/** * Created by Irwin on 2016/5/16. */ public abstract class AbsPet implements IPet { private int mIndex = -1; private String mStatus; private int mPortrait; @Inject Handler mHandler; @Inject List<String> mStatusList; @Inject protected String mName; @Inject @Descript("Yell") protected String mYell; public AbsPet(int portrait) { mPortrait = portrait; } @Override public String getName() { return mName; } @Override public int getPortrait() { return mPortrait; } public Handler getHandler() { return mHandler; } public List<String> getStatusList() { return mStatusList; } @Override public String getStatus() { if (mStatus == null) { mStatus = mYell; } return mStatus; } @Override public void enjoy(final TextView view) { if (mIndex == -1) { view.setText(mYell); } Random random = new Random(System.currentTimeMillis()); int seconds = random.nextInt(5); if (seconds < 1) { seconds = 1; } getHandler().postDelayed(new Runnable() { @Override public void run() { boolean hasNext = nextStatus(); if (hasNext) { enjoy(view); } view.setText(getStatus() + (hasNext ? " Ing" : " ...")); } }, seconds * 1000); } public boolean nextStatus() { if (++mIndex < getStatusList().size()) { mStatus = getStatusList().get(mIndex); return true; } mIndex = -1; return false; } }
然后分别实现两只宠物，Dog和Cat，这是我们具体要依赖的对象，下面是Dog的代码。
public class Dog extends AbsPet { private String mType; @Inject public Dog(int portrait) { super(portrait); this.mType = "汪星人"; } @Override public String getType() { return mType; } }
注意构造函数上的@Inject注解，它表明Dagger2可以自动new 这个类的实例。
接下来，我们添加一个Activity来显示宠物，
public class MainActivity extends AppCompatActivity { private static final String TAG = "Info"; private GifImageView mPetView; private TextView mTV_Info; private TextView mTV_Status; @Inject IPet mPet; ...... }
如代码中所示，我们将mPet字段添加@Inject注解，通过依赖注入的方式提供值。
需要注入字段的类也需要有一个Component来实现注入，所以我们为此Activity添加一个Component，在此之前我们先添加一个Module来为Component提供依赖，下面是提供Dog依赖的Module
@Module(includes = DogStatusModule.class)
public class DogModule { @Provides @Activity public IPet provideDog(Dog dog) { return dog; } @Provides public List<String> provideStatus(Set<String> set) { return new ArrayList<>(set); } @Provides public String provideName() { return "二汪"; } @Provides public int providePortrait() { return R.drawable.dog2; } @Provides @Descript("Yell") public String provideYell() { return "汪汪"; } }
其中我们为DogModule提供了它所需要的状态Module DogStatusModule。
接下来添加Activity的Component并关联DogModule，
@Component(dependencies = AppComponent.class, modules = DogModule.class)
@Activity
public interface PetActivityComponent {
public void inject(MainActivity activity);
public IPet getPet();
}
完成并编译后，可以在Build目录下找到Dagger2为我们生成的Component接口的实现代码。接下来我们就可以在Activity中简单的使用：
public class MainActivity extends AppCompatActivity { private static final String TAG = "Info"; private GifImageView mPetView; private TextView mTV_Info; private TextView mTV_Status; @Inject IPet mPet; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); setSupportActionBar(toolbar); mPetView = (GifImageView) findViewById(R.id.IMV_Pet); mTV_Info = (TextView) findViewById(R.id.TV_Info); mTV_Status = (TextView) findViewById(R.id.TV_Status); PetActivityComponent component = DaggerPetActivityComponent.builder() .appComponent(((MyApplication) getApplicationContext()).getAppComponent()) .build(); //You must call inject first so that Dagger2 will inject fields for you, otherwise you'll get NullPointer exceptions. component.inject(this); FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab); fab.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { playWith(mPet); getHttpRequester().request(0, "http://www.baidu.com", "search=dagger2", new IResultHandler<String>() { @Override public void onSuccess(String o) { Log.i(TAG, "Response: " + o); } @Override public void onFail(Throwable error) { } }); } }); bindPet(mPet); } public void bindPet(IPet pet) { mPetView.setImageResource(pet.getPortrait()); mTV_Info.setText(getString(R.string.PetInfo, mPet.getType(), mPet.getName())); mTV_Status.setText(pet.getStatus()); } public void playWith(IPet pet) { pet.enjoy(mTV_Status); } public IHttpRequester getHttpRequester() { return ((MyApplication) getApplicationContext()).getAppComponent().getHttpRequester(); } public IStorage getStorage() { return ((MyApplication) getApplicationContext()).getAppComponent().getStorage(); } }
在调用Component的Inject后，Dagger2就为mPet字段注入了值，然后我们就可以放心的使用mPet字段了,同时，我们还可以使用AppComponent中提供的所有服务或资源，如
((MyApplication) getApplicationContext()).getAppComponent().getHttpRequester().request(...);
至此，代码编写完成。当然，我们还添加了一些额外的代码，如HttpRequester，不同的Storage实现，CatModule，全局都是通过Dagger2使用这些实现，所以你可以随意改变自己的实现或者替换依赖，而不影响上层代码的使用，可以使你的开发和测试变得更简单哦！
运行工程，就可以看到效果了，
此时，如果我们希望使用依赖对象的不同实现，简单的替换Component依赖的Module,或者直接修改Module中相应提供依赖的地方即可。下面我们将Activity中的关联的DogModule替换为CatModule
@Component(dependencies = AppComponent.class, modules = CatModule.class) @Activity public interface PetActivityComponent { ...
}
替换后效果：
在实际的开发环境中，你可以随意替换不同的存储，网络请求实现来满足不同的场景和需求，是不是很方便：D
总结
一、 使用Dagger需要引入Dagger和Dagger compiler，在IDEA和Eclipse中可能需要打开Annotation processor。在AndroidStudio中需要引入android-apt plugin（see https://bitbucket.org/hvisser/android-apt，用于将Dagger2生成的代码加入classpath）
Android-apt插件帮你把annotation processors和AndroidStudio结合起来使用，它主要有两个功能：
1.允许配置编译时的annotation作为依赖，但是不会把这些东西包括到最终的Apk或Library中。
2.设置源码路径以便注解处理生成的代码可以被AndroidStudio识别。
二、 类构造函数加上@Inject生成实例，类字段加上@Inject可注入字段，注入字段依靠@Inject的构造函数或者@Provides方法。
注：
- Dagger2不能注入final字段和static字段，以及不可访问的字段（Private）。
- Dagger2无法注入多个类型相同的字段，但是可以通过加上qualifier识别依赖。
- Dagger2创建实例是在生成的T_Factory中进行的，而注入字段是通过T_MembersInjector中完成的，所以直接调用new T()不会注入字段。对于已有的非Dagger注入的对象，可以在Component中添加inject(T)（方法名可以随意）方法，调用这个方法就可以注入需要的字段。
三、 @Provides方法可以有自己的依赖，返回不同的类(也可以是基本类型)。
四、 用一个接口（或抽象类）来提供Component，这个接口里面应该声明没有参数但返回需要类型的方法，接口上需要加上@Component，并通过module参数引入需要的module。Dagger会按照约定生成一个Component实现。
五、 Component的使用方式有两种：一种是使用builder并传入需要的module；另一种是直接调用它的create()方法（适用于它的module中全是@Provides的静态方法时或有无参构造函数时）。
Component像连接@Module和@Inject的桥梁，将所有的东西联系起来。
Component实现主要是通过生成的builder来实例化。使用它的builder()方法来获取一个builder实例。如果一个嵌套的@Component.Builder类型已经存在，builder()方法会返回它的一个生成实现；如果嵌套的@Component.Builder不存在，返回的builder会提供设置每一个需要的modules和component依赖的方法（方法名是以小驼峰命名法命名的module和component类型名）。没有可见默认构造函数的module和component依赖必须明确设置，但是有默认或无参构造函数的可被component访问的module可以省略。下面是使用component builder的例子：（From：http://google.github.io/dagger/api/latest/dagger/Component.html）
public static void main(String[] args) { OtherComponent otherComponent = ...; MyComponent component = DaggerMyComponent.builder() // required because component dependencies must be set .otherComponent(otherComponent) // required because FlagsModule has constructor parameters .flagsModule(new FlagsModule(args)) // may be elided because a no-args constructor is visible .myApplicationModule(new MyApplicationModule()) .build(); }
在component只有无参(构造函数)modules，没有component依赖的情况下，component实现也会有一个工厂方法create(),SomeComponent.create()和SomeComponent.builder().build()是等同的。
六、 Module是一个用来满足稍复杂依赖（在@Inject无法满足的时候）的类，以@Module声明，在它里面可以声明@Provides的方法（Provides方法优先于@Inject构造函数），@Provides方法提供Component里面的绑定需要的依赖（通过返回类型指定，所以无法注入多个类型相同的字段），这些依赖可以类实例，也可以是基本类型。Module还可以通过include引入其他的module。
七、 Scope
@Singleton
@Singleton用来标记单例，但是是在component的生命周期而非应用的生命周期中的单例。
如果T被注解为单例（在T的类声明或在provideT上加@Singleton，同时在Component上加@Singleton）,引入T的component中的TProvider会使用如下方式生成(其他的Scope也应如此)：
TProvider= ScopedProvider.create(CoffeeMaker_Factory.create(…));
如果T未被标记为单例，TProvider会这样生成：
TProvider=T_Factory.create(…);
@Scope
用@Scope注解组件就可以加上范围限定。在这种情况下，组件实现会保存对所有加上范围限定的类实例的引用以便重用。有Scope的带有@Provides方法的模块只能被拥有相同范围限定的组件引用。
每一个Component都可以用Scope注解来添加Scope。Component实现确保每个实例中每个Scope绑定只有一个规定。如果Component声明了一个Scope，它就只能包括Unscope或者该Scope的绑定。例如：
@Singleton @Component interface MyApplicationComponent { // this component can only inject types using unscoped or @Singleton bindings }为了让Scope表现正确，何时初始化component实例是调用者的责任。比如说，一个单例组件，在一个应用中只应该被实例化一次，而一个RequestScoped的组件应该请求一次，实例化一次。因为组件是自维护（Self-contained）的实现，退出一个scope跟丢掉对component实例的所有引用一样简单。
父子组件的Scope应该是一种包含关系，父组件的Scope包括的子组件Scope的范围。
八、 Lazy injection
Lazy injection会等到第一次调用Lazy<T>.get()的时候创建T的实例并缓存。
九、 Provider
Provider<T>提供可以返回不同实例的功能，每一次调用Provider<T>.get()都会调用绑定逻辑，生成新的实例。
十、 Qualifier
Qualifier用于单靠类型无法识别依赖的时候（即多个依赖（可注入字段）类型相同时），使用Qualifier注解，Dagger会同时通过类型和qualifier来识别依赖。
十一、 MultiBindings
多重绑定可以把多个对象绑定到一个Set或Map，通过@Provides（type=SET|MAP）方法提供对象到集合中，对于Map 的Key，分为两种方式：一种是在运行时知道Key的情况，需要通过注解来指定Key（支持复杂的Mapkey）；一种是在运行时才知道Key的情况，这时可以通过提供Set<Map.Entry>，然后组装成Map。
十二、 子组件
使用子组件可以把应用的对象图划分成子图，可以压缩应用的各个部分，或者在一个组件上使用多个范围限定。组件提供子组件有两种方式，一种是在组件中提供工厂方法来返回子组件或子组件的Builder；第二种是注入子组件的builder。
父子组件会共享相同的Module实例，父组件已经引用的Module类，子组件不需要再传入（包括工厂方法和Builder方法）。
十三、 Producer实现异步注入
Producers引入了新的注解@ProducerModule, @Produces, 和@ProductionComponent，分别对应@Module,@Provides, 和 @Component。我们把@ProducerModule注解的类视为producer modules，@Produces注解的方法视为producer methods，@ProductionComponent注解的接口视为producer graphs(类似于modules, provider methods, 和object graphs)。
和原始Dagger最关键的不同在于producer方法会返回ListenableFuture<T>，并且后面的producer会依赖于这个未封装的T，当future可用的时候，框架会计划执行后续的方法。
通过绑定@Production Executor来指定一个线程池，每一个Producer 的方法都会在这个线程池中被计划执行。