架构进阶，Dagger2的原理及使用详解

目录

  • 一：Dagger2是什么？
  • 二：为什么要有Dagger2
  • 三：Dagger2如何使用
  1. 基本的概念
  2. 如何使用Dagger2
  3. 高级用法

（1）构造方法需要其他参数时候
（2） 模块之间的依赖关系
（3） @Named注解使用
（4） @Singleton注解
（5）自定义Scoped
（6）Subcomponent
（7）lazy 和 Provider

  • 四： MVP + Dagger2

Ps：文末有架构师进阶资料和面试题资料

一：Dagger2是什么？

是一个依赖注入框架，butterknife也是一个依赖注入框架。不过butterknife，最多叫奶油刀，Dagger2被叫做利器啊，他的主要作用，就是对象的管理，其目的是为了降低程序耦合。

二：为什么要有Dagger2

下面我就手写了

public class A {
 public void eat() {
 System.out.print("吃饭了");
 }
}

使用的时候我们就要

A a = new A();
a.eat();

如果现在改了,早A的构造方法中必须传入B对象

 public class A {
 private B b;
 public A(B b) {
 this.b = b;
 }
 public void eat() {
 System.out.print("吃饭了");
 }
}

那么使用的时候

A a = new A(new B());
a.eat();

可能就有人说了，不就加一个对象么，这里只是我举的一个很简单的例子，看的感觉很简单，但是在实际开发中，如果现在改了一个这个构造方法。是不是意味着，整个项目中的都的改，一不小心， 就是BUG 啊

三：Dagger2如何使用

1. 基本的概念

上来给你说，怎么玩，肯定懵逼，这里我简单说一下几个概念，想有个认知，在往下看，会好很多，Dagger 是通过@Inject使用具体的某个对象，这个对象呢，是由@Provides注解提供，但是呢，这个@Provides只能在固定的模块中，也就是@Module注解，我们查找的时候，不是直接去找模块，而是去找@Component

我们反向推导，当我们使用

@Inject
A a

想要获取a对象的示例的时候，Dagger2 会先去找，当前Activity或者Fragment所连接的桥梁，例如上图中，连接的只有一个桥梁，实际上可以有多个，这个桥梁，会去寻找他所依赖的模块，如图中，依赖了模块A，和模块B，然后在模块中，会去寻找@Providers注解，去寻找A的实例化对象。

2. 如何使用Dagger2

(1) 引入依赖库

Dagger2官网

compile ‘com.google.dagger:dagger:2.11‘
 annotationProcessor ‘com.google.dagger:dagger-compiler:2.11‘
(2) 创建Moudule
//第一步 添加@Module 注解
@Module
public class MainModule {
}
(3)创建具体的示例
//第一步 添加@Module 注解
@Module
public class MainModule {
 //第二步 使用Provider 注解 实例化对象
 @Provides
 A providerA() {
 return new A();
 }
}
(4)创建一个Component
//第一步 添加@Component
//第二步 添加module
@Component(modules = {MainModule.class})
public interface MainComponent {
 //第三步 写一个方法 绑定Activity /Fragment
 void inject(MainActivity activity);
}
(5)Rebuild Project

然后AS 会自动帮我们生成一个

开头都是以Dagger开始的

（6）将Component与Activity/Fragment绑定关系
package com.allens.daggerdemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import com.allens.daggerdemo.Bean.A;
import com.allens.daggerdemo.component.DaggerMainConponent;
import javax.inject.Inject;

public class MainActivity extends AppCompatActivity {
 /***
 * 第二步 使用Inject 注解，获取到A 对象的实例
 */
 @Inject
 A a;

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

 /***
 * 第一步 添加依赖关系
 */
 //第一种方式
 DaggerMainConponent.create().inject(this);

 //第二种方式
 DaggerMainConponent.builder().build().inject(this);

 /***
 * 第三步 调用A 对象的方法
 */
 a.eat();
 }
}

肯定有小伙伴说了，为了拿到一个对象，这么大个弯，太麻烦了。别急慢慢看，路要一步一步走嘛

3. 高级用法

（1）构造方法需要其他参数时候

怎么说呢，就和最来时的意思一样，

