Dagger2使用

先写两个对象类:

import javax.inject.Inject;

/**
 * Created by gaoyoujian on 2017/3/5.
 */

public class Wukong {

    @Inject
    JinGuBang mJinGuBang;

    @Inject
    public Wukong() {

    }


    public String useJingGubang() {
        return this.mJinGuBang.use();
    }
}

import javax.inject.Inject;

/**
 * Created by gaoyoujian on 2017/3/5.
 */

public class JinGuBang {

    @Inject
    public JinGuBang() {

    }

    public String use() {
        return "user Jing gu bang";
    }
}

然后写Module类:

import javax.inject.Singleton;

import dagger.Module;
import dagger.Provides;
import dagger.activity.JinGuBang;
import dagger.activity.Wukong;

/**
 * Created by gaoyoujian on 2017/3/5.
 */
@Module
public class XiYouModule {

    @Provides
    @Singleton
    Wukong provideWuKong() {
        return new Wukong();
    }

    @Provides
    @Singleton
    JinGuBang provideJinGuBang() {
        return new JinGuBang();
    }
}

然后写component:

import javax.inject.Singleton;

import dagger.Component;
import dagger.activity.Wukong;
import dagger.modules.XiYouModule;
import nickgao.com.meiyousample.MainActivity;

/**
 * Created by gaoyoujian on 2017/3/5.
 */
@Component(modules = {XiYouModule.class})
@Singleton
public interface XiYouComponent {

    void inject(Wukong wk);
    void inject(MainActivity a);
}

最后写activity:

public class MainActivity extends Activity {

    @Inject
    Wukong wukong;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        XiYouComponent xiYouComponent = DaggerXiYouComponent.builder().xiYouModule(new XiYouModule()).build();
        xiYouComponent.inject(this);
        xiYouComponent.inject(wukong);
        TextView textView = (TextView)findViewById(R.id.mytext);
        LogUtils.d("wukong="+wukong);
        if(wukong != null) {
            textView.setText(wukong.useJingGubang());

        }

    }


}

Dagger2的调用原则：
Dagger2是怎么选择依赖提供的呢，规则是这样的：

步骤1：查找Module中是否存在创建该类的方法。

步骤2：若存在创建类方法，查看该方法是否存在参数

步骤2.1：若存在参数，则按从步骤1开始依次初始化每个参数

步骤2.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束

步骤3：若不存在创建类方法，则查找Inject注解的构造函数，看构造函数是否存在参数

步骤3.1：若存在参数，则从步骤1开始依次初始化每个参数

步骤3.2：若不存在参数，则直接初始化该类实例，一次依赖注入到此结束

buildGradle:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    //dagger start
    apt 'com.google.dagger:dagger-compiler:2.0'
    //dagger end
    provided 'javax.annotation:jsr250-api:1.0'
    compile 'com.android.support:appcompat-v7:23.2.1'
    compile 'com.google.dagger:dagger:2.0'
    compile 'org.glassfish:javax.annotation:10.0-b28'
    compile 'com.android.support:support-v4:23.2.1'
    compile 'com.google.android.gms:play-services:8.4.0'
}

外层gradle:

 dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }