Dagger2

本文代码：
[DaggerExample]: https://github.com/zrfzhouruifeng163/DaggerExample

Dagger2是个啥？

一个依赖注入框架。（f....这是刷？哥们谷度吧）

Dagger2能解决啥问题？

进一步解耦
解耦？看下下面的强耦合性代码

public class C {

    public void methodC() {
    }
}
public class Example01Activity extends AppCompatActivity {

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

        c = new C();//随便new
        c.methodC();
    }
}

Example01Activity强烈依赖C，如果C的构造方法发生变化，onCreate内的代码得发生变化。
直白的说即是，Example01Activity里new了C，dagger2作用是解耦，实际就是不让Example01Activity里newC 又能给C的实例赋值。
上升一步高度，在这里强耦合的描述是，调用者调用被调用者，Example01Activity调用C ，Example01Activity是调用者，C是被调用者，在调用者内直接new被调用者。使用dagger2后，new的过程被转移到dagger2中了，dagger2再把对象注入到Example01Activity中。
dagger2处理后,代码如下：-----example01

public class C {
    
    @Inject
    public C() {
    }

    public void methodC() {
        Log.e("c","ccc");
    }
}
@Component
public interface Example01ActivityComponent {

    void inject(Example01Activity activity);
}
public class Example01Activity extends AppCompatActivity {

    @Inject
    C c;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example01);

        DaggerExample01ActivityComponent.create().inject(this);
        //这里的c没有new，就能直接使用了  啦啦啦
        c.methodC();
    }
}

冒然一看，上边代码貌似增加了代码量，其实真的是增加了代码量，但从逻辑上来看，的确没有在调用者中new了，勉强说是解耦了吧，虽然看起来没什么niao用。后续慢慢思考！

Dagger2的环境配置

作为一名安卓开发者，当前配置是

AndroidStudio 3.0.1
Android Plugin Version 2.3.1
Gradle version 3.3
----------------------------------------------
app下build.gradle
dependencies内增加：
compile 'com.google.dagger:dagger:2.14.1'
annotationProcessor 'com.google.dagger:dagger-compiler:2.14.1'

版本可以自己更改为最新，我就暂时用2.14.1了

常用的api清单

@Inject
@Component
@Module
@Qualifier
@Named
@Scope
@Singleton
@Lazy
@Provides
@IntoSet
@ElementsIntoSet
@IntoMap

大概有个印象，至于作用，后续慢慢说

有个前提

大家最好对注解和依赖注入有个了解，具体的可以自己谷度。

先从Inject和Component开始

@Inject   可以标注在三个地方
1.属性，表示我要往这个实例中注入对象，这是注入的目标。注意，该属性为非private的。
2.构造方法，表示我要用这个构造方法去生成对象，然后通过component注入到被Inject标注的属性上。注意，一个类中，只能有一个构造方法被标注。
3.方法上，可以理解为属性的set方式，也是注入的目标。

@Component   用该注解标注的接口，就是一个注入器，用于表示要往哪些类中注入，是一个入口。接口的命名方式：目标类+Component

@Inject标注在属性和构造方法上，实例代码如下 ----- example02

public class Book {

    //标注在构造方法上，表示我要用这个构造方法去生成对象
    @Inject
    public Book() {
    }

    public void read(){
        Log.e("book","read 水壶传");
    }
}


/**
 * 标注在接口上，表示这是一个注入器，针管儿，要打针啦
 * 要给PersonActivity打针，所以接口命名为PersonActivityComponent
 */
@Component
public interface PersonActivityComponent {

    //表示给哪个类注入，这里表示要给PersonActivity打针
    void inject(PersonActivity activity);
}


public class PersonActivity extends AppCompatActivity {

    //标注在属性上，表示我要往这个属性内注入对象，记得是非private的
    @Inject
    Book book;

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

        //在写这里之前记得先Build-make project下，在编译期内会生成一些代码
        //DaggerPersonActivityComponent就是在make后生成的，不make，是找不到这个类的，命名规则是：Dagger+component接口名
        //PersonActivity + Component
        //Dagger + PersonActivityComponent
        //清楚了没
        //言归正传，这里的作用是要给这个类注入内容
        DaggerPersonActivityComponent.create().inject(this);

        //直接调用方法就行了
        book.read();
    }
}

@Inject标注在方法上，实例代码如下 ------example03

public class Book {

    //标注在构造方法上，表示我要用这个构造方法去生成对象
    @Inject
    public Book() {
    }

    public void read(){
        Log.e("book","read 三国演义");
    }
}

/**
 * 标注在接口上，表示这是一个注入器，针管儿，要打针啦
 * 要给Person2Activity打针，所以接口命名为Person2ActivityComponent
 */
@Component
public interface Person2ActivityComponent {

    //表示给哪个类注入，这里表示要给PersonActivity打针
    void inject(Person2Activity activity);
}

public class Person2Activity extends AppCompatActivity {


    private Book book;

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

        //在写这里之前记得先Build-make project下，在编译期内会生成一些代码
        //DaggerPerson2ActivityComponent就是在make后生成的，不make，是找不到这个类的，命名规则是：Dagger+component接口名
        //Person2Activity + Component
        //Dagger + Person2ActivityComponent
        //清楚了没
        //言归正传，这里的作用是要给这个类注入内容
        DaggerPerson2ActivityComponent.create().inject(this);

        //直接调用方法就行了
        book.read();
    }

    //标注在方法上，类似set   表示我要往这个属性内注入对象，记得这里的属性可以是private的
    @Inject
    public void setBook(Book book){
        this.book = book;
        //这里就获取到了this，可以直接使用this了
        this.load();
    }

    //对象的方法
    public void load(){
        Log.e("load","hello world");
    }
}

@Inject在属性和方法上有啥异同？

1.二者都是给属性注入对象
2.标注在方法上，在方法内可以使用this关键字了，因为肯定是在调用完类的构造方法后才可以使用标注的方法，这时候当然有this了

可以想象下，标注在方法和属性上，可以同时使用吗？
of course --yes ------example04 如下：

public class Apple {

    //标注在构造方法上，表示我要用这个构造方法去生成对象
    @Inject
    public Apple() {
    }

    public void eat(){
        Log.e("apple","eat bugs");
    }
}

public class Book {

    //标注在构造方法上，表示我要用这个构造方法去生成对象
    @Inject
    public Book() {
    }

    public void read(){
        Log.e("book","read 三国演义");
    }
}


@Component
public interface Person3ActivityComponent {
    void inject(Person3Activity activity);
}

public class Person3Activity extends AppCompatActivity {

    @Inject
    Book book;

    private Apple apple;

    @Inject
    Apple apple2;

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

        DaggerPerson3ActivityComponent.create().inject(this);

        book.read();
        apple.eat();
        apple2.eat();
    }

    @Inject
    public void setApple(Apple apple) {
        this.apple = apple;
    }
}

Please think another question ---component可以同时给多个类注入吗？
of course ----yes ------example05

public class Book {

    //标注在构造方法上，表示我要用这个构造方法去生成对象
    @Inject
    public Book() {
    }

    public void read(){
        Log.e("book","read 三国演义");
    }
}

@Component
public interface Person4ActivityComponent {

    //给Person4Activity打针
    void inject(Person4Activity activity);

    //给Person5Activity打针
    void inject(Person5Activity activity);
}

public class Person4Activity extends AppCompatActivity {

    @Inject
    Book book;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_person4);

        DaggerPerson4ActivityComponent.create().inject(this);
        Log.e("tag","Person4Activity");
        book.read();

    }
}

public class Person5Activity extends AppCompatActivity {

    @Inject
    Book book;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_person5);

        DaggerPerson4ActivityComponent.create().inject(this);
        Log.e("tag","Person5Activity");
        book.read();

        Intent intent = new Intent(this,Person4Activity.class);
        startActivity(intent);
    }
}

再说@Module和@Provides

@Module:向 注入器 提供对象实例的类，想下@Inject作用在构造方法上，其作用就是向注入器提供构造对象的方法。@Module有相同的作用，只是换了一种方式，这是对@Inject的补充。
@Provides：与@Module配合使用的，标注在Module内的具体的提供对象的方法上。

描述个场景：

我们使用了两个类Apple和Book，但是Apple和Book分别来源于第三方的sdk，这时候 我们就没有办法在Apple和Book的构造上进行标注@Inject了，这时候又想使用dagger2 ,咋办呢，@Module来了。

看个实例代码----example06

//模拟来源于第三方sdk的类，不能修改其源码
public class Book {

    public Book() {
    }

    public void read(){
        Log.e("book","read 三国演义");
    }
}

//模拟来源于第三方sdk的类，不能修改其源码
public class Apple {

    public Apple() {
    }

    public void eat(){
        Log.e("apple","eat bugs");
    }
}

/**
 * 表示向构造器提供对象的类
 */
@Module
public class MyModule {

    //标注在方法上，表示具体的提供对象的方法,命名方式一般为:provide+具体要提供的类名
    @Provides
    Apple provideApple(){
        return new Apple();//这里需要new了
    }

    //标注在方法上，表示具体的提供对象的方法
    @Provides
    Book provideBook(){
        return new Book();//这里需要new了
    }
}

//这里的modules=Mydule.class   表示我这个注入器，从MyModule中寻找提供对象实例的方法
@Component(modules = MyModule.class)
public interface ModuleActivityComponent {

    void inject(ModuleActivity activity);
}

public class ModuleActivity extends AppCompatActivity {

    @Inject
    Apple apple;

    @Inject
    Book book;

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

        DaggerModuleActivityComponent.create().inject(this);

        apple.eat();
        book.read();
    }
}

描述下流程：

1.ModuleActivityComponent为入口，想要注入到目标类ModuleActivity中
2.发现ModuleActivity中有两个属性需要注入@Inject Apple  和@Inject Book
3.从哪儿找提供对象实例的的来源呢？发现component上有个modules=MyModule.class
4.去往Mymodule
5.找到了两个Provides方法，正好是provideApple 和 provideBook,ok，就这俩了
6.调用MyModule内的方法，然后给ModuleActivity中的俩属性注入实例。

OK，question,一个component可以多个module吗？
of course ---yes 实例代码如下 ------example07

//模拟来源于第三方sdk的类，不能修改其源码
public class Apple {

    public Apple() {
    }

    public void eat(){
        Log.e("apple","eat bugs");
    }
}