A a = new A(new B());
a.eat();

这种情况，如何使用Dagger2呢

肯定有小伙伴这么想

@Provides
 A providerA() {
 return new A(new B());
 }

直接 new 一个B ，这样的使用方法，是不对的！！！！！！，不对的！！！！！！！，不对的！！！！！！！！！

正确的打开方式

这时候，我们什么都不用该，只需要在moudule中添加一个依赖就可以了

@Module
public class MainModule {

 /***
 * 构造方法需要其他参数时候
 *
 * @return
 */
 @Provides
 B providerB() {
 return new B();
 }

 @Provides
 A providerA(B b) {
 return new A(b);
 }
}
（2） 模块之间的依赖关系

模块与模块之间的联系，

@Module (includes = {BModule.class})// includes 引入)
public class AModule {
 @Provides
 A providerA() {
 return new A();
 }
}

这样的话，Dagger会现在A moudule 中寻找对象，如果没找到，会去找module B 中是否有被Inject注解的对象，如果还是没有，那么GG，抛出异常

一个Component 应用多个 module

@Component(modules = {AModule.class,BModule.class})
public interface MainComponent {
 void inject(MainActivity activity);
}

dependencies 依赖其他Component

@Component(modules = {MainModule.class}, dependencies = AppConponent.class)
public interface MainConponent {
 void inject(MainActivity activity);
}

注意 这里有坑。一下会讲解

（3） @Named注解使用

相当于有个表示，虽然大家都是同一个对象，但是实例化对象不同就不如

A a1 = new A();
A a2 = new A();

// a1 a2 能一样嘛

Module中 使用@Named注解

@Module
public class MainModule {

 private MainActivity activity;

 public MainModule(MainActivity activity) {
 this.activity = activity;
 }

 @Named("dev")
 @Provides
 MainApi provideMainApiDev(MainChildApi mainChildApi, String url) {
 return new MainApi(mainChildApi, activity,"dev");
 }

 @Named("release")
 @Provides
 MainApi provideMainApiRelease(MainChildApi mainChildApi, String url) {
 return new MainApi(mainChildApi, activity,"release");
 }

}

在Activity/Fragment中使用

public class MainActivity extends AppCompatActivity {

 @Named("dev")
 @Inject
 MainApi apiDev;

 @Named("release")
 @Inject
 MainApi apiRelease;

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

 DaggerMainComponent.builder()
 .mainModule(new MainModule(this))
 .mainChildModule(new MainChildModule())
 .build()
 .inject(this);
 apiDev.eat();
 apiRelease.eat();
 Log.i("TAG","apiDev--->" + apiDev);
 Log.i("TAG","apiRelease--->" + apiRelease);
 }

}

打印Log

07-14 01:46:01.170 2006-2006/? I/TAG: apiDev--->[email protected]77928f
07-14 01:46:01.170 2006-2006/? I/TAG: apiRelease--->[email protected]
（4） @Singleton注解

单利模式，是不是超级方便，你想然哪个对象单利化，直接在他的Provider上添加@Singleton 就行了

例如

@Singleton
 @Provides
 A providerA(B b) {
 return new A(b);
 }

注意: 第一个坑！！！
如果 moudule所依赖的Comonent 中有被单利的对象，那么Conponnent也必须是单利的

@Singleton
@Component(modules = {MainModule.class})
public interface MainConponent {
}

然后 在Activity中使用，直接打印a1 a2 的地址，

@Inject
 A a2;
 @Inject
 A a1;

可以看到Log

12-30 01:32:58.420 3987-3987/com.allens.daggerdemo E/TAG: A1---->[email protected]
12-30 01:32:58.420 3987-3987/com.allens.daggerdemo E/TAG: A1---->[email protected]

不相信的小伙伴可以吧@Singleton去掉试试

现在我们完成了单利，然后做了一个事情，就是点击某个按钮，跳转到一个新的Activiry,两边都引用同样一个A 对象，打印A 的地址，

说一下，一个Conponent 可以被对个Activity/Fragment 引用,如

@Singleton
@Component(modules = {MainModule.class})
public interface MainConponent {
 void inject(MainActivity activity);
 void inject(TestAct activity);
}

