阅读 248

【android】摆正姿势,dagger2原来如此简单

##1.前言 依稀记得两年之前就偷偷学习过dagger2的使用,当然那个时候也是云里雾里,对照着博客确实实现了对象的注入,但是后来基本上没有再深入的学习过,虽然偶尔也会浏览到dagger2的文章,但是实际项目中并没有使用,一直搁置着,最近突然脑子发热,想学习了,刚好学到了这里,趁着脑子热,索性就记录下,待以后需要使用的翻看便知。

##2.什么是dagger2 dagger2是一款非常有名的依赖注入框架,那么问题来了,什么是依赖注入,很简单,就是字面意思,当你需要创建对象的时候,依赖于其他的程序进行注入,而不是自己主动去创建。

平时我们用到的set方法其实也是一种依赖注入的方式,再比如有参构造函数传递过来的对象同样属于注入的一种。

优点:

  • 避免无用的体力劳动(重复多次new对象)
  • 更好的管理类的实例,避免耦合 #####引入dagger2:
    annotationProcessor 'com.google.dagger:dagger-compiler:2.11' 
    implementation 'com.google.dagger:dagger-android:2.11'
    implementation 'com.google.dagger:dagger-android-support:2.11'
    // if you use the support libraries
    annotationProcessor 'com.google.dagger:dagger-android-processor:2.11'
复制代码

##3.最简单的对象注入(无参)

dagger2的使用依赖于几个比较主要的注解,下面跟随我一切来实现一个简单的对象注入,我们想要在MainActivity创建一个School对象:

1.首先创建School类

public class School {
    @Inject
    public School() {
    }
}
复制代码

可以看到我们在School的构造函数上加上了@Inject注解,此处的作用就是 : #####标识School类可以被注入,相对于给注入的对象指定一个创建的来源,不然程序无法知晓如果创建school对象。

2.school类有了,也标明了它可以被注入(使用@Inject注解),下面我们就要找个东西来创建这个实例,@Component注解就是这个作用,它相当于一个注入器,负责生产类的实例,起到一个桥梁的作用,一端是生产,一端是注入。

@Component
public interface MainComponent {
    void inject(MainActivity activity);
}
复制代码

3.Android Studio中 build---> make project,或者单独编译下module也可以,编译完成后将会自动生成dagger2注入所需的代码,代码生成位置在:

2.png

此时我们开始把school对象注入到MainActivity中,代码如下:

public class MainActivity extends AppCompatActivity {

    @Inject
    School school;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //inject方法负责连接所创建的实例和mainActivity,此时实例被赋值给school变量
        DaggerMainComponent.create().inject(this);
        Log.e("daggerLog","school :【"+school+"】");
    }
}
复制代码

####此时运行程序,就会出现下面的打印结果:

1.png

我们发现,MainActivity并没有new School()的操作,仅仅通过@Inject注解,并且进行inject连接之后,对象就“自动”产生了。

有些杠精可能要说了,这TM实在逗我,创建个对象一行代码搞定了,你给我弄这么多花里胡哨的不嫌麻烦吗?我只能说你说的没毛病,单个对象不频繁的创建或许并不需要这么麻烦,但是为了降低代码的耦合性,或者说从架构方面考虑,可能这真的很有必要。

##4.有参的对象注入

上面我们只是简单定义了一个无参的School对象,那么有参的对象应该如何注入呢,下面我们改造下School类。

public class School {

    private String name;

    private String address;

    @Inject
    public School(String name, String address) {
        this.name = name;
        this.address = address;
    }
}
复制代码

嗯,也没干啥,就增加了两个参数,我们来编译一下:

3.png

完犊子,报错了,看错误提示里面出现了@Provides注解,那么对于有参的构造函数,该如何进行注入呢,dagger2给我们提供了两个注解,@Module和@Provides, @Module标识我是用来提供注入实例的,@Provides用来表示具体提供实例的方法,看下面的这段代码:

@Module
public class MainModules {

    @Provides
    public School provideSchool(){
        return new School("南京高级中学","江苏南京");
    }
}
复制代码

在class名字上方加上@Module注解,在具体提供实例的地方添加上@Provides注解,此时School就具备了被注入的能力,但前面我们说到连接实例和被注入端使用的是@Component注解,那么如何为@Component指定使用哪个Module注入呢?

@Component(modules = MainModules.class)
public interface MainComponent {
    void inject(MainActivity activity);
}
复制代码

####很简单,通过@Component中的modules关键字来指定提供实例的module,如果有多个module可以使用{}括起来,形如下面这样的形式:

