Dagger2-从入门到精通(上)

前言

最近在做项目中,用到了Dagger2,所以找了一些博客和其他的一些学习资源,算是知道如何使用了,但是对其理解还相差很远。所以这篇文章重点针对与使用,和使用中常见的一些问题。对更深层的东西我就不再这里不懂装懂了。如果以后有机会或需要会在以后学习更加深入后在另写文章。


Dagger2

根据官网来说他就是一个快速的依赖注入框架。如果对依赖注入不太了解,那么请看这篇文章依赖注入原理,在这里我就不过多介绍了。其实他的作用重点就是解耦和管理实例对象。那我们看看他具体有什么好处:

  1. 依赖的注入和配置独立于组件之外,注入的对象在一个独立、不耦合的地方初始化,这样在改变注入对象时,我们只需要修改对象的实现方法,而不用大改代码库。
  2. 依赖可以注入到一个组件中:我们可以注入这些依赖的模拟实现,这样使得测试更加简单。
  3. app中的组件不需要知道有关实例创建和生命周期的任何事情,这些由我们的依赖注入框架管理的

这是网上的一切说法。对于文字我们不好理解,还是看看在具体应用中我们该如何去使用。不过在使用之前我们先简单的理解及概念。 @Inject: 通常在需要依赖的地方使用这个注解。换句话说,你用它告诉Dagger这个类或者字段需要依赖注入。这样,Dagger就会构造一个这个类的实例并满足他们的依赖。

@Module: Modules类里面的方法专门提供依赖,所以我们定义一个类,用@Module注解,这样Dagger在构造类的实例的时候,就知道从哪里去找到需要的 依赖。modules的一个重要特征是它们设计为分区并组合在一起(比如说,我们的app中可以有多个组成在一起的modules)

@Provide: 在modules中,我们定义的方法是用这个注解,以此来告诉Dagger我们想要构造对象并提供这些依赖。

@Component: Components从根本上来说就是一个注入器,也可以说是@Inject和@Module的桥梁,它的主要作用就是连接这两个部分。 读不懂也没关系,我们接下来实战代码。在讲解后在结合概念我们就能很好的理解了


引入

引入方法有2种: 第一种: 在工程的build.gradle文件中添加android-apt插件(该插件后面介绍)

buildscript {

    ....

    dependencies {

        classpath 'com.android.tools.build:gradle:2.1.0'
        // 添加android-apt 插件
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}

在app的中的build.gradle文件中添加配置

apply plugin: 'com.android.application'
// 应用插件
apply plugin: 'com.neenbedankt.android-apt'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.2"

    defaultConfig {
        applicationId "com.mahao.alex.architecture"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}


dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.3.0'

    // dagger 2 的配置
    compile 'com.google.dagger:dagger:2.4'
    apt 'com.google.dagger:dagger-compiler:2.4'
    compile 'org.glassfish:javax.annotation:10.0-b28'// 添加java 注解库
}

以上两个配置就可以了。

android-apt是Gradle编译器的插件,根据其官方文档,主要两个目的:

  • 编译时使用该工具,最终打包时不会将该插件打入到apk中。
  • 能够根据设置的源路径,在编译时期生成相应代码。

在导入类库时,

    compile 'com.google.dagger:dagger:2.4'
    apt 'com.google.dagger:dagger-compiler:2.4'

dagger是主要的工具类库。dagger-compiler为编译时期生成代码等相关的类库。

在android-apt的文档中,也推荐使用这种方式。因为,编译时期生成代码的类库在运行期并不需要,那么将其分为两个库,(运行类库dagger)和(编译器生成代码类库(dagger-compiler)),那么在打包时,就不需要将dagger-compiler打入其中(用不到),减小APK 的大小


第二种: 这种方法比较简单(Android Studio2.2以上),直接引入依赖

 compile 'com.google.dagger:dagger:2.9'
 annotationProcessor 'com.google.dagger:dagger-compiler:2.9'

推荐第一种方式


实践

public class ApiService {
    
    public void register() {
        //注册的方法
         Log.i("TAG", "ApiService: ");
    }

}

public class UserStroe {

    public void login(){
        //登录的方法
    }
}

首先假设我们现在有两个方法,一个是注册,另一个是登录。如果我们现在MainActivity中调用register();我们一般会这么写:

ApiSeivie apiServce=new ApiService();
apiService.register();

如果们们使用Dagger2该如何使用呢?

  • module 首先:我们先创建module(他是主要提供实例的类),这里我们定义为UserModule:
@Module
public class UserModule {

    public UserModule() {
    }

