文章目录
  1. 1. 依赖注入
  2. 2. 依赖注入器Dagger
  3. 3. Dagger 使用例子
  4. 4. 链接

依赖注入

依赖是我们代码中两个模块之间的耦合,通常是一个模块需要用到另外一个模块。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public interface Led{
void on();
void off();
}

public class A implements Led{
void on() {
System.out.println("A on");
}
void off(){
System.out.println("A off");
}
}

public class B implements Led{
void on() {
System.out.println("B on");
}
void off(){
System.out.println("B off");
}
}

public class User {
...
Led led;
...
public user() {
led = new B();
}
}

上面的代码中Class User 就依赖Class B 。

上面的实现明显有问题,类User中不应该出现Led的子类。明显应该把类A或者类B的实例作为参数传。
可以如下实现。

1
2
3
4
5
6
7
8
public class User {
...
Led led;
...
public user(Led led) {
this.led = led;
}
}

修改之后的代码耦合性明显降低,这就叫依赖注入。 依赖注入有两个好处:

  • 解耦 耦合度降低
  • 方便测试

依赖注入的核心思想就是,被依赖者不要在依赖者里面创建,而是别的地方创建,然后通过注入器注入到依赖者里面。

依赖注入器Dagger

这里的dagger是指square出品的原始 dependency injector
到目前为止最新版本1.2.5。

compile ‘com.squareup.dagger:dagger:1.2.5’
compile ‘com.squareup.dagger:dagger-compiler:1.2.5’

IDEA 需要Settings > Compiler > Annotation Processors > “Enable annotation processing” 否则不会自动生成需要的代码。

有时候可能只是用用@Injection 那么只要引入下面这个包即可。

compile ‘javax.inject:javax.inject:1’

https://mvnrepository.com/artifact/javax.inject/javax.inject/1 这个链接是maven的仓库,列举了不同构建工具的依赖指令。

有人利用java手动实现依赖注入
http://blog.evercoding.net/2016/04/12/implement-dependency-injection-by-annotation

Dagger 使用例子

  1. 新建工程

  2. 引入dagger库

  3. 简单例子

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    import dagger.Module;
    import dagger.ObjectGraph;

    import javax.inject.Inject;

    /**
    * Created by Peter on 2016/9/2.
    */
    public class Test2 {
    @Inject
    FloorLamp lamp;

    public static void main(String args[]) {
    System.out.println("Test2 ++");
    ObjectGraph o = ObjectGraph.create(Test2M.class);
    Test2 t = o.get(Test2.class);
    t.lamp.on();
    t.lamp.off();

    }

    @Module(injects = Test2.class)
    static class Test2M {
    }

    static class FloorLamp implements Lamp {
    @Inject
    FloorLamp() {
    System.out.println("Floor lamp instance");
    }
    public void on() {
    System.out.println("Floor lamp on");
    }

    public void off() {
    System.out.println("Floor lamp off");
    }
    }

    }

在类Test2中没有直接实例化FloorLamp。

  • Test2总要有个地方实例化
  • Test2依赖的FloorLamp也要实例化

@Module(injects = Test2.class) 指明了要注入的地方。ObjectGraph o = ObjectGraph.create(Test2M.class);执行之后,Dagger就知道了依赖关系。

@Inject FloorLamp() 告诉Dagger用这个构造函数去实例化FloorLamp,实例化之后赋值个Test2实例的lamp。
这些事情发生在Test2 t = o.get(Test2.class); 语句中。当这个语句返回,FloorLamp和Test2就已经实例化完成并实现了注入。

链接

http://square.github.io/dagger/