@Component(modules = {MainModules.class,OtherModules.class})
复制代码

此时我们再次编译项目,并且修改MainActivity代码如下:

public class MainActivity extends AppCompatActivity {

    @Inject
    School school;

    @Inject
    School school2;

    private Button btnJump;

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

        DaggerMainComponent.create().inject(this);

        Log.e("daggerLog","school name:【"+school.getName()+"】 address:【"+school.getAddress()+"】");

        Log.e("daggerLog","school add >【"+school+"】");
        Log.e("daggerLog","school2 add >【"+school2+"】");

  }
}
复制代码

运行后,结果打印如下:

4.png

此时School对象已经注入完毕,可以正常使用了,此处大家可能发现了我们注入了两个School对象,但如果我们想保持School单例的话,该如何操作呢? 当然dagger2不会让我们为这些所担忧,它提供了@Singleton注解用于处理单例的情况;

####注意:Singleton是局部单例,和生命周期绑定,注入activity单例范围就是当前activity之内,注入application就是全局单例。 下面我们来验证一下,修改代码,在Module和Component中分别加入@Singleton注解,缺一不可,此时代码如下:

@Module
public class MainModules {

    @Singleton
    @Provides
    public School provideSchool(){
        return new School("南京高级中学","江苏南京");
    }
}

@Singleton
@Component(modules = MainModules.class)
public interface MainComponent {
    void inject(MainActivity activity);
}

复制代码

运行后,结果打印如下:

5.png

可以看到此时在MainActivity中确实实现了单例,那么我们再次修改下代码,新增SecordActivity,并把School对象注入到SecordActivity中,并在MainActivity中添加跳转按钮,点击后跳转到SecordActivity:

@Singleton
@Component(modules = MainModules.class)
public interface MainComponent {
    void inject(MainActivity activity);
    void inject(SecordActivity activity);
}

public class SecordActivity extends AppCompatActivity {

    @Inject
    School school;

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

        DaggerMainComponent.create().inject(this);

        Log.e("daggerLog","secord school add >【"+school+"】");
    }
}
复制代码

编译运行后,点击跳转后打印结果如下:

6.png
####就像我们前面说的那样,@Singleton是局部单例,此时的两个Activity中的School对象已经是不同的对象了。

我们看下@Singleton的源码:

@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}
复制代码

发现里面有个@Scope注解,@Scope其实才是单例的关键,@Scope是用来管理生命周期的,而@Singleton是dagger2通过@Scope提供的一种默认实现。

##5.全局单例的实现 下面我们看一下全局单例该如何实现,首先创建MyApplicaiton:

public class MyApplicaiton extends Application {

    private AppComponent appComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        appComponent = DaggerAppComponent.builder().build();
    }

    public AppComponent getAppComponent() {
        return appComponent;
    }
}

@Singleton
@Component(modules = {AppModule.class})
public interface AppComponent {
    void inject(MainActivity activity);
    void inject(SecordActivity activity);
}

@Module
public class AppModule {

    @Singleton
    @Provides
    public School provideSingleSchool(){
        return new School("全局单例的School","中国");
    }
}

public class MainActivity extends AppCompatActivity {

    @Inject
    School school;

    @Inject
    School school2;

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

        ((MyApplicaiton)getApplication()).getAppComponent().inject(this);


        Log.e("daggerLog","school name:【"+school.getName()+"】 address:【"+school.getAddress()+"】");

        Log.e("daggerLog","school add >【"+school+"】");
        Log.e("daggerLog","school2 add >【"+school2+"】");
    }
}

public class SecordActivity extends AppCompatActivity {

    @Inject
    School school;

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

        ((MyApplicaiton)getApplication()).getAppComponent().inject(this);

        Log.e("daggerLog","secord school add >【"+school+"】");
    }
}
复制代码

然后运行,跳转到SecordActivity,日志打印如下:

7.png
#####通过日志可以发现,所有的School对象都是同一对象,实现了全局的单例!

##6.如何传递context.

有些时候我们在通过@Provides提供对象的时候需要context参数,形如下面的形式:

public class ShowUtils {
    private Context context;

    @Inject
    public ShowUtils(Context context) {
        this.context = context;
    }
}
复制代码

这个时候如果我们正常通过@Provides的方式提供的话,dagger是无法确定此处的context是哪种类型的,是Application的?还是Activity的?此时编译就会报错,那么我们该如何指定Context具体是何种类型呢?