    @Provides
    public ApiService provideApiService() {
        return new ApiService();
    }
}

@Module: Modules类里面的方法专门提供依赖,所以我们定义一个类,用@Module注解,这样Dagger在构造类的实例的时候,就知道从哪里去找到需要的依赖。

@Provide: 在modules中,我们定义的方法是用这个注解,以此来告诉Dagger我们想要构造对象并提供这些依赖。

现在我们回头在看看概念是不就明白其中的含义了。

可以看到我们在MainActivity中需要ApiService,我们在module中创建他的实例。等他需要的时候我们就给他。现在module创建好了。我们还需要调用者(MainActivity)和被调用者(module)之间的桥梁,这就是Component。

注意,在module中,我们创建的方法必须是public不可以是privite。这个也很好理解。我们创建的方法本来就是给外界调用的,如果你用privite的话只能本类使用了。

Component:

@Component(modules = {UserModule.class})
public interface UserComponet {

    void inject(MainActivity activity);
}
注意:inject方法接收父类型参数,而调用时传入的是子类型对象则无法注入。比如你想作用BaseActivity,inject()就传入BaseActivity,但是只能作用BaseActivity不能作用子类MainActivity。反之亦然;

@Component: 我们定义UserComponet并加上@Component注解。表明他是一个桥梁。首先他必须是一个接口。其次我们必须依赖一个module(当然,从{}这个符号我们就可以看到,他可以同时依赖多个module),它还有另一参数dependencies,这里我们先不说他,等后面讲到了再说他。这里我们看到他里面只有一个方法 void inject().这里我们传入MainActivity,因为我们想在这个类中使用我们实例ApiService。这样module和MainActivity通过Component就关联起来了。创建好这些类以后我们需要Rebuild Progect。

图片.png

这是会生成一个DaggerUserComponet类,这个类命名是以Dagger开头接上我们UserComponet类名。这个类方法很少,主要就是将我们的MainActivity和Component关联起来,通过:

DaggerUserComponet.create().inject(this);

将我们的MainActivity传入Component的inject()方法中,这样这个桥梁就就通了,我们就可以使用了,如下:

public class MainActivity extends AppCompatActivity {


    @Inject
    ApiService mApiService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerUserComponet.create().inject(this);
        mApiService.register();
        Log.d("TAG", "onCreate: " + mApiService);
    }
}
注意 这里我们 @Inject注解的对象不能用privite修饰。

在我们的想要的创建的对象加上@Inject注解并且调用DaggerUserComponet.create().inject(this);后我们就可以使用这个对象了。我们运行看看结果:

dagger2 D/TAG: ApiService: 
com.example.ggxiaozhi.dagger2 D/TAG: onCreate: com.example.ggxiaozhi.dagger2.ApiService@4a7c73b4

可以看到正常运行没有问题了。实例对象已经被我们创建出来了。我们用2张图总结一下:

图片.png

这张图从概念出发,我们再从我们的例子中总结出来经验概括就是这样的:

图片.png


明白了流程后那他是怎么解耦的呢?使用方法就这么简单就结束了吗?答案是肯定的。我们一定不止这么简单,关于解耦的话我就举一个简单的例子。之前我们创建了2个类注册和登录,现在我们再创建一个类去管理他们:

public class UserManager {

    UserStroe mUserStroe;
    ApiService mApiService;

    public UserManager() {
        mApiService = new ApiService();
        mUserStroe = new UserStroe();
    }

    public void register() {
        mApiService.register();
        mUserStroe.login();
    }
}

然后我们在MainActivity中去调用UserManager中的register方法。这么一个看好像是没什么问题,但是如果我们mApiService.register();需要一个Context参数怎么办?你可能会这么该:

public class UserManager {

    UserStroe mUserStroe;
    ApiService mApiService;

    public UserManager(Context context) {
        mApiService = new ApiService(context);
        mUserStroe = new UserStroe();
    }

    public void register() {
        mApiService.register();
        mUserStroe.login();
    }
}

调用处new UserManager(this);但是你注意看,我们只是需要一个context就要将UserManager和MainActivity中的代码都要改,要是在实际项目中,需要改更多的参数呢?所以我们来看下用Dagger2该如何解决。这里我把需求再复杂话一些。首先我们还是先从module来看: 这里我们将例子复杂一下假设ApiService需要一个context,userStroe需要一个url。我们就可以这样写

@Module
public class UserModule {

    Context context;

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

    @Provides
    public ApiService provideApiService() {
        return new ApiService(context);
    }
    @Provides
    public String providerUrl() {
        return "www.baidu.com";
    }