上面与两个Activity, MainActivity 和 TestAct ，都引用相同的 对象，答应地址看看

12-30 00:48:17.477 2788-2788/com.allens.daggerdemo E/TAG: A1---->[email protected]
12-30 00:48:17.517 2788-2788/com.allens.daggerdemo E/TAG: A2---->[email protected]

竟然不同，说好的单利呢

注意: 第二个坑，单利对象只能在同一个Activity中有效。不同的Activity 持有的对象不同

那有人就要问了，没什么办法么，我就想全局只要一个实例化对象啊？ 办法肯定是有的，

（5） 自定义Scoped
/**
 * @作者 ： Android架构
 * @创建日期 ：2017/7/14 下午3:04
 * @方法作用：
 * 参考Singleton 的写法
 * Scope 标注是Scope
 * Documented 标记在文档
 * @Retention(RUNTIME) 运行时级别
 */
@Scope
@Documented
@Retention(RUNTIME)
public @interface ActivityScoped {
}

首先想一下，什么样的对象，能够做到全局单例，生命周期肯定和APP 绑定嘛，这里我做演示，一个AppAip 我们要对这个对象，全局单利，所以二话不说，先给Application 来个全家桶，

Module

@Module
public class AppModule {

 @Singleton
 @Provides
 AppApi providerAppApi() {
 return new AppApi();
 }
}

Component

@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {
 AppApi getAppApi();
}

Application

public class MyApp extends Application {

 private AppConponent appComponent;

 @Override
 public void onCreate() {
 super.onCreate();
 appComponent = DaggerAppConpoment.create();
 }

 public AppConponent getAppComponent() {
 return appConponent;
 }
}

最后是如何使用

首先，这个是个桥梁，依赖方式，上文已经说过了

@ActivityScoped
@Component(modules = {MainModule.class}, dependencies = AppConponent.class)
public interface MainComponent {
 void inject(MainActivity activity);
 void inject(TestAct activity);
}

细心的小伙伴可能已经发现了，只有在上面一个MainComponent添加了一个@ActivityScoped,这里说明一下，@Singleton是Application 的单利

注意，第三个坑，子类component 依赖父类的component ，子类component的Scoped 要小于父类的Scoped，Singleton的级别是Application

所以，我们这里的@Singleton 级别大于我们自定义的@ActivityScoped，同时，对应module 所依赖的component ，也要放上相应的Scope

好吧，上面的例子，打印Log.

12-30 02:16:30.899 4717-4717/? E/TAG: A1---->[email protected]
12-30 02:16:31.009 4717-4717/? E/TAG: A2---->[email protected]

一样啦

爬坑指南（极度重要）

  1. Provide 如果是单例模式 对应的Compnent 也要是单例模式
  2. inject(Activity act) 不能放父类
  3. 即使使用了单利模式，在不同的Activity 对象还是不一样的
  4. 依赖component， component之间的Scoped 不能相同
  5. 子类component 依赖父类的component ，子类component的Scoped 要小于父类的Scoped，Singleton的级别是Application
  6. 多个Moudle 之间不能提供相同的对象实例
  7. Moudle 中使用了自定义的Scoped 那么对应的Compnent 使用同样的Scoped
（6）Subcomponent

这个是系统提供的一个Component，当使用Subcomponent,那么默认会依赖Component

例如

@Subcomponent(modules = TestSubModule.class)
public interface TestSubComponent {
 void inject(MainActivity activity);
}
@Component(modules = {MainModule.class})
public interface MainConponent {
 TestSubComponent add(TestSubModule module);
}

在TestSubComponent中 我void inject(MainActivity activity);，便是这个桥梁，我是要注入到MainActivity,但是dagger 并不会给我生成一个Dagger开头的DaggerTestSubComponent 这个类，如果我想使用TestSubModule.class里面提供的对象，依然还是使用DaggerMainConponent例如

DaggerMainConponent
 .builder()
 .mainModule(new MainModule())
 .build()
 .add(new TestSubModule())
 .inject(this);

可以看到这里有一个add的方法，真是我在MainConponent添加的TestSubComponent add(TestSubModule module);

（7）lazy 和 Provider
public class Main3Activity extends AppCompatActivity {

