Dagger2在Android开发中的应用

世界是普遍联系的，任何事物和个体都直接或间接相互依赖，在时空长河中共同发展。在面向对象的世界中，更是如此，类与类之间的依赖，关联关系，模块（亦或是分层架构中的层）之间的耦合关系，都是我们在软件开发实践中，时刻在处理着的联系。

在软件开发中，我们一直尝试弱化这种联系，以便让软件程序更健壮，更灵活，便于维护和升级。从面向过程遍程中提倡方法的分离（过程分离），到面向对象开发中的减少类依赖，层间低耦合，层内高类聚，无一不体现了这一点。正因为在面向对象的世界中，我们更容易处理类（对象），模块（或层）之间的关系，所以面向对象开发才成为了更受欢迎的开发方式。

为了处理代码中的依赖关系，依赖注入框架应运而生。在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 的方法都会在这个线程池中被计划执行。