//模拟来源于第三方sdk的类，不能修改其源码
public class Book {

    public Book() {
    }

    public void read(){
        Log.e("book","read 三国演义");
    }
}

/**
 * 表示向构造器提供Apple对象的类
 */
@Module
public class AppleModule {

    //标注在方法上，表示具体的提供对象的方法
    @Provides
    Apple provideApple(){
        return new Apple();//这里需要new了
    }

}

/**
 * 表示向构造器提供Book对象的类
 */
@Module
public class BookModule {


    //标注在方法上，表示具体的提供对象的方法
    @Provides
    Book provideBook(){
        return new Book();//这里需要new了
    }
}

//多个module用这种方式
@Component(modules = {AppleModule.class,BookModule.class})
public interface Module01ActivityComponent {

    void inject(Module01Activity activity);
}

public class Module01Activity extends AppCompatActivity {

    @Inject
    Apple apple;

    @Inject
    Book book;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_module01);

        DaggerModule01ActivityComponent.create().inject(this);

        apple.eat();
        book.read();
    }
}

OK,question again，对接口声明的字段标注@Inject和对接口实现类的构造标注@Inject,能实现注入吗？看下面的代码----example08

public interface IAnimal {
    void bark();
}
public class Dog implements IAnimal {

    //这里对接口实现类的构造进行标注
    @Inject
    public Dog() {
    }
    public void bark(){
        Log.e("dog bark","汪汪汪");
    }
}
public class AnimalActivity extends AppCompatActivity {

    //这里对接口声明的字段标注
    @Inject
    IAnimal animal;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_animal);

        DaggerAnimalActivityComponent.create().inject(this);

        animal.bark();
    }
}
@Component
public interface AnimalActivityComponent {

    void inject(AnimalActivity activity);
}

The answer is NO. 会报错的，注入不了。
但是，接口的引用指向子类的对象，这是一种很常用的用法，该如何实现呢，---module啦,一切尽在code中。

public interface IAnimal {
    void bark();
}

public class Dog implements IAnimal {

    //这里不需要标注@Inject
    public Dog() {
    }
    public void bark(){
        Log.e("dog bark","汪汪汪");
    }
}

public class Cow implements IAnimal {

    //注意这里需要标注@Inject
    @Inject
    public Cow() {
    }

    @Override
    public void bark() {
        Log.e("cow bark","哞哞哞");
    }
}

@Module
public class AnimalModule {

    //方式一： 直接在提供的方法内new一个就行了   这时Dog的构造上不需要@Inject
//    @Provides
//    IAnimal provideAnimal(){
//        return new Dog();//new new new
//    }

    //方式二：在接口实现类Cow的构造上@Inject  ，在这里直接当参数传进来，即可
    //这里在参数中有Cow，会去寻找是否有Cow实例的方法，发现Cow的构造上有@Inject   使用。
    @Provides
    IAnimal provideAnimal(Cow cow){
        return cow;
    }
}

@Component(modules = AnimalModule.class)
public interface Animal2ActivityComponent {

    void inject(Animal2Activity activity);
}

public class Animal2Activity extends AppCompatActivity {

    @Inject
    IAnimal animal;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_animal2);

        DaggerAnimal2ActivityComponent.create().inject(this);

        animal.bark();

    }
}

在上面的AnimalModule中列出了方式一和方式二，两个provide方法，大家应该注意到了我把方式一给注释了，why？因为放开后，运行会报错，这当然是废话，为什么报错呢？我的理解是，一方面provide的方法不要重名，尽管符合重载原则，另一方面，因为在dagger2中，component会寻找对象构造来源，这个来源通常是唯一的，上面的方式一二，两个方法都是构造IAnimal的，可以说component找到了两个来源，然后就不知道选择哪个了，就报错了。
怎么解决呢？

引出@Named和@Qualifier

作用：
1.标记在provide方法上，用于区分来源。
2.标记在字段上，表示使用哪个来源。

先说@Named,代码如下，----example10

public class Oriange implements IFruit{
    @Inject
    public Oriange() {
    }

    @Override
    public void name() {
        Log.e("name","oriange");
    }
}

public class Banana implements IFruit{
    @Override
    public void name() {
        Log.e("name","banananana");
    }
}

public class Pear implements IFruit {

    public String name = "China";
    @Inject  //注意构造方法上不能打@Named
    public Pear() {
        name = "China";
    }


    public Pear(String name) {
        this.name = name;
    }

    @Override
    public void name() {
        Log.e("name",name);
    }
}

@Module
public class FruitModule {

    @Provides
    @Named("banana")//打标记，标记来源，用于区分
    IFruit provideBanana(){
        return new Banana();
    }

    @Provides
    @Named("oriange")//打标记，标记来源，用于区分
    IFruit provideOriange(Oriange oriange){
        return oriange;
    }

    @Provides
    @Named("pear2")
    Pear providePear(){
        Log.e("from","module pear");
        return new Pear("America");
    }
}

@Component(modules = FruitModule.class)
public interface FruitActivityComponent {
    void inject(FruitActivity activity);
}

public class FruitActivity extends AppCompatActivity {


    @Inject
    @Named("banana")   //标记是用哪个来源进行注入
    IFruit banana;

    @Inject
    @Named("oriange")   //标记是用哪个来源进行注入
    IFruit oriange;

    @Inject   //对应的是Pear中的构造方法上的@Inject   注意构造方法上不能打@Named
    Pear pear1;

    @Inject
    @Named("pear2")   //对应的是FruitModule中的方法
    Pear pear2;


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

        DaggerFruitActivityComponent.create().inject(this);

        banana.name();
        oriange.name();

        pear1.name();
        pear2.name();
    }
}

再说@Qualifier ,也是标记来源，@Named是通过字符串来唯一确定，而@Qualifier是通过定义注解来区分，具体做法是，定义一个注解，然后在该注解上标注@Qualifier，然后将该注解标注在构造器来源和@Inject标注的字段上。不同的来源定义不同的注解。
二者的区别是，Named需要手动去写这个唯一标示，Qualifier则是直接定义，省去了写字符串的过程，更加简洁。
代码如下----example11

public class Bird {

    public String name;

    public Bird(String name) {
        this.name = name;
    }

    public void name(){
        Log.e("name=",name);
    }
}

/**
 * 定义一个注解，并标注@Qualifier,这里定义的是标注parrot来源的注解
 */
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface ParrotQualifier {
}


/**
 * 定义一个注解，并标注@Qualifier,这里定义的是标注sparrow来源的注解
 */
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface SparrowQualifier {
}

@Module
public class BirdModule {

    //不同的来源标注不同的Qualifier，用于区分

    @Provides
    @SparrowQualifier    //标注sparrow注解，表示这是sparrow对象的来源
    Bird provideBird1(){
        return new Bird("sparrow");
    }

    @Provides
    @ParrotQualifier  //标注parot注解，表示这是parrot对象的来源
    Bird provideBird2(){
        return new Bird("parrot");
    }
}

@Component(modules = BirdModule.class)
public interface BirdActivityComponent {

    void inject(BirdActivity activity);
}


public class BirdActivity extends AppCompatActivity {

    @Inject
    @SparrowQualifier  //标注sparrow注解，表示要使用被SparrowQualifier标注的来源，注入到该字段
    Bird sparrow;

    @Inject
    @ParrotQualifier  //标注parrot注解，表示要使用被ParrotQualifier标注的来源，注入到该字段
    Bird parrot;

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

        DaggerBirdActivityComponent.create().inject(this);

        sparrow.name();
        parrot.name();
    }
}

@Inject @Module @Component的工作流程

dagger2.png

文字叙述：

1.component为入口
2.inject确定被注入的目标类（如XXXActivity）
3.在目标类中确认有哪些被@Inject标注的字段或方法需要被注入实例。
4.回到component，查看是否有module
5.有module
    5.1查看module中是否有提供依赖的provide方法
    5.2有提供依赖的provide方法
        5.2.1 方法上没有参数，则直接利用这个方法创建对象，注入到目标字段
        5.2.2 方法上有参数，那么此时该参数也是需要被注入的字段（等效于被@Inject标注了），那么此时就需要从步骤1的component开始，寻找能为此参数提供依赖的标注，一直找到为止，然后利用该参数所在的方法，创建对象，注入到目标字段中。
    5.3没有提供依赖的provide方法，则从6.1开始
6.无module
    6.1在各个类中寻找被@Inject标注的构造方法
    6.2没有找到能提供依赖的被@Inject标注的构造方法，则报错，证明没有可以提供依赖的来源。
    6.3找到了提供依赖的@Inject构造方法
    6.4查看该构造方法上是否有参数
    6.5构造上没有参数，则直接利用此构造创建对象，然后注入到目标字段上
    6.6构造上有参数，那么此时该参数也是需要被注入的字段（等效于被@Inject标注了），那么此时就需要从步骤1的component开始，寻找能为此参数提供依赖的标注，一直找到为止，然后继续进行利用参数所在的构造函数进行创建对象，然后注入到目标字段上。

@Scope

scope有范围、余地的意思，被scope标注的类，在一定范围内能达到单例的效果，即只创建一次，多次使用都是同一个对象。
@Scope的源码如下：

@Target(ANNOTATION_TYPE)
@Retention(RUNTIME)
@Documented
public @interface Scope {}

ANNOTATION_TYPE 表示Scope只能标注在注解上。
需要注意：

1.@Scope是用于自定义注解的，只能标注在注解上。
2.被@Scope自定义出来的注解，是可以标注在类、方法和Component上的

Scope使用方式一：

Scope标注在类以及Component上
步骤：

1.使用@Scope自定义一个注解@MyScope
2.将@MyScope标注在类上
3.将@MyScope标注在Component上
4.使用Component进行注入实现即可

实例代码如下 ---example12

/**
 * Scope只能标注在注解上
 * 这里自定义一个Scope
 */
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface MyScope {
}

/**
 * 注意是这个类上标注了自定义的一个主机@MyScope
 */
@MyScope
public class Laptop {
    //构造上标注了@Inject
    @Inject
    public Laptop() {
        Log.e("laptop","laptop");
    }
}

/**
 * 这里没有标注自定义的@MyScope
 */
public class Mobile {
    //构造上标注了@Inject
    @Inject
    public Mobile() {
        Log.e("mobile","mobile");
    }
}