 @PresentForContext
 @Inject
 Lazy<Present> lazy;
 @PresentForName
 @Inject
 Provider<Present> provider;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main3);

 AppComponent appComponent = DaggerAppComponent.builder().appModule(new AppModule(this)).build();
 ActivityComponent activityComponent = DaggerActivityComponent.builder()
 .appComponent(appComponent)
 .activityModule(new ActivityModule())
 .build();

 activityComponent.injectActivity(this);
 Present present = lazy.get();
 Present present1 = provider.get();
 }
}

其中Lazy(懒加载)的作用好比component初始化了一个present对象,然后放到一个池子里,需要的时候就get它,所以你每次get的时候拿到的对象都是同一个;并且当你第一次去get时,它才会去初始化这个实例.

procider(强制加载)的作用:

1:同上当你第一次去get时,它才会去初始化这个实例

2:后面当你去get这个实例时,是否为同一个,取决于他Module里实现的方式

四： MVP + Dagger2

这是现在主流的设计架构

MVP，这个我会在后面的文章介绍，这里不做太多解释

当你了解MVP 的时候，你就知道，所有的业务逻辑全在Presenter，

换句话， presenter 持有的对象，控制着你程序的全部逻辑，这在dagger 中，讲白了 我们只要将所有的presetner 对象控制就可以了

下面附上目录结构，当然仅仅作为参考。dagger 强大的用法还是需要各位自己去体会，下面的项目 是我刚刚学会dagger 时候 写的一个项目

可以看到 ，我是 将所有的activity 或者 fragment 全部添加在同一个Component中，当然现在的话 不推荐，比如Utils 你可以专门做一个Component，

首先放上我的Module，公司项目，很多东西没敢放上来，体谅，可以看到 我这里提供了一个SplashPresenter,也就是启动页的Presneter，业务逻辑

@Module
public class ApiModule {

 public ApiModule() {

 }

 @Provides
 @Singleton
 Handler provideHandler() {
 return new Handler();
 }

 @Provides
 @Singleton
 SQLiteDatabase provideSQLiteDatabase() {
 return new DataBaseHelper(MyApp.context, Config.SqlName, null, Config.SqlVersion).getWritableDatabase();
 }

 /**
 * @ User : Android架构
 * @ 创建日期 : 2017/7/13 下午3:24
 * @模块作用 ：
 * <p>
 * ====================================================================================================================================
 * ====================================================================================================================================
 */
 private SplashPresenter splashPresenter;

 public ApiModule(SplashAct splashAct) {
 splashPresenter = new SplashPresenter(splashAct, new SplashModel());
 }

 @Provides
 @Singleton
 SplashPresenter provideSplashPresenter() {
 return splashPresenter;
 }

 .....
}

当我使用的时候，只需要注入即可，如下代码

public class SplashAct extends BaseActivity implements SplashContract.View {

 @Inject
 SplashPresenter presenter;

 @Inject
 Handler handler;

 @Inject
 ApiService apiService;

 @Override
 protected void onCreate() {
 setContentView(R.layout.activity_splash);
 }

 @Override
 protected void initInject() {
 DaggerApiComponent.builder()
 .apiModule(new ApiModule(this))
 .build()
 .inject(this);
 }

 @Override
 protected void initListener() {
 presenter.getWordsInfo(true, apiService);
 }

 @Override
 public void gotoLogInAct() {
 handler.postDelayed(new Runnable() {
 @Override
 public void run() {
 startActivity(new Intent(SplashAct.this, LogInAct.class));
 finish();
 }
 }, 1500);
 }
}

原文地址：https://blog.51cto.com/14332859/2429542

时间： 2024-08-29 22:24:30

架构进阶，Dagger2的原理及使用详解的相关文章

Mysql主从数据库架构的复制原理及配置详解

1 复制概述 Mysql内建的复制功能是构建大型,高性能应用程序的基础.将Mysql的数据分布到多个系统上去,这种分布的机制,是通过将Mysql的某一台主机的数据复制到其它主机(slaves)上,并重新执行一遍来实现的.复制过程中一个服务器充当主服务器,而一个或多个其它服务器充当从服务器.主服务器将更新写入二进制日志文件,并维护文件的一个索引以跟踪日志循环.这些日志可以记录发送到从服务器的更新.当一个从服务器连接主服务器时,它通知主服务器从服务器在日志中读取的最后一次成功更新的位置.从服务器接收