#####此时又出现了一个新的注解@Qualifier,@Qualifier的作用是当dagger无法确定类型的时候,或者说当我们@module里有多个provides提供相同类型的返回值(dagger提供对象是根据返回值匹配的)的时候,对类型进行限定,下面举个例子来体验一下,首先自定义一个限定注解:

@Qualifier
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface ForActivityContext {
}
复制代码

然后我们修改下上面例子中的MainModules:

@Module
public class MainModules {

    private Context context;

    public MainModules(Context context) {
        this.context = context;
    }

    @Singleton
    @Provides
    public School provideSchool(){
        return new School("南京高级中学","江苏南京");
    }

    @Singleton
    @Provides
    public ShowUtils provideShowUtils(){
        return new ShowUtils(context);
    }

    //注意这里,此处限定我们使用的context是activity的context
    @ForActivityContext
    @Provides
    public Context provideContext(){
        return context;
    }
}

复制代码

当然我们还需要在需要此对象的Activity上添加此注解:

@ForActivityContext
public class MainActivity extends AppCompatActivity {

    @Inject
    School school;

    @Inject
    School school2;

    @Inject
    ShowUtils showUtils;

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

        DaggerMainComponent.builder().mainModules(new MainModules(this)).build()
                .inject(this);
        Log.e("daggerLog","school name:【"+school.getName()+"】 address:【"+school.getAddress()+"】");

        Log.e("daggerLog","school add >【"+school+"】");
        Log.e("daggerLog","school2 add >【"+school2+"】");

        Log.e("daggerLog","showUtils add >【"+showUtils+"】");
    }
}
复制代码

此时运行结果如下,可以看到showUtils对象成功注入到了MainActivity中:

8.png

####再看另外一种情况: 当我们需要在一个@module里提供同一对象的不同实例的时候,该如何指定具体需要由哪个@Provides来提供呢? 先看下面一段代码:

    @Singleton
    @Provides
    public School provideSchool(){
        return new School("南京高级中学","江苏南京");
    }

    @Singleton
    @Provides
    public School provideSchoolOther(){
        return new School("国外学校","外国");
    }
复制代码

其他代码不修改,直接编译会报下面的错误:

9.png
不要慌,@Qualifier来帮你解决这个问题,首先使用@Qualifier自定义一个注解:

@Qualifier
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface SchoolType {
    int type() default 0;
}
复制代码

然后在@provides中添加此注解:

    @SchoolType
    @Singleton
    @Provides
    public School provideSchool(){
        return new School("南京高级中学","江苏南京");
    }

    @SchoolType(type = 1)
    @Singleton
    @Provides
    public School provideSchoolOther(){
        return new School("国外学校","外国");
    }
复制代码

在MainActivity中@Inject处指定需要使用那种type的对象来进行注入:

@ForActivityContext
public class MainActivity extends AppCompatActivity {

    @SchoolType
    @Inject
    School school;

    @SchoolType(type = 1)
    @Inject
    School school2;

    @Inject
    Student student;

    @Inject
    ShowUtils showUtils;

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

        DaggerMainComponent.builder().mainModules(new MainModules(this)).build()
                .inject(this);

        Log.e("daggerLog","school name:【"+school.getName()+"】 address:【"+school.getAddress()+"】");

        Log.e("daggerLog","school add >【"+school+"】");
        Log.e("daggerLog","school2 add >【"+school2+"】");
        Log.e("daggerLog","school2 name:【"+school2.getName()+"】 address:【"+school2.getAddress()+"】");

        Log.e("daggerLog","showUtils add >【"+showUtils+"】");
    }
}
复制代码

运行结果如下:

10.png
可以看到school和school2对象都成功的注入到了MainActivity中,由于我们指定了@SchoolType并且使用了不同的type,所以创建了两个不同的对象。 #####那么是不是我们需要限定的时候就需要自定义注解呢,当然不是,dagger2为我们提供了一个注解@Named,我们来看下@Named的源码:

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {
    /** The name. */
    String value() default "";
}
复制代码

是不是瞬间豁然开朗,这不就是我们刚刚定义的@SchoolType一样嘛,只是名字不同罢了,当然把上面的@SchoolType直接替换成@Named也是一样的,不信大家可以试试!

####说了这么多,对于dagger基本使用大家是不是有点头绪了,本篇我们主要讲解了基本注解@Inject,@Component,@Module,@Provides,@Qualifier等的使用,当然dagger2还是很多更高阶的用法,比如dependencies依赖,又比如subcomponent注解我们还没有讲到,这些内容准备放在下篇博文中进行讲解,敬请期待!

本文源码地址: github.com/hanxiaofeng… --- > daggeruse目录

文章分类
Android
文章标签