@MyScope   //注意要在这里标注@MyScope，因为目标类ScopeActivity中，有个被@Inject标注的字段，而这个字段所属的类被@MyScope标注了，所以这个Component必须标注
@Component
public interface ScopeActivityComponent {
    void inject(ScopeActivity activity);
}

public class ScopeActivity extends AppCompatActivity {

    @Inject
    Laptop laptop01;
    @Inject
    Laptop laptop02;

    @Inject
    Mobile mobile01;
    @Inject
    Mobile mobile02;

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

        DaggerScopeActivityComponent.create().inject(this);

        log(laptop01.hashCode()+"");
        log(laptop02.hashCode()+"");
        log(mobile01.hashCode()+"");
        log(mobile02.hashCode()+"");
    }

    private void log(String msg){
        Log.e("msg",msg);
    }
}

结果如下：

com.zhourf.dagger.daggerexample E/laptop: laptop
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/msg: 186183467
com.zhourf.dagger.daggerexample E/msg: 186183467
com.zhourf.dagger.daggerexample E/msg: 146743176
com.zhourf.dagger.daggerexample E/msg: 2886945

可以看出：
被MyScope标注的Laptop类，构造方法只执行了一次，而laptop01和laptop02的地址值是同一个
没有被MyScope标注的Mobile类，构造方法执行了两次，mobile01和mobile02的地址值不同。

此外，刚才在上面描述时，有一句话，“在一定范围内能达到单例的效果”，那么这个范围是什么呢？
先看代码：---example12

/**
 * Scope只能标注在注解上
 * 这里自定义一个Scope
 */
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface MyScope {
}

/**
 * 注意是这个类上标注了自定义的一个主机@MyScope
 */
@MyScope
public class Laptop {
    //构造上标注了@Inject
    @Inject
    public Laptop() {
        Log.e("laptop","laptop");
    }
}

/**
 * 这里没有标注自定义的@MyScope
 */
public class Mobile {
    //构造上标注了@Inject
    @Inject
    public Mobile() {
        Log.e("mobile","mobile");
    }
}

@MyScope   //注意要在这里标注@MyScope，因为目标类ScopeActivity中，有个被@Inject标注的字段，而这个字段所属的类被@MyScope标注了，所以这个Component必须标注
@Component
public interface ScopeActivityComponent {
    void inject(ScopeActivity activity);
}

public class ScopeActivity extends AppCompatActivity {

    @Inject
    Laptop laptop01;
    @Inject
    Laptop laptop02;

    @Inject
    Mobile mobile01;

    @Inject
    Mobile mobile02;

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

        DaggerScopeActivityComponent.create().inject(this);

        log(laptop01.hashCode()+"");
        log(laptop02.hashCode()+"");
        log(mobile01.hashCode()+"");
        log(mobile02.hashCode()+"");

        startActivity(new Intent(this,Scope2Activity.class));
    }

    private void log(String msg){
        Log.e("msg",msg);
    }
}

@MyScope
@Component
public interface Scope2ActivityComponent {

    void inject(Scope2Activity activity);

    void inject(Scope3Activity activity);
}

public class Scope2Activity extends AppCompatActivity {

    @Inject
    Laptop laptop03;
    @Inject
    Laptop laptop04;

    @Inject
    Mobile mobile03;

    @Inject
    Mobile mobile04;

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

        DaggerScope2ActivityComponent.create().inject(this);

        log(laptop03.hashCode()+"");
        log(laptop04.hashCode()+"");
        log(mobile03.hashCode()+"");
        log(mobile04.hashCode()+"");
    }

    private void log(String msg){
        Log.e("msg",msg);
    }
}

public class Scope3Activity extends AppCompatActivity {

    @Inject
    Laptop laptop05;
    @Inject
    Laptop laptop06;

    @Inject
    Mobile mobile05;

    @Inject
    Mobile mobile06;

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

        DaggerScope2ActivityComponent.create().inject(this);

        log(laptop05.hashCode()+"");
        log(laptop06.hashCode()+"");
        log(mobile05.hashCode()+"");
        log(mobile06.hashCode()+"");
    }

    private void log(String msg){
        Log.e("msg",msg);
    }
}

结果如下：

com.zhourf.dagger.daggerexample E/laptop: laptop
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/msg: 186183467
com.zhourf.dagger.daggerexample E/msg: 186183467
com.zhourf.dagger.daggerexample E/msg: 146743176
com.zhourf.dagger.daggerexample E/msg: 2886945

com.zhourf.dagger.daggerexample E/laptop: laptop
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/msg: 106306550
com.zhourf.dagger.daggerexample E/msg: 106306550
com.zhourf.dagger.daggerexample E/msg: 91425783
com.zhourf.dagger.daggerexample E/msg: 128682596

com.zhourf.dagger.daggerexample E/laptop: laptop
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/msg: 76555776
com.zhourf.dagger.daggerexample E/msg: 76555776
com.zhourf.dagger.daggerexample E/msg: 16014905
com.zhourf.dagger.daggerexample E/msg: 98020478

在上面的的代码中，使用了ScopeActivityComponent 注入ScopeActivity，使用Scope2ActivityComponent,分别注入Scope2Activity和Scope3Activity，每个Activity中分别声明了Laptop和Mobile的两个字段。启动ScopeActivity后，会自动跳转到Scope2Activity，Scope2Activity自动跳转Scope3Activity
可以看出结果：
在ScopeActivity中：

com.zhourf.dagger.daggerexample E/laptop: laptop
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/msg: 186183467
com.zhourf.dagger.daggerexample E/msg: 186183467
com.zhourf.dagger.daggerexample E/msg: 146743176
com.zhourf.dagger.daggerexample E/msg: 2886945

Laptop构造执行了一次，两个laptop的地址相同
Mobile构造执行了两次，两个mobile的地址不同

在跳转到Scope2Activity后：

com.zhourf.dagger.daggerexample E/laptop: laptop
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/msg: 106306550
com.zhourf.dagger.daggerexample E/msg: 106306550
com.zhourf.dagger.daggerexample E/msg: 91425783
com.zhourf.dagger.daggerexample E/msg: 128682596

Laptop的构造重新执行了，且一次，两个laptop地址相同，又与ScopeActivity中的laptop地址不同
Mobile的构造重新执行了，两次，两个mobile地址不同，与ScopeActivity中的mobile地址不同。

在Scope3Activity中：

com.zhourf.dagger.daggerexample E/laptop: laptop
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/mobile: mobile
com.zhourf.dagger.daggerexample E/msg: 76555776
com.zhourf.dagger.daggerexample E/msg: 76555776
com.zhourf.dagger.daggerexample E/msg: 16014905
com.zhourf.dagger.daggerexample E/msg: 98020478

Laptop的构造重新执行了，且一次，两个laptop地址相同，又与ScopeActivity和Scope2Activity中的laptop地址不同
Mobile的构造重新执行了，两次，两个mobile地址不同，与ScopeActivity和Scope2Activity中的mobile地址不同。

结论：

1.@Scope是用于自定义注解的
2.@MyScope 必须同时标注在类上和对应的Component上。
3.被@MyScope标注后，在Component注入的同一个目标范围内，可以达到单例的表现效果，如果Component注入了多个目标，那么各自目标内，可以单例。但是多个目标不能共享单例。

Scope使用方式二

将自定义Scope标注在方法和Component上
步骤

1.使用@Scope自定义注解@TestScope
2.将@TestScope标注在module的provide方法上
3.将@TestScope标注在component上
4.使用Component进行注入实现。

示例代码如下，---example13

public class Green {

    public Green() {
        Log.e("green construct","green");
    }
}

@Module
public class TestModule {

    @TestScope  //标注在provide方法上   只会取一次
    @Provides
    Green provideGreen(){
        Log.e("green provide","green");
        return new Green();
    }

}

@TestScope
@Component(modules = TestModule.class)
public interface ColorActivityComponent {

    void inject(ColorActivity activity);
}

public class ColorActivity extends AppCompatActivity {

    @Inject
    Green green1;
    @Inject
    Green green2;


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

        DaggerColorActivityComponent.create().inject(this);

        log(green1.hashCode());
        log(green2.hashCode());
    }

    private void log(int msg){
        Log.e("color",msg+"");
    }
}

运行结果：

com.zhourf.dagger.daggerexample E/green provide: green
com.zhourf.dagger.daggerexample E/green construct: green
com.zhourf.dagger.daggerexample E/color: 186183467
com.zhourf.dagger.daggerexample E/color: 186183467

Scope使用方式三

自定义注解，标注在类、component和provide上，混合使用。
示例代码，-----example13

//自定义一个Scope注解
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface TestScope {
}

public class Green {

    public Green() {
        Log.e("green construct","green");
    }
}

public class Red {

    public Red() {
        Log.e("red construct","red");
    }
}

public interface IBlue {
}
@TestScope
public class Blue implements IBlue {

    @Inject
    public Blue() {
        Log.e("blue construct","blue");
    }
}

public interface IOrange {
}
@TestScope
public class Orange implements IOrange {

    @Inject
    public Orange() {
        Log.e("Orange construct","Orange");
    }
}

@Module
public class TestModule {

    @TestScope
    @Provides
    Green provideGreen(){
        Log.e("green provide","green");
        return new Green();
    }

    @Provides
    Red provideRed(){
        Log.e("red provide","red");
        return new Red();
    }

    @Provides
    IBlue provideBlue(Blue blue){
        Log.e("blue provide","blue");
        return blue;
    }

    @TestScope
    @Provides
    IOrange provideOrange(Orange orange)
    {Log.e("orange provide","orange");
        return orange;
    }
}

@TestScope
@Component(modules = TestModule.class)
public interface ColorActivityComponent {

    void inject(ColorActivity activity);
}

public class ColorActivity extends AppCompatActivity {

    @Inject
    Green green1;
    @Inject
    Green green2;

    @Inject
    Red red1;
    @Inject
    Red red2;

    @Inject
    IBlue blue1;
    @Inject
    IBlue blue2;

    @Inject
    IOrange orange1;
    @Inject
    IOrange orange2;

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

        DaggerColorActivityComponent.create().inject(this);


        log("green1",green1.hashCode());
        log("green2",green2.hashCode());
        log("red1",red1.hashCode());
        log("red2",red2.hashCode());
        log("blue1",blue1.hashCode());
        log("blue2",blue2.hashCode());
        log("orange1",orange1.hashCode());
        log("orange2",orange2.hashCode());
    }

    private void log(String tag,int msg){
        Log.e(tag,msg+"");
    }
}

