Dagger2在Android studio中的配置与简单使用

版权声明：本文为博主原创文章，请尊重个人劳动成果，转载注明地址：http://blog.csdn.net/evan_man 谢谢！

Dagger2环境搭建（android studio）：Module：app-->gradle配置（红色部分）
apply plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt'
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        // the latest version of the android-apt plugin
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4'
    }
}
android {
    compileSdkVersion 23
    buildToolsVersion "23.0.2"
    defaultConfig {
        applicationId "com.test.yqman.mydaggertest"
        minSdkVersion 17
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.2.0'

    compile 'javax.inject:javax.inject:1'
    compile 'javax.annotation:javax.annotation-api:1.2'
    compile 'com.google.dagger:dagger:2.0'
    apt 'com.google.dagger:dagger-compiler:2.0'
    provided 'org.glassfish:javax.annotation:10.0-b28'
}

使用：
Module
@Module
public class SecondModule {
    @Provides MyDataService providerMyDataService_sbdf(){ 
        return new MyDataService();
    }
}

@Module
public class MyModule {
    MainActivity mainActivity;
    public MyModule(MainActivity mainActivity){
        this.mainActivity = mainActivity;
    }
    @Provides MainActivity providerMainActivity_dafwe(){
        return mainActivity;
    }
    @Provides MyData providerMyData_xdsf(){
 
f46d
      return new MyData();
    }
    @Provides MyPresenter MyPresenter(MainActivity mainActivity,MyDataService myDataService){
        return new MyPresenter(mainActivity,myDataService);
    }
}
说明：

这里使用了两个注释@Module 、@Provides；
前者声明这是个Module类
后者声明这个方法可以提供什么对象；重要的是返回值，方法名不重要；当然为了让别人看的清楚这个方法返回什么类型对象；方法名可以采用provider+返回类名的格式；
简单概述：方法返回值指明提供的依赖类型(重点)；方法参数指明将要消耗的依赖对象
注意：
用Provider标注且返回值类型相同的方法只能出现一次！！！
方法中的参数必须在当前componet或者下一级component中的modules中能够找到一个提供相关对象的方法；
即：
MainActivity mainActivity来自于MyModule类中的@Provides MainActivity
MyDataService myDataService来自于SecondModule类中的@Provides MyDataService

Component

@Component(modules = {MyModule.class,SecondModule.class})
public interface MyComponent {
    void inject_vsd(MainActivity mainActivity);
    ClientClass inject_asd(ClientClass clientClass);
    MyPresenter providerMyPresent_dfafd();
}

@Component(dependencies = MyComponent.class)
public interface MySecondComponent {
    void inject_faewf(ClientClass clientClass);
}

说明：

这里使用了注释@Component(modules = {MyModule.class,SecondModule.class})声明这是个Component类
这个类可以声明两种方法：
指明消耗依赖类：
这类方法的格式是void xsajklf(MyClass myclass)或者 MyClass xsajklf(MyClass myclass)；
即返回的对象要么为void要么为消耗依赖类对象自己；
简单概述：方法返回值随意，方法参数指明消耗依赖类，方法名随意只不过建议使用inject命名

返回类实例的对象普通方法：
这类方法格式是ProviderClassA xdasdfas();
这类方法的使用场景主要是当另一个Component使用了dependencies关键字时，即@Component(dependencies = MyComponent.class)；该Componet给上一层的Component所能提供的依赖类对象；
简单概述：方法返回值指明提供的依赖类型，方法参数为空

注意：这里定义的Component是一个接口

消耗依赖类：
public class MainActivity extends Activity {
    @Inject MyPresenter myPresenter;
    @Inject MyData myDatabase1;
    @Inject MyData  myDatabase2;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.layout);
        if(myPresenter==null) Log.e("test", "presenter is null");
        MyComponent m = DaggerMyComponent.builder().myModule(new MyModule(this)).secondModule(new SecondModule()).build();
        m.inject_vsd(this);

        //证明注入成功
        Log.e("test", "---------dagger test-------------");
        if(myPresenter==null){  Log.e("test", "Dagger failed");  }
        else{   Log.e("test", "Dagger success");  }

        //默认情况注入对象是否单例
        Log.e("test", "---------single test-------------");
        if(myDatabase1==myDatabase2){   Log.e("test", "single model");   }
        else{  Log.e("test", "not single model");  }

        //普通方法返回消耗类
        Log.e("test", "---------simple method test-------------");
        MyPresenter pre = m.providerMyPresent_dfafd();
        if(pre == null){  Log.e("test", "can not return 0bject"); }
        else if(pre==myPresenter) Log.e("test", "single model");
        else Log.e("test", "not single model");
        new ClientClass(m);
    }
}
说明：

@Inject MyPresenter myPresenter;
@Inject MyData myDatabase1;
@Inject MyData myDatabase2;
上面三个域通过 MyComponent m = DaggerMyComponent.builder().myModule(new MyModule(this)).secondModule(new SecondModule()).build();; m.gblihui(this);
注射进来
MyPresenter pre = m.providerMyPresent_dfafd();; 只是一个普通的方法调用，底层实现也是调用Module中的相关方法；

注意：使用@Inject进行标注的域，必须是类变量不能是局部变量；而且变量类型必然是能够在Component或者其底层Component声明的Module中能够找到对应拥有该返回值能力的方法；

消耗依赖类调试信息：
presenter is null
---------dagger test-------------
Dagger success
---------single test-------------
not single model
---------simple method test-------------
not single model

reference：

http://stackoverflow.com/questions/29703480/dagger-2-and-android-studio-working-but-cant-see-generated-classes

文中源码请戳这里！！