Linux学习之路-DNS原理-BIND配置详解

DNS原理-BIND配置详解 DNS系统概述 DNS系统作用     a) DNS,简单地说,就是Domain Name System,翻成中文就是"域名系统".主要的功能就是将人易于记忆的Domain Name与人不容易记忆的IP Address作转换.      b) DNS提供正向解析和反向解析          正向解析:根据主机名称(域名)查找对应的IP地址.          反向解析:根据IP地址查找对应的主机域名 DNS系统结构  系统结构原理  目前DNS采用的是分布

ios中创建可以拖动的view原理和实现详解

有时候我们会需要在界面上拖动view;uiview是继承于uiresponder的,所以可以响应触摸相关的事件. 重点是以下一组方法: - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event - (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event - (void)touchesEnded:(NSSet *)touches withEvent:(UIE

ios中创建可以拖动的view原理和实现详解(含代码)

有时候我们会需要在界面上拖动view;uiview是继承于uiresponder的,所以可以响应触摸相关的事件. 重点是以下一组方法: - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event - (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event - (void)touchesEnded:(NSSet *)touches withEvent:(UIE

【Anroid进阶】SQLite数据库使用完全详解

在Android开发中,我们一般可以使用文件.sharedpreferences.以及数据库来保存我们程序运行中产生的数据,本篇主要讲解如何使用SQLite数据库,完成数据的增删改查的一般操作 SQLite介绍 SQLite 一个非常流行的嵌入式数据库,它支持 SQL 语言,并且只利用很少的内存就有很好的性能.此外它还是开源的,任何人都可以使用它. SQLite 和其他的主要 SQL 数据库没什么区别.它的优点就是高效,Android 运行时环境包含了完整的 SQLite. SQLite 和其他

DeepLearning tutorial（3）MLP多层感知机原理简介+代码详解

DeepLearning tutorial(3)MLP多层感知机原理简介+代码详解 @author:wepon @blog:http://blog.csdn.net/u012162613/article/details/43221829 本文介绍多层感知机算法,特别是详细解读其代码实现,基于python theano,代码来自:Multilayer Perceptron,如果你想详细了解多层感知机算法,可以参考:UFLDL教程,或者参考本文第一部分的算法简介. 经详细注释的代码:放在我的gith

DeepLearning tutorial（4）CNN卷积神经网络原理简介+代码详解

DeepLearning tutorial(4)CNN卷积神经网络原理简介+代码详解 @author:wepon @blog:http://blog.csdn.net/u012162613/article/details/43225445 本文介绍多层感知机算法,特别是详细解读其代码实现,基于python theano,代码来自:Convolutional Neural Networks (LeNet).经详细注释的代码和原始代码:放在我的github地址上,可下载. 一.CNN卷积神经网络原理

TCP/IP协议族——ARP、DNS工作原理及实例详解

 测试网络: 通过VMware创建了两个虚拟机,并利用桥接方式联网以此模拟两台主机连接一台路由器的情况.测试网络图如下: ARP协议工作原理 ARP协议能实现任意网络地址到任意物理地址的转换,这里仅讨论IP地址到以太网地址(MAC地址)的转换.其工作原理是:主机向自己所在网络广播一个ARP请求,该请求包含目标机器的网络地址.此网络上的其他机器都将接收到这个请求,但只有被请求的目标机器会回应一个ARP应答,其中包含自己的物理地址. 以太网ARP请求/应答报文 以太网ARP请求/应答报文格式如下

DeepLearning tutorial（1）Softmax回归原理简介+代码详解

DeepLearning tutorial(1)Softmax回归原理简介+代码详解 @author:wepon @blog:http://blog.csdn.net/u012162613/article/details/43157801 本文介绍Softmax回归算法,特别是详细解读其代码实现,基于python theano,代码来自:Classifying MNIST digits using Logistic Regression,参考UFLDL. 一.Softmax回归简介 关于算法的详