结果如下：

com.zhourf.dagger.daggerexample E/green provide: green
com.zhourf.dagger.daggerexample E/green construct: green
com.zhourf.dagger.daggerexample E/red provide: red
com.zhourf.dagger.daggerexample E/red construct: red
com.zhourf.dagger.daggerexample E/red provide: red
com.zhourf.dagger.daggerexample E/red construct: red
com.zhourf.dagger.daggerexample E/blue construct: blue
com.zhourf.dagger.daggerexample E/blue provide: blue
com.zhourf.dagger.daggerexample E/blue provide: blue
com.zhourf.dagger.daggerexample E/Orange construct: Orange
com.zhourf.dagger.daggerexample E/orange provide: orange
com.zhourf.dagger.daggerexample E/green1: 186183467
com.zhourf.dagger.daggerexample E/green2: 186183467
com.zhourf.dagger.daggerexample E/red1: 146743176
com.zhourf.dagger.daggerexample E/red2: 2886945
com.zhourf.dagger.daggerexample E/blue1: 122148166
com.zhourf.dagger.daggerexample E/blue2: 122148166
com.zhourf.dagger.daggerexample E/orange1: 112546567
com.zhourf.dagger.daggerexample E/orange2: 112546567

结果分析

Green ,@TestScope标注在component和provide上，Green及构造上什么都不标注
com.zhourf.dagger.daggerexample E/green provide: green
com.zhourf.dagger.daggerexample E/green construct: green
com.zhourf.dagger.daggerexample E/green1: 186183467
com.zhourf.dagger.daggerexample E/green2: 186183467
调用了一次provide和一次构造，两个green的地址相同

Red,@TestScope只标注在component上，Red类及构造及provide上什么都不标注
com.zhourf.dagger.daggerexample E/red provide: red
com.zhourf.dagger.daggerexample E/red construct: red
com.zhourf.dagger.daggerexample E/red provide: red
com.zhourf.dagger.daggerexample E/red construct: red
com.zhourf.dagger.daggerexample E/red1: 146743176
com.zhourf.dagger.daggerexample E/red2: 2886945
调用了两次provide和两次构造，两个red对象地址不同，所以只标注在component上，没什么用

Blue,@TestScope标注在component及Blue类上，Blue构造标注@Inject，provide方法上什么都不标注
com.zhourf.dagger.daggerexample E/blue construct: blue
com.zhourf.dagger.daggerexample E/blue provide: blue
com.zhourf.dagger.daggerexample E/blue provide: blue
com.zhourf.dagger.daggerexample E/blue1: 122148166
com.zhourf.dagger.daggerexample E/blue2: 122148166
调用了两次provide和一次构造，两个blue对象地址相同，因为provide没有标注@TestScope，所以调用了两次，而类上标注了@TestScope，所以构造只执行了一次。

Orange，@TestScope同时标注在Component、provide和Orange类上
com.zhourf.dagger.daggerexample E/Orange construct: Orange
com.zhourf.dagger.daggerexample E/orange provide: orange
com.zhourf.dagger.daggerexample E/orange1: 112546567
com.zhourf.dagger.daggerexample E/orange2: 112546567
调用了一次构造和一次provide，两个oriange对象地址相同。provide优先级比类高，所以取到provide就一次了。

其实也就是说：
1.自定义Scope，单独标注类或provide上，都有“单例效果”。
2.自定义Scope，同时标注在类和provide上，provide优先级高。
3.component上必须标注Scope，才有效果。

然后再说@Singleton

@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

这其实就是@Scope自定义注解的一种实现，和我们上面定义的@TestScope是一样的。

Lazy

一看这个词，就能想到懒加载，其含义也是类似的，在使用时再去加载。
1.在@Inject Lazy 时，不会去调用依赖来源创建对象
2.在@Inject T t时，就直接取调用来源创建对象了
3.如果有两个@Inject Lazy 那么两个Lazy之间完全独立，互不影响。
4.Lazy的get方法是获取T对象，当一个Lazy第一次get时，调用依赖来源创建对象，然后缓存，当第二次get时，获取的是缓存的对象，而不会再去调用依赖来源创建对象
5.两个Lazy不会共享缓存
示例代码 ----example14

public class HuaWei {

    @Inject
    public HuaWei() {
        Log.e("huawei","huawei");
    }
}
@Component
public interface HuaweiActivityComponent {
    void inject(HuaweiActivity activity);
}

public class HuaweiActivity extends AppCompatActivity {

    @Inject
    HuaWei hw1;//这时就直接调用依赖来源去创建对象了

    @Inject
    Lazy lhw1;//此时没有调用依赖来源去创建对象

    @Inject
    Lazy lhw2;//此时没有调用依赖来源去创建对象

    @Inject
    HuaWei hw2;//这时就直接调用依赖来源去创建对象了

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

        DaggerHuaweiActivityComponent.create().inject(this);

        Log.e("start","--------------------");
        log("hw1",hw1.hashCode());
        log("lhw1",lhw1.get().hashCode());//当第一次调用get时，才调用依赖来源去创建对象，然后缓存起来
        log("lhw1",lhw1.get().hashCode());//当第二次调用get时，使用第一次的缓存
        log("hw2",hw2.hashCode());
        log("lhw2",lhw2.get().hashCode());//当第一次调用get时，才调用依赖来源去创建对象，然后缓存起来。需要注意的是两个Lazy是完全独立的，不会共享缓存
        log("lhw2",lhw2.get().hashCode());//当第二次调用get时，使用第一次的缓存
    }

    private void log(String tag,int msg){
        Log.e(tag,msg+"");
    }
}

运行结果：

com.zhourf.dagger.daggerexample E/huawei: huawei  //@Inject时就调用了构造
com.zhourf.dagger.daggerexample E/huawei: huawei //@Inject时就调用了构造
com.zhourf.dagger.daggerexample E/start: --------------------
com.zhourf.dagger.daggerexample E/hw1: 186183467
com.zhourf.dagger.daggerexample E/huawei: huawei   //get时才去调用构造函数
com.zhourf.dagger.daggerexample E/lhw1: 146743176
com.zhourf.dagger.daggerexample E/lhw1: 146743176//第二次get就不调用构造了
com.zhourf.dagger.daggerexample E/hw2: 2886945
com.zhourf.dagger.daggerexample E/huawei: huawei  //第二个Lazy的第一次get时，调用构造
com.zhourf.dagger.daggerexample E/lhw2: 122148166
com.zhourf.dagger.daggerexample E/lhw2: 122148166 //第二次get不调用构造

Provider

Provider ,字面意思，提供者。
1.使用@Inject Provider 时，不会立即调用构造函数。
2.当使用Provider.get()时才去调用构造函数，同时不会缓存对象
3.当使用第二次Provider.get()，会立即调用构造函数。
4.也就是说每次调用Provider.get()时都会调用构造函数，重新创建对象，就像一个T的工厂一样，源源不断生成，且每次都是new的。
示例代码 example15

public class Table {

    @Inject
    public Table() {
        Log.e("table construct","table");
    }
}

@Component
public interface TableActivityComponent {
    void inject(TableActivity activity);
}

public class TableActivity extends AppCompatActivity {

    @Inject
    Provider provider1;//此时没有调用构造函数
    @Inject
    Provider provider2;//此时没有调用构造函数

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

        DaggerTableActivityComponent.create().inject(this);
        Log.e("tag","----------");

        log("provider1 get1",provider1.get().hashCode());//此时调用构造函数，不缓存
        log("provider1 get2",provider1.get().hashCode());//此时依然调用构造函数，重新创建
        log("provider2 get1",provider2.get().hashCode());//此时调用构造函数，不缓存
        log("provider2 get2",provider2.get().hashCode());//此时依然调用构造函数，重新创建
    }
    private void log(String tag,int msg){
        Log.e(tag,msg+"");
    }

}
运行结果：
com.zhourf.dagger.daggerexample E/tag: ----------
com.zhourf.dagger.daggerexample E/table construct: table
com.zhourf.dagger.daggerexample E/provider1 get1: 186183467
com.zhourf.dagger.daggerexample E/table construct: table
com.zhourf.dagger.daggerexample E/provider1 get2: 146743176
com.zhourf.dagger.daggerexample E/table construct: table
com.zhourf.dagger.daggerexample E/provider2 get1: 2886945
com.zhourf.dagger.daggerexample E/table construct: table
com.zhourf.dagger.daggerexample E/provider2 get2: 122148166
Set
@IntoSet 将一个值add入set
 1.标注在provide方法上，可以将provide方法的返回值add到Set中。
 2.使用@Inject Set set 字段 ，可以从provide方法取得依赖。
 3.相同返回值的多个provide方法，最终都会将值存到同一个Set内。
 4.都使用@IntoSet标注，且返回值不同的provide方法，会将值存到各自的Set Set中。
 5.一个component，inject多个目标类时，共享这个Set。
 @ElementsIntoSet 将多个值add入set
 1.与@IntoSet功能类似，也是往Set中add值。
 2.@IntoSet是一个一个值的add，@ElementsIntoSet则是一次可以add多个。
 3.也是标注在provide方法上，但是其返回值是Set类型。
 注意：
 对于二者，同一个component内，不论module多少，Set共享，就是同一个T的，用的都是同一个Set。
 不同的component之间，Set独立不共享。
 实例代码 ----example16