    @Provides
    public UserManager provideUserManager(ApiService apiService, UserStroe userStroe) {
        return new UserManager(userStroe, apiService);
    }
}
public class UserManager {
    UserStroe mUserStroe;
    ApiService mApiService;

    public UserManager(UserStroe mUserStroe, ApiService mApiService) {
        this.mUserStroe = mUserStroe;
        this.mApiService = mApiService;
    }

    public void register() {
        mApiService.register();
        mUserStroe.login();
    }
}

 public class UserStroe {

    @Inject
    public UserStroe(String url) {
        Log.d("TAG", "UserStroe: " + url);
    }

    public void login() {
        Log.d("TAG", "UserStroe: ");
    }
}  

public class MainActivity extends AppCompatActivity {


    @Inject
    UserManager mManager;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);
        mManager.register();
        Log.d("TAG", "onCreate: " + mManager);
    }
}

这里我们创建DaggerUserComponet用了方法:

 DaggerUserComponet.builder().userModule(new UserModule(this)).build().inject(this);

这个方法与之前用的其实内部都是一样的,因为我们UserModule需要context参数,所以我们选择这种构建方法

可以看到在创建对象时我们可以在module中像之前一样提供一个创建的方法,第二种我们也可以通过在对象的构造函数上加上@Inject注解,这里我们需要一个url和context,我们只需要提供一个创建String的url方法即可,并通过UserModule的构造函数将conetxnt传入,最后提供一个创建UserManager的方法将两个参数穿进去,最后运行一下:

dagger2 D/TAG: UserStroe: www.baidu.com
com.example.ggxiaozhi.dagger2 D/TAG: ApiService: 
com.example.ggxiaozhi.dagger2 D/TAG: UserStroe: 
com.example.ggxiaozhi.dagger2 D/TAG: onCreate: com.example.ggxiaozhi.dagger2.UserManager@4a7c6f00

可以看到我们修改了这么多,又需要URL,又需要context但是我们创建UserManager和调用方法没变,因为我们只是需要UserManager中的方法,里面你需要什么,怎么实现的对MainActivity它并不关心。所以这样就大大做到了解耦的目的。其实使用Dagger2就说白了就是调用者需要什么实例我就在module中创建什么实例,如果这个实例需要参数,需要什么参数,我就在mudule给你创建你想要的参数。


结语

这篇文章属于入门,下一章才是重点,我们会介绍@Qualifier,@Named ,@Singleton以及自定义注解。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏向治洪

android dataBinding详解

官方介绍地址:http://developer.android.com/intl/zh-cn/tools/data-binding/guide.html 201...

22410
来自专栏向治洪

Android面试之高级篇

结合自己之前去很多大公司的面试经历和自己面别人的一些题,这里做一些总结,Android面试中常见的面试题。 1,Android的Handler运行机制     ...

2779
来自专栏白驹过隙

ZeroMQ - 三种模型的python实现

48114
来自专栏Android相关

Android7.0中的ResourceNotFoundException

随着Android N的出现,适配7.0的问题也成为了各大产品头疼的问题。而最近在我们的平台上面收到了7.0的Crash。具体的栈如下:

2315
来自专栏移动端开发

Android学习--持久化(三) SQLite & LitePal

    自己做为一个iOS开发,看到安卓这一块的时候,那中浓烈的熟悉味道更加强烈,SQLite这种轻量级的关系型数据库的使用在移动端相差不多,iOS有FMDB,...

1333
来自专栏Android常用基础

AndFix的使用分析

最近发现热修复比较火,很多文章也做了介绍。所以自己也简单的学习下。因为自己在实际项目中并没有用到。所以为了防止忘记,写成博客做成笔记,同时也帮助一些没有接触过的...

1692
来自专栏Java编程技术

Spring&Mybaits数据库配置解惑

一般我们会在datasource.xml中进行如下配置,但是其中每个配置项原理和用途是什么,并不是那么清楚,如果不清楚的话,在使用时候就很有可能会遇到坑,所以下...

1212
来自专栏Phoenix的Android之旅

观察者模式--DataBinding的原理和坑

上一次我们介绍了DataBinding的应用,不过只在应用层面描述了下,没有做深入分析。 关于DataBinding的实现原理,它的根本思想是观察者模式。 这篇...

2362
来自专栏非著名程序员

Android 开发如何做好内存优化

Android的一个应用程序的内存泄露对别的应用程序影响不大。为了能够使得Android应用程序安全且快速的运行,Android的每个应用程序都会使用一个专有...

1927
来自专栏Adam笔记

KSCrash源码分析

6430

扫码关注云+社区

领取腾讯云代金券