Dagger2框架学习--第一节 实例展示

概述:

现在的领导都是需要秘书和司机等服务人员，以此为实例来实现代码。

1 第一版代码

领导依赖秘书端茶倒水，这就是依赖的概念。

//领导
public class LingDao {
    private Mishu mishu;
    public LingDao() {
        this.mishu = new Mishu();
    }
}


/**
 * 秘书
 */
public class Mishu {
    public void daoshu() {
        Logger.d("倒水");
    }
}

2 领导有了个情人

1 领导有了情人，而且领导经常换口味，领导喜欢根据年龄来选情人

/**
 * 领导情人
 */
public class Qingren {
    private int age;

    public Qingren(int age) {
        this.age = age;
    }
}

//领导
public class LingDao {
    private Mishu mishu;
    private Qingren qingRen;

    public LingDao() {
        this.mishu = new Mishu();
        this.qingRen = new Qingren(18);
    }
}


/**
 * 秘书
 */
public class Mishu {
    public void daoshu() {
        Logger.d("倒水");
    }
}

2 领导要根据身材来选情人

/**
* 领导
* Created by lincoln on 2017/8/17.
*/
public class LingDao {
   private Mishu mishu;
   private Qingren qingRen;

   public LingDao() {
       this.mishu = new Mishu();
//        this.qingRen = new Qingren(3);
       this.qingRen = new Qingren("丰满");
   }
}


/**
* 领导情人
*/
public class Qingren {
//    private int age;

//    public Qingren(int age) {
//        this.age = age;
//    }

   private String style;

   public Qingren(String style) {
       this.style = style;
   }
}


/**
* 秘书
*
* Created by lincoln on 2017/8/17.
*/
public class Mishu {
   public void daoshu() {
       Logger.d("倒水");
   }
}

第一次领导根据年龄选择情人，第二次领导根据身材选情人。
每次领导变换选择标准，都要变更LingDao.java的代码，耦合性太强，解耦参考第二版代码

2 第二版代码:

/**
 * 主方法
 * Created by lincoln on 2017/8/17.
 */
public class Main {

    public static void main(String[] args) {
        Qingren qingren = new Qingren("清纯");
        Mishu mishu = new Mishu();
        
        LingDao lingDao = new LingDao(mishu,qingren);
    }
}


/**
 * 领导
 * Created by lincoln on 2017/8/17.
 */
public class LingDao {
    private Mishu mishu;
    private Qingren qingRen;

    public LingDao(Mishu mishu, Qingren qingRen) {
        this.mishu = mishu;
        this.qingRen = qingRen;
    }
}

/**
 * 秘书
 *
 * Created by lincoln on 2017/8/17.
 */
public class Mishu {

    public void daoshu() {
        Logger.d("倒水");
    }

}

/**
 * 领导情人
 */
public class Qingren {
//    private int age;

//    public Qingren(int age) {
//        this.age = age;
//    }

    private String style;

    public Qingren(String style) {
        this.style = style;
    }
}

解耦后，领导变换选择情人的标准，不会影响到LingDao.java。
这种实例化依赖的权力移交模式被称为控制反转（IoC），
而这种通过将依赖从构造方法中传入的手段就是被传的神乎其乎的依赖注入（DI）。

3 依赖注入三种方法

1  构造方法注入
class A {
    B b;
    C c;
    public A(B b, C c) {
        this.b = b;
        this.c = c;
    }
} 

2  Setter方法注入

class A {
    B b;
    C c;
    public void setB(B b) {
        this.b = b;
    }
    public void setC(C c) {
        this.c = c;
    }
}

3  接口注入
interface Setter {
    void setB(B b);
    void setC(C c);
}

class A implements Setter{
    B b;
    C c;
    public void setB(B b) {
        this.b = b;
    }
    public void setC(C c) {
        this.c = c;
    }
}

大家肯定会想，依赖注入的引进，使得需求方不需要实例化依赖，但总得有地方去实例化这些依赖啊。
确实，依赖注入引进了第三方，你可以称它为 IoC 容器，也可以称它为注射器（injector），为了便于理解，
我们之后都有注射器来指代吧，通过注射器可以将依赖以上面 3 种注入方式之一注入到需求方。   

参考

轻松学，听说你还没有搞懂 Dagger2