public class Desk {
    public String name;
    public Desk(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Desk{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Chair {
    public String name;
    @Override
    public String toString() {
        return "Chair{" +
                "name='" + name + '\'' +
                '}';
    }
    public Chair(String name) {
        this.name = name;
    }
}

@Module
public class DeskModule {

    @Provides
    @IntoSet   //这里的Desk会被放到Set中    对应的返回值其实是Set
    Desk provideDesk(){
        return new Desk("   DeskModule   intoset dest1");
    }

    @Provides
    @IntoSet  //这里的Desk会被放到Set中，且是同一个set，就算跨Activity了也是同一个     对应的返回值其实是Set
    Desk provideDesk3(){
        return new Desk("DeskModule   intoset dest2");
    }

    @Provides
    @IntoSet  //这里的Chair会被放到Set中     对应的返回值其实是Set
    Chair provideChair(){
        return new Chair("DeskModule   intoset chair1");
    }

    @Provides
    @ElementsIntoSet   //这里的Chair会被放到Set中  且是同一个Set   对应的返回值其实是Set
    Set provideSetChair(){
        Set set = new HashSet<>();
        set.add(new Chair(" DeskModule   elementsIntoSet  chair2"));
        set.add(new Chair("DeskModule   elementsIntoSet   chair3"));
        return set;
    }

    @Provides  //返回值是Desk
    Desk provideDesk2(){
        return new Desk("DeskModule   desk3");
    }

    @Provides
    @IntoSet   //这里的Chair会被放到Set中  且是同一个Set   对应的返回值其实是Set
    String provideName(){
        return "DeskModule   aaaa";
    }
}

@Module
public class Desk2Module {

    @Provides
    @IntoSet  //这个返回值是Set   也会被放到Set中   且与DeskModule中的是同一个Set
    Desk provideDesk(){
        return new Desk("Desk2Module   intoset 2dest4");
    }

    @Provides
    @IntoSet  //这个返回值是Set   也会被放到Set中   且与DeskModule中的是同一个Set
    Chair provideChair(){
        return new Chair("Desk2Module   intoset 2chair4");
    }

    @Provides
    @ElementsIntoSet   //这个返回值是Set   也会被放到Set中   且与DeskModule中的是同一个Set
    Set provideSetChair(){
        Set set = new HashSet<>();
        set.add(new Chair("Desk2Module   ElementsIntoSet 2chair5"));
        set.add(new Chair("Desk2Module   ElementsIntoSet  2hair6"));
        return set;
    }


    @Provides
    @IntoSet//这个返回值是Set   也会被放到Set中   且与DeskModule中的是同一个Set
    String provideName(){
        return "Desk2Module   2bbbb";
    }
}

@Component(modules = {DeskModule.class,Desk2Module.class})
public interface SetActivityComponent {

    void inject(SetActivity activity);
    void inject(DeskActivity activity);
}

public class SetActivity extends AppCompatActivity {

    @Inject
    Set ss;

    @Inject
    Set sd;

    @Inject
    Set sc;

    @Inject
    Desk d;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_set);

        DaggerSetActivityComponent.create().inject(this);
        Log.e("start","---------");

        for(String str:ss){
            Log.e("ss=",str);
        }

        for(Desk d :sd){
            Log.e("sd=",d.toString());
        }

        for(Chair c : sc)
        {
            Log.e("sc=",c.toString());
        }

        Log.e("d=",d.toString());

        startActivity(new Intent(this,DeskActivity.class));
    }
}

public class DeskActivity extends AppCompatActivity {

    @Inject
    Set ss;

    @Inject
    Set sd;

    @Inject
    Set sc;

    @Inject
    Desk d;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_desk);

        DaggerSetActivityComponent.create().inject(this);
        Log.e("start","deskActivity---------");

        for(String str:ss){
            Log.e("ss=",str);
        }

        for(Desk d :sd){
            Log.e("sd=",d.toString());
        }

        for(Chair c : sc)
        {
            Log.e("sc=",c.toString());
        }

        Log.e("d=",d.toString());

        //startActivity(new Intent(this,ChairActivity.class));
    }
}
代码说明：
 DeskModule内，使用@IntoSet @ElementsIntoSet 返回了Set Set Set ，示例值都是以DeskModule开头
Desk2Module内，使用@IntoSet @ElementsIntoSet 返回了Set Set Set ，示例值都是以Desk2Module开头
SetActivityComponent中，module={DeskModule,Desk2Module}
 且inject(SetActivity) 和 inject(DeskActivity)
SetActivity 和DeskActivity 中分别对Set Set Set 进行访问
结果显示是两个module中的Desk Chair String 都add到了同一个Set Set Set 中了，说明同一个component多个module是共用一个Set的
 运行结果：
SetActivity内log的结果：
com.zhourf.dagger.daggerexample E/start: ---------
com.zhourf.dagger.daggerexample E/ss=: DeskModule   aaaa
com.zhourf.dagger.daggerexample E/ss=: Desk2Module   2bbbb
com.zhourf.dagger.daggerexample E/sd=: Desk{name='   DeskModule   intoset dest1'}
com.zhourf.dagger.daggerexample E/sd=: Desk{name='DeskModule   intoset dest2'}
com.zhourf.dagger.daggerexample E/sd=: Desk{name='Desk2Module   intoset 2dest4'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='Desk2Module   ElementsIntoSet  2hair6'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='DeskModule   intoset chair1'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='Desk2Module   ElementsIntoSet 2chair5'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='Desk2Module   intoset 2chair4'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='DeskModule   elementsIntoSet   chair3'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name=' DeskModule   elementsIntoSet  chair2'}
com.zhourf.dagger.daggerexample E/d=: Desk{name='DeskModule   desk3'}

DeskActivity内log的结果，与上面是一样的。
com.zhourf.dagger.daggerexample E/start: deskActivity---------
com.zhourf.dagger.daggerexample E/ss=: DeskModule   aaaa
com.zhourf.dagger.daggerexample E/ss=: Desk2Module   2bbbb
com.zhourf.dagger.daggerexample E/sd=: Desk{name='Desk2Module   intoset 2dest4'}
com.zhourf.dagger.daggerexample E/sd=: Desk{name='   DeskModule   intoset dest1'}
com.zhourf.dagger.daggerexample E/sd=: Desk{name='DeskModule   intoset dest2'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='DeskModule   elementsIntoSet   chair3'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name=' DeskModule   elementsIntoSet  chair2'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='Desk2Module   ElementsIntoSet 2chair5'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='Desk2Module   intoset 2chair4'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='DeskModule   intoset chair1'}
com.zhourf.dagger.daggerexample E/sc=: Chair{name='Desk2Module   ElementsIntoSet  2hair6'}
com.zhourf.dagger.daggerexample E/d=: Desk{name='DeskModule   desk3'}


在上面的代码基础上，增加一个ChairActivityComponent-ChairModule-ChairActivity
 如下代码：
@Module
public class ChairModule {

    @Provides
    @IntoSet
    Desk provideDesk3(){
        return new Desk("ChairModule  desk---");
    }

    @Provides
    @ElementsIntoSet
    Set provideDesks(){
        Set s = new HashSet<>();
        s.add(new Desk("ChairModule   ElementsIntoSet  desk///"));
        s.add(new Desk("ChairModule   ElementsIntoSet  desk+++"));
        return s;
    }
}

@Component(modules = ChairModule.class)
public interface ChairActivityComponent {

    void inject(ChairActivity activity);
}

public class ChairActivity extends AppCompatActivity {

//    @Inject
//    Set ss;

    @Inject
    Set sd;

//    @Inject
//    Set sc;
//
//    @Inject
//    Desk d;

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

        DaggerChairActivityComponent.create().inject(this);

        Log.e("start","ChairActivity---------");

//        for(String str:ss){
//            Log.e("ss=",str);
//        }

        for(Desk d :sd){
            Log.e("sd=",d.toString());
        }

//        for(Chair c : sc)
//        {
//            Log.e("sc=",c.toString());
//        }

//        Log.e("d=",d.toString());
    }
}
运行结果如下
com.zhourf.dagger.daggerexample E/start: ChairActivity---------
com.zhourf.dagger.daggerexample E/sd=: Desk{name='ChairModule   ElementsIntoSet  desk+++'}
com.zhourf.dagger.daggerexample E/sd=: Desk{name='ChairModule  desk---'}
com.zhourf.dagger.daggerexample E/sd=: Desk{name='ChairModule   ElementsIntoSet  desk///'}
ChairActivityComponent与SetActivityComponent是独立的，在ChairModule只是增加了Set,在ChairActivity中只能访问Set 且值只是ChairModule中增加的。说明了 两个component之间Set是独立的，互不影响。
IntoMap
@IntoSet是将同一个T的值存到一个Set中，看@IntoMap，应该也明白是将值存到一个Map中，只是增加了key。key的表示也是用注解的形式，如@StringKey @ClassKey
示例代码如下 example17
public class Mouse {
    public String name;

    @Override
    public String toString() {
        return "Mouse{" +
                "name='" + name + '\'' +
                '}';
    }

    public Mouse(String name) {
        this.name = name;
    }
}

@Module
public class MouseModule {

    @Provides
    @IntoMap
    @StringKey("key01")
    Mouse provideMouse(){   //注意这里的返回值是T
        return new Mouse("mouse01");
    }

    @Provides
    @IntoMap
    @StringKey("key02")
    Mouse provideMouse2(){
        return new Mouse("mouse02");
    }
}

@Component(modules = MouseModule.class)
public interface MapActivityComponent {
    void inject(MapActivity activity);
}

public class MapActivity extends AppCompatActivity {

    @Inject  //这里用这种方式注入结果  
    Map map;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_map);

        DaggerMapActivityComponent.create().inject(this);

        for(Map.Entry entry : map.entrySet()){
            Log.e(entry.getKey(),entry.getValue().toString());
        }
    }
}
运行结果：
com.zhourf.dagger.daggerexample E/key01: Mouse{name='mouse01'}
com.zhourf.dagger.daggerexample E/key02: Mouse{name='mouse02'}
结果显示，module中的两个provide方法都将值into中了map，key也是各自定义的。
 扩展：：：
 1.一个component，多个module，则Map共用吗？
 2.provideMouse方法 能放到Map中吗？
 示例代码， example17
public class Mouse {
    public String name;

    @Override
    public String toString() {
        return "Mouse{" +
                "name='" + name + '\'' +
                '}';
    }

    public Mouse(String name) {
        this.name = name;
    }
}

public class KeyBoard {
    public String name;

    @Override
    public String toString() {
        return "KeyBoard{" +
                "name='" + name + '\'' +
                '}';
    }

    public KeyBoard(String name) {
        this.name = name;
    }
}

@Module
public class MouseModule {

    @Provides
    @IntoMap
    @StringKey("key01")
    Mouse provideMouse(){
        return new Mouse("mouse01");
    }

    @Provides
    @IntoMap
    @StringKey("key02")
    Mouse provideMouse2(){
        return new Mouse("mouse02");
    }

}

@Module
public class Mouse2Module {

    @Provides
    @IntoMap
    @StringKey("key03")
    Mouse provideMouse3(){
        return new Mouse("mouse03");
    }

    @Provides
    @IntoMap
    @ClassKey(Mouse.class)
    Mouse provideMouse4(){
        return new Mouse("mouse04");
    }

