Dagger2入门

一、为什么要使用Dagger2

Dagger2是一个Android端的依赖注入框架，如果你不了解什么是依赖注入的话，我想你看这篇文章也没有必要，当然如果是为了学习新技术，推荐去google一下什么叫依赖注入，有很多好文章，这篇介绍的是dagger2的使用，就不介绍什么是依赖注入了和依赖注入的好处了。

二、基本使用

使用时我们要有一个基本思想，所谓的依赖注入是事先把要用到的对象实例化，然后利用注入器注入到要用这个对象的地方。所以我们要做两件事，第一，实例化对象。第二，写一个构造器。

1、利用@Inject直接定义构造方法

现在有这样一个类

public class Animal {
private String name;
public Animal(){
this.name ="puppy";
}
}

我们要注入这样一个类，可以分一下几步走

1）利用@Inject注解构造方法，这一步就是直接宣告这个类可以通过这个构造方法实例化。

public class Animal {
private String name;

@Inject
public Animal(){
this.name ="puppy";
}

public String getName(){
return name;
}
}

2）利用@Component声明一个注入器

@Component()
public interface AnimalMainComponet {
void inject( MainActivity mainActivity);
}

如果想要声明一个注入器，那么我们要创建一个接口，利用@Component声明，然后写一个inject方法，传入的必须是要注入的类的强类型，上面这个例子说明我们想注入到MainActivity中，注意，这里的方法可以随意命名，不会影响。当然，除了使用接口，我们也可以使用抽象类：

@Component()
public  abstract class AnimalMainComponet {
abstract void inject( MainActivity mainActivity);
}

3）开始注入

因为dagger2是基于编译期生成代码的，所以先编译一下，就会自动生成一个以Dagger开头的类，利用这个类来注入

public class MainActivity extends AppCompatActivity {

@Inject Animal animal;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView tv = (TextView)findViewById(R.id.tv);
DaggerAnimalMainComponet.builder().build().inject(this);
tv.setText(animal.getName());

}
}

利用@Inject直接声明下Animal，然后利用DaggerAnimalMainCompomet注入下就可以使用animal了。运行结果



利用@Inject直接注入构造方法非常简单，但是有缺点

public class User {
private String name;
private String age;

public User(Car car){
this.name =car.getName();
this.age ="345";
}

public User(String name,String age){
this.name =name;
this.age = age;
}

public String getInfo(){
return name+" "+age;
}
}

这里有两个构造方法，但是，@Inject只能用来指明使用一个构造方法注入，而且这个方法还必须是无参的，在这里就不能这么用了。另外，我们经常用到第三方的包，是不可能修改第三方包中的构造方法的。所以这种注入方式虽然简单，但是不怎么用。我们接着介绍第二种方法：

2、利用@Module，@Provides注入。

还是以这个Animal为例，假设我么无法修改这个Animal类：

public class Animal {
private String name;
public Animal(){
this.name ="puppy";
}
}

我们按照以下步骤来

1）利用@Module声明一个类：这步是为了宣告这个类可以用来提供实例化好了的对象

@Module
public class AnimalModule {

}

2）在@Module类中利用@Provides来预先生成要用的对象。

@Module
public class AnimalModule {
@Provides
Animal provideAnimal(){
return new Animal();
}
}

这里真正提供Animal对象的是利用@Provides注解的provideAnimal方法，需要注意的是提供对象的方法必须以provide开头。

3）利用@Component声明注入器

@Component(modules = AnimalModule.class)
public  interface AnimalMainComponet {
void inject( MainActivity mainActivity);
}

这里和上面不同的是要指明我们从哪里获取需要的对象，用的就是

@Component(modules = AnimalModule.class)

如果这里要从多个地方获取不同的对象，可以这样写 

@Component(modules = {AnimalModule.class,CarModule.class,UserModule.class})

4）开始注入

public class MainActivity extends AppCompatActivity {

@Inject Animal animal;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView tv = (TextView)findViewById(R.id.tv);
DaggerAnimalMainComponet.builder().build().inject(this);
tv.setText(animal.getName());

}
}

真正注入的实现和第一种方法中提到的是一模一样的。

三、复杂应用

 1. 构造方法带参数怎么办

现在有这样一个类

public class Car {
private String name;
public Car(String name){
this.name = name;
}

public String getName(){
return name;
}
}

用上面的第一种方法肯定不行，那让我们用第二种方法来写

写一个@Module，并且提供一个@Provides方法

@Module
public class CarModule {
@Provides
Car provideCar(){
return new Car("宝马");
}
}

这里问题来了，我们只能在这部把传入的参数写死了，但是我想在用的时候再传入参数怎么办呢？可以利用CarModule传入

@Module
public class CarModule {
private String inputCarName;
public CarModule(String name){
inputCarName = name;
}
@Provides
Car provideCar(){
return new Car(inputCarName);
}
}