    @Provides
    @IntoMap
    @ClassKey(MouseModule.class)
    KeyBoard provideMouse5(){
        return new KeyBoard("keyboard01");
    }

    @Provides
    @IntoMap
    @ClassKey(Mouse2Module.class)
    Object provideMouse6(){
        return new KeyBoard("object");
    }
}

@Component(modules = {MouseModule.class,Mouse2Module.class})
public interface MapActivityComponent {
    void inject(MapActivity activity);
}

public class MapActivity extends AppCompatActivity {

    @Inject
    Map map;

    @Inject
    Map,Mouse > map2;

    @Inject
    Map,KeyBoard> map3;

    @Inject
    Map,Object> map4;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_map);

        DaggerMapActivityComponent.create().inject(this);

        Log.e("tag","-----------");
        for(Map.Entry entry : map.entrySet()){
            Log.e(entry.getKey(),entry.getValue().toString());
        }
        Log.e("tag","-----------");
        for(Map.Entry,Mouse> entry : map2.entrySet()){
            Log.e(entry.getKey().getName(),entry.getValue().toString());
        }
        Log.e("tag","-----------");
        for(Map.Entry,KeyBoard> entry : map3.entrySet()){
            Log.e(entry.getKey().getName(),entry.getValue().toString());
        }
        Log.e("tag","-----------");
        for(Map.Entry,Object> entry : map4.entrySet()){
            Log.e(entry.getKey().getName(),entry.getValue().toString());
        }
    }
}
运行结果：
com.zhourf.dagger.daggerexample E/tag: -----------
com.zhourf.dagger.daggerexample E/key01: Mouse{name='mouse01'}
com.zhourf.dagger.daggerexample E/key02: Mouse{name='mouse02'}
com.zhourf.dagger.daggerexample E/key03: Mouse{name='mouse03'}
com.zhourf.dagger.daggerexample E/tag: -----------
com.zhourf.dagger.daggerexample E/com.zhourf.dagger.daggerexample.example17.Mouse: Mouse{name='mouse04'}
com.zhourf.dagger.daggerexample E/tag: -----------
com.zhourf.dagger.daggerexample E/com.zhourf.dagger.daggerexample.example17.MouseModule: KeyBoard{name='keyboard01'}
com.zhourf.dagger.daggerexample E/tag: -----------
com.zhourf.dagger.daggerexample E/com.zhourf.dagger.daggerexample.example17.Mouse2Module: KeyBoard{name='object'}
结论：
 1.在同一个component内，无论几个module，都共用同一个类型的Map
 2.Map的key与value的类型严格对应，这里不适用“接口的引用指向子类的对象”这句话。
再次扩展：如果是两个component，注入到两个类中呢？-example18
@Module
public class Map1Module {

    @Provides
    @IntoMap
    @StringKey("key01")
    String provideStr1(){
        return "value01";
    }
}
@Component(modules = {Map1Module.class})
public interface Map1ActivityComponent {
    void inject(Map1Activity activity);
}
public class Map1Activity extends AppCompatActivity {

    @Inject
    Map map;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_map1);

        DaggerMap1ActivityComponent.create().inject(this);


        Log.e("tag","Map1Activity-----------1111");
        for(Map.Entry entry:map.entrySet())
        {
            Log.e(entry.getKey(),entry.getValue());
        }

        startActivity(new Intent(this,Map2Activity.class));
    }
}

@Module
public class Map2Module {

    @Provides
    @IntoMap
    @StringKey("key02")
    String provideStr1(){
        return "value02";
    }
}

@Component(modules = {Map2Module.class})
public interface Map2ActivityComponent {
    void inject(Map2Activity activity);
}
public class Map2Activity extends AppCompatActivity {
    @Inject
    Map map;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_map2);

        DaggerMap2ActivityComponent.create().inject(this);


        Log.e("tag","Map2Activity-----------222");
        for(Map.Entry entry:map.entrySet())
        {
            Log.e(entry.getKey(),entry.getValue());
        }
    }
}
运行结果：
com.zhourf.dagger.daggerexample E/tag: Map1Activity-----------1111
com.zhourf.dagger.daggerexample E/key01: value01
com.zhourf.dagger.daggerexample E/tag: Map2Activity-----------222
com.zhourf.dagger.daggerexample E/key02: value02
可以看到两个component的情况下，Map是各自独立的。
扩展：如何自定义Map的key？
 在注释类型中声明的方法的返回类型，必须符合下列类型：
1.基本数据类型
2.String
3.Class
4.枚举类型
5.注解类型
6.以上数据类型的数组
看一个示例，example19
//自定义个枚举
public enum TestEnum {
    A,B,C,D
}

//自定义Map的key，方法返回值是枚举
@MapKey
public @interface CustKey {
    TestEnum value();
}

@Module
public class TestModule {
    @Provides
    @IntoMap
    @CustKey(TestEnum.A)
    String provideStrA(){
        return "aaa";
    }

    @Provides
    @IntoMap
    @CustKey(TestEnum.B)
    String provideStrB(){
        return "bbb";
    }
}

@Component(modules = TestModule.class)
public interface KeyActivityComponent {
    void inject(KeyActivity activity);
}

public class KeyActivity extends AppCompatActivity {

    @Inject
    Map map;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_key);

        DaggerKeyActivityComponent.create().inject(this);

        for(Map.Entry entry:map.entrySet())
        {
            Log.e(entry.getKey().toString(),entry.getValue());
        }
    }
}
运行结果：
com.zhourf.dagger.daggerexample E/A: aaa
com.zhourf.dagger.daggerexample E/B: bbb
@Component的dependencies
试想下：
 Component1提供了 A B C的依赖
 Component2提供了 D E F的依赖
 那么在一个目标类内@Inject A a;@Inject D d了，那么怎么实现？
 其实就是，每个component都有各自的提供依赖功能，怎么使用的问题。
 大家都知道Component(modules = {}) 中module的作用，其实还有个dependencies，也是类似的功能，区别在于 ：modules=Module类，dependencies=其他的Component ,这样就把其他component的功能引入到自身了。
 看下实例 example21
public class Table {
    @Inject
    public Table() {
    }

    public void name(){
        Log.e("Table tag","Table");
    }
}

@Module
public class TableModule {
    @Provides
    Table provideTable(){
        return new Table();
    }
}

@Component(modules = TableModule.class)
public interface TableComponent {
    //这么定义，会从所依赖的module中寻找
    //一般是供其他component依赖时这么定义
    Table getTable();
}

public class Cup {
    @Inject
    public Cup() {
    }

    public void name(){
        Log.e("cup tag","cups");
    }
}

@Module
public class CupModule {
    @Provides
    Cup provideCup(){
        return new Cup();
    }
}

//注意这里的dependencies
@Component(modules = CupModule.class,dependencies = TableComponent.class)
public interface CupActivityComponent {

    void inject(CupActivity activity);
}

public class CupActivity extends AppCompatActivity {

    @Inject
    Cup cup;

    @Inject
    Table table;//在TableComponent 中可以找到依赖来源

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

        DaggerCupActivityComponent
                .builder()
                .tableComponent(DaggerTableComponent.create())//因为CupActivityComponent  dependencies了TableComponent,所以这里需要传入TableComponent的实例
                .build()
                .inject(this);

        cup.name();
        table.name();
    }
}
运行结果：
com.zhourf.dagger.daggerexample E/cup tag: cups
com.zhourf.dagger.daggerexample E/Table tag: Table
@Subcomponent
看名字，就猜个大概，Component 的 sub ，sub 子的意思。
 这其实也是Component的一种依赖方式。
 更确切的说，subcomponent 继承了Component的依赖，并拥有自己的依赖。
 比如：
 Component1 可以提供A B C 依赖
 Subcomponent1 可以提供 D E 依赖
 SubComponent2 可以提供 F依赖
 那么：Subcomponent1 的inject的目标类中，可以提供ABCDE依赖
 SubComponent2的inject的目标类中，可以提供ABCF依赖
 注意：字的Component上必须标注为@Subcomponent
 看示例代码 example22
提供全局的Application的Component
首先自定义DaggerApplication，并在AndroidManifest中做修改
public class DaggerApplication extends Application {
    private static DaggerApplication instance;

    @Override
    public void onCreate() {
        super.onCreate();
        instance = this;
    }
    public static DaggerApplication getInstance(){
        return instance;
    }
}

提供Application的Module
@Module
public class ApplicationModule {
    @Provides
    DaggerApplication provideApplication(){
        return DaggerApplication.getInstance();
    }
}

定义类Lion  及其module component
public class Lion {
    public Lion() {
    }
    public void roar(){
        Log.e("lion","lion");
    }
}
@Module
public class LionModule {

    @Provides
    Lion provideLion()
    {
        return new Lion();
    }
}
//注意这里是Subcomponent
@Subcomponent(modules = LionModule.class)
public interface LionComponent {
   void inject(AnimalActivity activity);
}

定义类Tiger  及其module component
public class Tiger {

    public Tiger() {
    }
    public void roar()
    {
        Log.e("roar","tiger");
    }
}
@Module
public class TigerModule {

    @Provides
    Tiger provideTiger()
    {
        return new Tiger();
    }
}
//注意这里是sub
@Subcomponent(modules = TigerModule.class)
public interface TigerComponent {
    void inject(TigerActivity activity);
}

定义基Component，并将Lion和TigerComponent置为此的sub
@Component(modules = ApplicationModule.class)
public interface AnimalActivityComponent {
    LionComponent plus();
    TigerComponent plus2();
}

看一个Activity
public class AnimalActivity extends AppCompatActivity {

    @Inject
    Lion lion;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_animal3);
        
        DaggerAnimalActivityComponent.builder().build()//获取基Component
                .getLion()//获取子component  LionComponent
                .inject(this);  //注入此地
        lion.roar();

        startActivity(new Intent(this,TigerActivity.class));
    }
}

public class TigerActivity extends AppCompatActivity {
//自身提供的依赖
    @Inject
    Tiger tiger;

    //获取了基Component提供的依赖，这样就获取到了全局的一个application
    @Inject
    DaggerApplication application;

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

        AnimalActivityComponent component = DaggerAnimalActivityComponent.builder().build();
        Log.e("tag", "TigerActivity......");
        component.getTiger().inject(this);
        tiger.roar();
        Log.e("tag", "applicaion=" + application.getPackageName());
    }
}
运行结果：
com.zhourf.dagger.daggerexample E/lion: lion
com.zhourf.dagger.daggerexample E/tag: TigerActivity......
com.zhourf.dagger.daggerexample E/roar: tiger
com.zhourf.dagger.daggerexample E/tag: applicaion=com.zhourf.dagger.daggerexample

                    
                        
                        
                             
                        
                        
                        
                            
                        
                        
                        
                            
                        
                    
                

        你可能感兴趣的:(Dagger2)
        
            
                
                    dagger2 使用教程第一节
                        九风特

                        我翻译了官方文档，说实话，那个文档只是介绍了很多概念，第一次了解dagger2的兄弟，看完了可能更迷了。这没关系，也正常。下面我们来一步一步的学习它，既然要使用它当做我们架构的材料，那就要真正的了解它，不过凡事都要循序渐进，那么我们就从最简单的开始吧为什么要使用dagger2关于这方面可以参考官方文档的自述,使用dagger2的目的就是为了实现依赖注入，dagger2很好的实现了依赖注入，那么只要
                    
                    Dagger2 笔记
                        杨华_6f65

                        是一个依赖注入框架,依赖注入是面向对象编程的一种设计原则，其目的是为了降低程序耦合，实现MVP模式。
                    
                    Dagger2
                        imkobedroid

                        dependencies：一个component可以通过此注解依赖另外一个component，但是所依赖的component中必须要提供所要使用的modules中provide所注解的方法，并且返回值相同，如果其中有named注解的方法这里的返回值为void，如果依赖的component有@signton标注，依赖者必须自定义一个signton标注并放在上面，例如：被依赖者@Singleton@C
                    
                    Android项目框架之MVP+Dagger.Android+LiveData
                        海晨忆

                        个人博客：haichenyi.com。感谢关注  之前的那个系列从零开始搭建一个主流的项目框架（一~八），尽管把dagger2中injectactivity优化了一下，但是依然显得繁琐，每一个activity里面都要写一个inject方法。Dagger.Android只用在基类里面inject一次，子类里不用管，直接用。  还有就是之前的MVP架构，每次更新页面的时候都要在每个页面对应的Contr
                    
                    Android Weekly Notes #437-438
                        圣骑士wind

                        AndroidWeeklyIssue#4373PracticalStepsToMasterAndroidDataStoreGoodbyeGson,HelloMoshiGson已经过时了,拥抱moshi.AnnouncingCoil1.0Coil1.0发布.AndroidWeeklyIssue#438Dagger2inAndroidDynamicMultimoduleproject多module项目
                    
                    1.Android架构 retrofit运行时注解（POST详解）+反射实战demo 2分钟手写彻底搞懂注解
                        鹏城十八少

                        今天开始架构师之路！分为6节课，以手写retofit,Butterknife,Arount,Dagger2,hilit,ASM,AOP为主说说你对注解的了解，是怎么解析的编译时注解与运行时注解，为什么retrofit要使用运行时注解？什么时候用运行时注解？编译期注解处理的是字节码还是java文件它们的生命周期不一样，有些接口不用在编译时处理。他们没有用到。所以运行时更适合Retrofit:运行时注
                    
                    Dagger2 简单实例
                        King9527

                        最近通宵，一些技术的简单标记。Dagger2看了很多文章，对于刚开始看的人真是头疼，我们不是要解耦吗，感觉搞得很复杂，我按我的理解，由浅到深讲解一下。Dagger2是什么？agger2是一个基于JSR-330标准的依赖注入框架，在编译期间自动生成代码，负责依赖对象的创建有什么好处：为了进一步解耦和方便测试，我们会使用依赖注入的方式构建对象。Dagger2的字段说明：@Inject:通常在需要依赖的
                    
                    Android.mk中APT使用
                        Calvin880828
android系统分析
                        Android.mk中APT使用1.注解工具2.Android.mkAPT支持2.1Android.mk配置2.2Androidbuild系统patch3.编译生成源码1.注解工具注解工具是java代码生成及对象注入的强大工具。注解包括源码可见、字节码可见及运行时可见。目前比较流行的APT技术，也即时编译成字节码时可见。下面以Dagger2及ButterKnife两款注解工具讲解如何在Androi
                    
                    配置dagger2
                        不一样的王小同

                        不少同志看到网上配置dagger2的教程,结果可能一直报错,如下所示:Error:Couldnotgetunknownproperty'classpath'fortask':app:transformJackWithJackForDebug'oftypecom.android.build.....这个时候我们需要检查自己是否是按照网上说的那样添加apt插件什么的,其实不要那么做了,现在Androi
                    
                    单读学习-网络框架搭建
                        tuionf

                        概述单读APP的网络框架部分采用Dagger2+Retrofit2.0+Rxjava模式,网络框架的初始化在Application中，请先了解Dagger2的简单在引入依赖Retrofit2.0+Rxjava的依赖在build.gradle(app)分别引入Retrofit2.0和Rxjava的依赖compile'io.reactivex:rxjava:1.0.14'compile'io.reac
                    
                    2019-05-17 Dagger2 在 Kotlin 中使用出现Unresolved reference: DaggerxxxComponent
                        猫KK

                        如题，按正常的java方式使用，在将java代码转化成kotlin代码时，编译会出现Unresolvedreference:DaggerxxxComponent问题，这其实时kotlin的语言对注解的处理详细看这里，解决该问题：在app下的gradle中：WechatIMG475.jpegWechatIMG476.jpeg
                    
                    Android编译时注解
                        huweijian5

                        Android编译时注解[TOC]前言相信大家经常都使用到注解，如果使用过AndroidAnnotations,Dagger2,EventBus,RxJava,BufferKnife等开源项目，对注解应该更为深刻，这些项目的原理基本都是基于编译时注解动态生成代码，效果等同于手写代码，因此相对反射来说性能基本无影响。另外，已经实现了注解轻松实现线程切换开源项目，欢迎fork&star.了解注解注解的
                    
                    Dagger2基本使用2之子组件
                        翻滚丷大头鱼
javadagger2
                        一，基本使用，完成一个注入1，创建作用域//自定义作用域，作用域只是一个名称，随便起啥名字都可以，这里取一个全局单利的名字@Scope@Documented@Retention(RUNTIME)public@interfaceGlobalSingleton{}2，创建一个modulepublicinterfaceApiService{}//调用dagger的@Component注解，这个里面可以创
                    
                    Dagger2基本使用3之其他使用
                        翻滚丷大头鱼
javadagger2
                        一，Dagger容器中添加不是Dagger创建的实力对象在实际使用中，有些类的已经创建好了，dagger需要使用这些类，就需要通过参数传入，下面是android中传入application实例的一个例子1，创建module//创建需要传入已经已经创建好的实例类@ModulepublicclassContextModule{privatefinalApplicationapplication;//通
                    
                    Dagger2源码分析
                        翻滚丷大头鱼
android
                        首先，还是看看简单的dagger为我们写了哪些代码，先看代码publicclassUser{@InjectpublicUser(){Log.e("User","newUser"+this);}}@ComponentpublicinterfaceAppComponent{voidinject(MainActivitymainActivity);}publicclassMainActivityexte
                    
                    Android之Dagger&Hilt依赖注入使用指南
                        AAnthonyyy
依赖注入androidkotlinandroid-studio
                        简介Dagger2是一个DependencyInjection（DI）依赖注入框架。它提供给Java和Android使用，主要用于模块间解耦、提高代码的健壮性和可维护性。使用了IOC（控制反转）的思想，在编译阶段使用APT利用Java注解生成Java代码，然后结合部分手写代码来完整依赖注入工作。运行前需要先编译一次项目，目的是用APT生成中间代码。Dagger2不使用反射，在编译阶段生成代码，所以
                    
                    Android开源框架--Dagger2详解
                        袁震
android开源
                        功名只向马上取，真是英雄一丈夫一，定义我们知道在一个类中，通常会定义其他类型的变量，这个变量就是我们所说的“依赖“。对一个类的变量进行初始化，有两种方式。第一种，这个类自己进行初始化；第二种，其他外部的类帮你进行初始化。其中第二种方式，由外部类进行初始化的方式就是我们所说的”依赖注入“。由于他是由外部来控制，因此又叫做”控制反转“。依赖注入和非依赖注入的区别就是，变量初始化工作是由谁来做的。前面我
                    
                    Android-Jetpack--Hilt详解
                        袁震
androidjetpackandroid
                        善学者尽其理，善行者究其难一，定义Hilt是针对dagger2的二次封装依赖注入框架，至于什么是依赖注入，在Android开源框架--Dagger2详解-CSDN博客中已经讲解，建议大家先去了解Dagger2之后，再来看Hilt。这样就会感觉Hilt其实非常简单。上面说到了Hilt是对dagger2的二次封装，dagger2是可以用于任何类的注入的，但是Hilt就是安卓专属的API了。目前Hilt
                    
                    适用于 Android 初学者的 Dagger 2 - 进阶第二部分
                        PekingVagrant