这里我们在CarModule中定义了一个参数用来接收传入的参数，然后在provideCar中使用，在MainActivity中这样使用

public class MainActivity extends AppCompatActivity {

@Inject Car car;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView tv = (TextView)findViewById(R.id.tv);
DaggerCarMainComponent.builder().carModule(new CarModule("奔驰")).build().inject(this);
tv.setText(car.getName());

}
}

和之前的比起来，注入的时候多了一个carModule方法，这里我们可以实例化自己的CarModule，随意传入参数。看下运行结果

2. 有多个构造方法怎么办

有这样一个类要注入：

public class User {
private String name;
private int age;
public User(int age){
this.age =age;
name = "defaultName";
}

public User(String name){
this.name =name;
this.age =99;
}

public String getInfo(){
return name+" "+age;
}
}

这个类中有两个构造方法，那么我们在@Module中提供实例时也应该提供两个不同的方法，分别用不同的构造方法来生成对象，比如这样

@Provides
public User provideUserByName(){
return new User(name);
}

@Provides
public User provideUserByAge(){
return new User(age);
}

但是，很不幸，这样会报错，因为Dagger2框架不知道应该选哪个方法去生成User对象。知道原因就好解决了，我们可以用@Name注解表明下

@Module
public class UserModule {

private String name;
private  int age;
public UserModule(String name,int age){
this.name =name;
this.age =age;
}

@Named("ByName")
@Provides
public User provideUserByName(){
return new User(name);
}

@Named("ByAge")
@Provides
public User provideUserByAge(){
return new User(age);
}

}

在使用的时候可以这样用

public class MainActivity extends AppCompatActivity {

@Named("ByName")
@Inject
User user1;

@Named("ByAge")
@Inject
User user2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView tv = (TextView)findViewById(R.id.tv);
DaggerUserMainActivityComponent.builder().userModule(new UserModule("hello",100)).build().inject(this);
tv.setText("ByName: "+user1.getInfo()+"  ByAge: "+user2.getInfo());

}
}

这样就知道user1 是用了provideUserByName()这个方法生成，user2是用了provideUserByAge（）这个方法生成的。这样问题确实解决了，但是字符串很容易出错啊，一不小心拼错了怎么办？  为了更方便的使用，我们可以使用@Qualifier 注解来自定义一个注解，达到上面的字符串一样的效果。

首先自定义两个注解来代替上面的两个字符串：

用来代替ByName字符串的注解@ByName

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface ByName {
}

以及用来代替ByAge字符串的注解@ByAge

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface ByAge {
}

用法这样的，在@Module中

@ByName
@Provides
public User provideUserByName(){
return new User(name);
}

@ByAge
@Provides
public User provideUserByAge(){
return new User(age);
}

在使用时

@ByName
@Inject
User user1;

@ByAge
@Inject
User user2;

3. 构造方法的参数中有要靠依赖注入的对象

先看下我们的项目结构，我们现在有三个类可以实现依赖注入了，现在我们有这样一个类

public class InfoUtil {
public Animal animal;
public Car car;
public User user;

public InfoUtil(Animal animal) {
this.animal = animal;

}

public InfoUtil(Car car) {
this.car = car;
}

public InfoUtil(User user) {
this.user = user;
}

public String getAnimalInfo(){
return "the name of animal is : "+animal.getName();
}

public String getCarInfo(){
return "the name of car is :"+car.getName();
}

public String getUserInfo(){
return ""+user.getInfo();
}

}

我们来看看这个类的module怎么写

@Module
public class InfoUtilModule {

@ByAnimal
@Provides
public InfoUtil provideInfoUtilByAnimal(Animal animal){
return new InfoUtil(animal);
}

@ByUser
@Provides
public InfoUtil provideInfoUtilByUser(@ByName User user){
return new InfoUtil(user);
}

@ByCar
@Provides
public InfoUtil provideInfoUtilByCar(Car car){
return new InfoUtil(car);
}
}

可以看到，这里定义了三个不同的注解来区分用不同的参数构造InfoUtil这个类，注意provideInfoUtilByUser这个方法，它的参数需要显示制定用那种方式注入，这里用的是@ByName。那么这些方法中的Animal ，User，Car从哪里来呢？ 这里框架会自动从建立的依赖关系图中去获取，所以我们在写Component的时候就要指定提供这些对象的Module类，如下

@Component(modules = {InfoUtilModule.class, AnimalModule.class, CarModule.class, UserModule.class})
public interface InfoUtilComponent {
public void inject(MainActivity mainActivity);
}

四、巨坑

同一个Activity只能在一个Component中注入，否则会报错，就是说如果在不同Component中的 inject方法中传入了同一个Activity的引用会报错。