android翻译适用于Android初学者的Dagger2-进Dagger2Dagger2forAndroidBeginners
                        原文链接这个故事是该系列的第七部分，适用于Android初学者的Dagger2。如果您没有阅读上一个，可以从下面开始。Dagger2forAndroidBeginners — IntroductionDaggerisafullystatic,compile-timedependencyinjectionframeworkforbothJavaandAndroid.Itisanadaptationo
                    
                    三 Dagger2的@Singleton注解
                        天地玄黄

                        概述：在Dagger2中，@Singleton注解可以保证被注解的对象全局都是单例。本篇主要分析为什么这个注解会有这种效果。首先@Singleton注解需要在两处添加：第一处是在创建实例的地方添加@ModulepublicclassMainModule{@Provides@SingletonstaticStudentprovideStudent(){returnnewStudent();}@Pro
                    
                    kotlin与dagger2问题：Unresolved reference: DaggerMainComponent
                        Mars-xq
kotlin
                        kotlin项目集成dagger2时遇到：E:\Users\lenovo\MyDagger2\app\src\main\java\com\xq\mydagger2\MainActivity.ktError:(22,9)Unresolvedreference:DaggerMainComponentError:Executionfailedfortask':app:compileDebugKotlin
                    
                    Dagger2学习笔记
                        Zeal27
架构依赖注入控制反转Dagger2
                        Dagger2是第一个使用生成代码的方式实现依赖注入的框架。作为Dagger的升级版本，自然有它的优势，优先注重的是执行效率。本文着重介绍Dagger2。官方据点传送门：https://google.github.io/dagger//users-guide.html首先来看一下依赖注入和控制反转在软件工程领域，DI是一种实现控制反转用来解决依赖的设计模式，依赖是一个可以被使用的对象（服务），注入
                    
                    创建Android Architecture Components项目需要用到的组件
                        执念蓝枫

                        LiveData持有可被观察数据的类DatBinding数据绑定（在布局文件里绑定数据）Dagger2依赖注入（用于解耦）Room对象映射库，能够在数据库内容发生改变时通过LiveData的形式发出通知LifecycleLifecycle是一个包含组件（Activity或者Fragment）生命周期状态的类，这个类还能够为其他类提供当前的生命周期。PagingLibrary分页加载库：用于逐步从数
                    
                    Android开发常用轮子
                        yabinYang
android常用
                        一、快速开发框架1.XSnow基于RxJava2+Retrofit2精心打造的Android基础框架，包含网络、上传、下载、缓存、事件总线、权限管理、数据库、图片加载，基本都是项目中必用功能，每个模块充分解耦，可自由拓展2.MVPArms一个整合了大量主流开源项目高度可配置化的AndroidMVP快速集成框架（包括Mvp、Dagger2、RxJava、RxAndroid、Rxlifecycle、R
                    
                    android常用轮子(持续更新)
                        流船

                        一、快速开发框架XSnow基于RxJava2+Retrofit2精心打造的Android基础框架，包含网络、上传、下载、缓存、事件总线、权限管理、数据库、图片加载，基本都是项目中必用功能，每个模块充分解耦，可自由拓展2.MVPArms一个整合了大量主流开源项目高度可配置化的AndroidMVP快速集成框架（包括Mvp、Dagger2、RxJava、RxAndroid、Rxlifecycle、RxC
                    
                    安卓常用框架
                        IT刘小牛
android安卓框架安卓轮子android
                        一、快速开发框架XSnow基于RxJava2+Retrofit2精心打造的Android基础框架，包含网络、上传、下载、缓存、事件总线、权限管理、数据库、图片加载，基本都是项目中必用功能，每个模块充分解耦，可自由拓展2.MVPArms一个整合了大量主流开源项目高度可配置化的AndroidMVP快速集成框架（包括Mvp、Dagger2、RxJava、RxAndroid、Rxlifecycle、RxC
                    
                    Dagger2 User's Guide (用户指南) 全文翻译。
                        红酥手黄藤酒丶

                        原文地址https://google.github.io/dagger/users-guide翻译很累，转载请注明出处。适合使用过一段时间Dagger2的人看。可能会用到的示例。下载官方github上的示例链接：https://github.com/google/dagger/tree/master/examples/simple/src/main/java/coffee有不对或者不合适的地方请指
                    
                    Dagger2进阶-模块化开发
                        dasan沈扬

                        在Dagger2快速入门中，我们通过注入了Logger，实现了打日志，假设要为Logger增加上传日志功能，那么现在Logger需要一个网络库组件Retrofit实例，这个实例不应该每次都初始化，应该是全局的，所以Logger代码改造如下：publicclassLogger{privateRetrofitretrofit;publicLogger(Retrofitretrofit){this.re
                    
                    Dagger2依赖注入解析之MVP模式解耦
                        乐小文

                        之前写过一篇关于Dagger2入门的一篇文章。前一篇文章只是简单的介绍了Dagger2的注解和使用，本篇文章旨在探讨Dagger2实际运用于MVP开发模式中如何解耦的问题。接下来，我们一起去看看Dagger2实际上手是如何使用的。创建BaseM、V、P层@Inject是不能使用在抽象类的构造函数上的，所以在解耦合MVP时需要注意。每个人对MVP开发的模式都有不同的理解，那么在我看来，黑猫白猫，只要
                    
                    Dagger2 独家解读
                        kevin910

                        1、Dagger2是干嘛的？Dagger2是用于依赖解耦的2、要了解Dagger2他是怎么解耦的？他是靠注解生成器，通过各种注解比如：@Component、@Module、@Provides、@Named、@Singleton等等在ASBuild阶段，使用com.google.dagger:dagger-compiler:2.11注解生成器，按照已经实现好的代码，对我们项目的整个代码进行扫描注解，
                    
                                web报表工具FineReport常见的数据集报错错误代码和解释
                                    老A不折腾
web报表finereport代码可视化工具
                                    在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 
  
NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 
NS_LayerReport_MultiDs=错误代码
                                
                                Java的WeakReference与WeakHashMap
                                    bylijinnan
java弱引用
                                    首先看看 WeakReference 
 
wiki 上 Weak reference 的一个例子： 
 
 

	public class ReferenceTest {
	public static void main(String[] args) throws InterruptedException {
 
            WeakReference r = new Wea
                                
                                Linux——（hostname）主机名与ip的映射
                                    eksliang
linuxhostname
                                    一、 什么是主机名 
无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的； 
主机名是用于什么的呢？ 
答：在一个局域网中，每台机器都有一个主
                                
                                oracle 常用技巧
                                    18289753290

                                    oracle常用技巧   ①复制表结构和数据     create table  temp_clientloginUser   as     select distinct userid from tbusrtloginlog   ②仅复制数据   如果表结构一样   insert into  mytable  select  * &nb
                                
                                使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException
                                    酷的飞上天空
exception
                                    有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
                                
                                IT系统分析师如何学习大数据
                                    蓝儿唯美
大数据
                                    我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系 统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
                                
                                spring学习——简介
                                    a-john
spring
                                    Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 
 
为了降低Java开发的复杂性，
                                
                                自定义颜色的xml文件
                                    aijuans
xml
                                    <?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
                                
                                运营到底是做什么的？
                                    aoyouzi
运营到底是做什么的？
                                    文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
                                
                                js面向对象类和对象
                                    百合不是茶
js面向对象函数创建类和对象
                                    接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言 但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下  ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似 
  
下面介绍一些js的类和对象的创建的技术 
  
一:类和对
                                
                                web.xml之资源管理对象配置 resource-env-ref
                                    bijian1013
javaweb.xmlservlet
                                    resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 
<resource-env-ref>
    <resource-env-ref-name>资源名</resource-env-ref-name>
    <resource-env-ref-type>查找资源时返回的资源类
                                
                                Create a composite component with a custom namespace
                                    sunjing

                                    https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace 
  
When you developed a composite component the namespace you would be seeing would 
                                
                                【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter
                                    bit1129
mongodb
                                     一、复本集为什么要加入Arbiter这个角色   回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。   什么是Artiber？   An arbiter does 
not have a copy of data set and 
cannot become a primary. Replica sets may have arbiters to add a 
                                
                                Javascript开发笔记
                                    白糖_
JavaScript
                                     
 获取iframe内的元素 
 
通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
                                
                                Web浏览器Chrome打开一段时间后，运行alert无效
                                    bozch
Webchormealert无效
                                    今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。 
试了试其他浏览器，发现都是没有问题的。 
开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。 
这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了 就关闭浏览器重启。 
  
结果就好了，这也太怪异了。难道是cho
                                
                                编程之美-高效地安排会议 图着色问题 贪心算法
                                    bylijinnan
编程之美
                                    

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class GraphColoringProblem {

	/**编程之美 高效地安排会议 图着色问题 贪心算法
	 * 假设要用很多个教室对一组
                                
                                机器学习相关概念和开发工具
                                    chenbowen00
算法matlab机器学习
                                    基本概念： 
机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。 
它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。 
 
开发工具 
M
                                
                                [宇宙经济学]关于在太空建立永久定居点的可能性
                                    comsci
经济
                                     
       大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 
 
       所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
                                
                                oracle 11g database control 证书错误
                                    daizj
oracle证书错误oracle 11G 安装
                                    oracle 11g database control 证书错误  
 
win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面 
 
解决办法： 
 
是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
                                
                                Java I/O之用FilenameFilter实现根据文件扩展名删除文件
                                    游其是你
FilenameFilter
                                    在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。 
在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16 
                                
                                C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例
                                    dcj3sjt126com
carray
                                    # include <stdio.h>

int main(void)
{
	
	int a[5] = {1, 2, 3, 4, 5};
		//a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4]
	
	int i;

	for (i=0; i<5; ++i)
		printf("%d\n",
                                
                                PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。 就是 唯一 且 不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引
                                    dcj3sjt126com
primary
                                    PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。 就是 唯一 且 不能为空。INDEX 索引，普通的UNIQUE 唯一索引。 不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号   INT会员姓名  
                                
                                java集合辅助类 Collections、Arrays
                                    shuizhaosi888
CollectionsArraysHashCode
                                      
Arrays、Collections 
  
1 ）数组集合之间转换 
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    } 
     a）Arrays.asL
                                
                                Spring Security（10）——退出登录logout
                                    234390216
logoutSpring Security退出登录logout-urlLogoutFilter
                                           要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
                                
                                透过源码学前端 之 Backbone 三 Model
                                    逐行分析JS源代码
backbone源码分析js学习
                                    Backbone 分析第三部分  Model 
概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里， 
但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件， 
如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。 
                                
                                SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter
                                    乒乓狂魔
springMVC
                                    这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 
 
HttpMessageConverter接口介绍： 
 

public interface HttpMessageConverter<T> {

	/**
	 * Indicate
                                
                                分布式基础知识和算法理论
                                    bluky999
算法zookeeper分布式一致性哈希paxos
                                       
分布式基础知识和算法理论 
BY [email protected] 
本文永久链接：http://nodex.iteye.com/blog/2103218 
  
在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
                                
                                Android Studio的.gitignore以及gitignore无效的解决
                                    bell0901
androidgitignore
                                    　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 
　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了 
　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store 
                                
                                成为高级程序员的10个步骤
                                    tomcat_oracle
编程
                                    What 
软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 
  
Why 
 
  得到更多的报酬！因为你的薪水会随着你水平的提高而增加  
  提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进  
  历经更大的挑战。随着你的成长，各种影响力也会提高。  
                                
                                mongdb在linux下的安装
                                    xtuhcy
mongodblinux
                                    一、查询linux版本号： 
lsb_release -a  
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa
                                
                
            
        
    

    
        
            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    

    
        
            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.