Android |《看完不忘系列》之dagger

嗨，我是哈利迪~《看完不忘系列》将以从树干到细枝的思路分析一些技术框架，本文将对开源项目dagger进行介绍。

本文约3800字，阅读大约10分钟。

Dagger源码基于最新版本2.28.3

背景

依赖注入（Dependency Injection，DI）遵循控制反转（Inversion of Control，IoC）原则，简单来说就是创建对象时给对象传入依赖，通过传入不同实例来实现不同行为（控制），比如常见的构造方法和setter都叫注入。

简单概括一下谷歌的造车栗子，

一、不注入，由Car类自己创建依赖的Engine实例，当需要替换汽车引擎时，需要修改Car类，违背了开放封闭原则，

class Car {
    private Engine engine = new Engine();
}

二、手动依赖注入，如构造方法和setter，当需要替换汽车引擎时，传入不同的引擎实现（如ElectricEngine extends Engine）即可，无需修改Car类，

//1.构造方法注入
class Car {
    private final Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }
}

//2.setter注入
class Car {
    private Engine engine;

    public void setEngine(Engine engine) {
        this.engine = engine;
    }
}

三、随着汽车配件变多，依赖注入的代码也会越来越多，如汽车需要引擎、轮胎，引擎又需要气缸和火花塞，这样一层层下去注入代码成指数级上升，出现了大量创建对象的样板代码，

class Car {
    private final Engine engine;//引擎
    private final Wheel wheel;//轮胎

    public Car(Engine engine,Wheel wheel) {
        this.engine = engine;
        this.wheel = wheel;
    }
}

class Engine {
    private final Cylinder cylinder;//气缸
    private final SparkPlug sparkPlug;//火花塞

    public Car(Cylinder cylinder,SparkPlug sparkPlug) {
        this.cylinder = cylinder;
        this.sparkPlug = sparkPlug;
    }
}

void main(){
    //为了造辆车，要new出一堆对象，还要构造方法注入，套娃既视感
    Cylinder cylinder = new Cylinder();
    SparkPlug sparkPlug = new SparkPlug();
    Engine engine = new Engine(cylinder,sparkPlug);
    Wheel wheel = new Wheel();
    Car car = new Car(engine,wheel);
}

从代码可以看出有两大痛点，一是要创建很多对象，二是对象的创建过程还需有序，即要先有气缸和火花塞才能造引擎，先有引擎和轮胎才能造车，这样使用方还需花时间了解配件间的依赖关系，很是不便。

于是就有了一些库来实现自动依赖注入，有两个实现思路（koin的实现以后再聊~），

  1. 一是运行期反射连接依赖项，编译影响小，但运行慢
  2. 二是编译期就连接依赖项，创建辅助类需要额外的io和编译耗时，会拖慢编译速度，但运行快

像Android内存和算力都有限的终端设备，dagger当然是选择思路2啦。dagger通过注解标记对象创建姿势、依赖关系、作用域等信息，在编译期创建辅助类，从而实现自动依赖注入。不过dagger的上手成本略高，谷歌后来又推出了Hilt，旨在让我们用得舒心，

Hilt 是推荐用于在 Android 中实现依赖项注入的 Jetpack 库。Hilt 通过为项目中的每个 Android 类提供容器并自动为您管理其生命周期，定义了一种在应用中执行 DI 的标准方法。

Hilt 在热门 DI 库 Dagger 的基础上构建而成，因而能够受益于 Dagger 提供的编译时正确性、运行时性能、可伸缩性和 Android Studio 支持。

-- 谷歌

Hilt就先放一放，下面我们先开始dagger之旅吧~

补：关于手动注入的痛点，可以看下谷歌的手动依赖项注入（看完或许能更好的理解dagger的设计）。

树干

简单使用

依赖，

implementation 'com.google.dagger:dagger:2.28.3'
annotationProcessor 'com.google.dagger:dagger-compiler:2.28.3'

@Inject和@Component

@Inject标记实例的创建姿势，汽车和引擎类，

class Car {
    private final Engine mEngine;

    @Inject //告诉dagger如何创建Car
    public Car(Engine engine) {
        mEngine = engine;
    }

    public void start() {
        mEngine.start();
    }
}

class Engine {
    @Inject //告诉dagger如何创建Engine
    public Engine() {
    }

    public void start() {
        Log.e("哈利迪", "引擎发动，前往秋名山");
    }
}

这样dagger就能生成类似 new Car(new Engine()) 的代码来创建实例，

@Component标记所要创建的实例有哪些，如在造车图纸（接口）里声明要造车，

@Component //告诉dagger要造啥
interface CarGraph {
    //造车
    Car makeCar();
}

make一下项目，生成Car_Factory、Engine_Factory和DaggerCarGraph三个类，在Activity中使用，

class DaggerActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_dagger);
        //得到造车图纸
        CarGraph carGraph = DaggerCarGraph.create();
        //造出一辆汽车
        Car car = carGraph.makeCar();
        //引擎发动
        car.start();
    }
}

注入姿势二，还可以直接把汽车注入给Activity，

@Component //告诉dagger要造啥
public interface CarGraph {
    //造车
    Car makeCar();

    //新增：告诉dagger有个Activity要注入
    void inject(DaggerActivity activity);
}

make一下，这时会多出一个类DaggerActivity_MembersInjector（成员注入器），我们后面再看，在Activity中，

class DaggerActivity extends AppCompatActivity {
    //向Activity注入汽车
    @Inject
    Car mCar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_dagger);
        //得到造车图纸
        CarGraph carGraph = DaggerCarGraph.create();
        //告诉dagger有个Activity要注入
        carGraph.inject(this);
        //此时，mCar已被dagger自动赋值，我们可以直接发动引擎
        mCar.start();
    }
}

不管是哪种姿势，都可以看出，Activity只管提车，无需关心造车内部的细节（用了什么引擎），这样以后要换引擎了，Activity和Car也不用改动代码。

@Module和@Binds

那么问题来了，通常我们都是面向接口编程，现在想把Engine换成IEngine接口咋整呢？因为我有两种引擎，分别是汽油车的GasEngine，和电动车的ElectricEngine，接口没有构造方法怎么注入？此时@Module和@Binds注解就派上用场了。

定义引擎接口和实现类，

interface IEngine {
    public void start();
}

class GasEngine implements IEngine {//汽油引擎
    @Inject
    public GasEngine() {
    }

    @Override
    public void start() {
        Log.e("哈利迪", "汽油 引擎发动，前往秋名山");
    }
}

class ElectricEngine implements IEngine {//电动引擎
    @Inject
    public ElectricEngine() {
    }

    @Override
    public void start() {
        Log.e("哈利迪", "电动 引擎发动，前往秋名山");
    }
}

然后Car我们不要了，新写一个汽车类NewCar，让他依赖于接口IEngine而非类，

class NewCar {
    //依赖于接口
    private final IEngine mEngine;

    @Inject //告诉dagger如何创建NewCar
    public NewCar(IEngine engine) {
        mEngine = engine;
    }

    public void start() {
        mEngine.start();
    }
}

下面有请@Module和@Binds登场！建一个抽象类GasEngineModule，表示汽油引擎模块，用于提供汽油引擎，

@Module
abstract class GasEngineModule {//汽油引擎模块
    @Binds
    abstract IEngine makeGasEngine(GasEngine engine);
}

然后在造车图纸CarGraph里支持一下NewCar的创建，把Module引入Component，

@Component(modules = {GasEngineModule.class})
//引入汽油引擎模块
public interface CarGraph {
    //...

    //造新车
    NewCar makeNewCar();
}

Activity使用，

//DaggerActivity.java
void onCreate(Bundle savedInstanceState) {
    CarGraph carGraph = DaggerCarGraph.create();
    NewCar newCar = carGraph.makeNewCar();
    newCar.start();
}

搞定~

这时如果想要把NewCar换成电动引擎，直接依赖新的模块即可，新增模块ElectricEngineModule，用于提供电动引擎，

@Module
public abstract class ElectricEngineModule {//电动引擎模块
    @Binds
    abstract IEngine makeElectricEngine(ElectricEngine engine);
}

GasEngineModule模块换成ElectricEngineModule，

@Component(modules = {ElectricEngineModule.class})//替换
public interface CarGraph {
    //...
}

运行就能得到电动车了，可见这个过程我们不需要修改NewCar就能换掉引擎（偷梁换柱）。

@IntoMap和@StringKey

又有一天，突然想开双混动汽车了咋整，就是说汽油引擎和电动引擎我全都要，我们发现@Component的modules可以传入数组，那试试把两个引擎模块都传进去，

@Component(modules = {GasEngineModule.class, ElectricEngineModule.class})
public interface CarGraph {
    //...
}

make一下，不用想也知道会出错，NewCar只有一个依赖IEngine接口，这时dagger已经不知道，造NewCar到底要传入哪个引擎了，

那怎么办？支持多绑定的@IntoMap和@StringKey登场了。

IntoMap表示会把这个Module存进map里，StringKey表示Module名字，这个名字也会作为map的key，

@Module
abstract class GasEngineModule {//汽油引擎模块
    @Binds
    @IntoMap
    @StringKey("Gas")
    abstract IEngine makeGasEngine(GasEngine engine);
}

@Module
abstract class ElectricEngineModule {//电动引擎模块
    @Binds
    @IntoMap
    @StringKey("Electric")
    abstract IEngine makeElectricEngine(ElectricEngine engine);
}

然后修改一下NewCar，此时不再只是依赖一个引擎接口IEngine了，而是一组引擎，

class NewCar {
    //我现在是混动车了，要用map接收引擎
    private final Map<String, IEngine> mEngineMap;

    @Inject //告诉dagger如何创建NewCar
    public NewCar(Map<String, IEngine> engineMap) {
        mEngineMap = engineMap;
    }

    public void start() {
        //双混动走起~
        for (Map.Entry<String, IEngine> entry : mEngineMap.entrySet()) {
            entry.getValue().start();
            //汽油 引擎发动，前往秋名山
            //电动 引擎发动，前往秋名山
        }
    }
}

Activity代码不用改动，双混动车就造好了。

@Singleton

如果想要给双混动NewCar限量全球一款，可以用@Singleton指定为单例，

@Singleton //单例，我现在是限量款混动车
public class NewCar {
    //...
}

@Singleton //造车图纸也需跟着单例
@Component(modules = {GasEngineModule.class, ElectricEngineModule.class})
public interface CarGraph {
    //...
}

Activity运行，

//DaggerActivity.java
void onCreate(Bundle savedInstanceState) {
    CarGraph carGraph = DaggerCarGraph.create();
    NewCar newCar = carGraph.makeNewCar();
    newCar.start();
    NewCar newCar2 = carGraph.makeNewCar();
    newCar2.start();
    //newCar和newCar2是同一个实例
    Log.e("哈利迪", newCar.hashCode() + "," + newCar2.hashCode());
}

dagger的使用就先聊到这啦，相信对dagger也已经有了初步认识，还有些注解没讲到，比如：

@Provides：当我们没法用@Inject来标记实例的创建姿势时，可以用@Module和@Provides来提供实例，比如Retrofit是三方库的类我们没法标记其构造方法，则可以用Provides提供，

@Module
public class NetworkModule {
    @Provides
    public Retrofit provideRetrofit() {
        return new Retrofit.Builder()
            .baseUrl("xxx")
            .build();
    }
}

@Scope：作用域 ...

@Subcomponent：子组件...

注解还有很多，准备放到细枝篇来写了...🤣

实现原理

dagger编译期解析注解创建辅助类的过程就不分析了，我们直接看他生成的辅助类，

注：一开始写接口名字时，用造车图纸CarGraph而不是造车厂CarFactory，是为了避免和dagger的生成类搞混，用CarGraph有几何图的寓意，可以理解成造车蓝图（PPT），让我们一起，为梦想窒息...

我们看到DaggerCarGraph，他实现了我们的CarGraph接口，

class DaggerCarGraph implements CarGraph {
    //Provider，提供多引擎map，<引擎名字、引擎实例>
    private Provider<Map<String, IEngine>> mapOfStringAndIEngineProvider;
    //Provider，提供NewCar
    private Provider<NewCar> newCarProvider;

    private DaggerCarGraph() {
        initialize();
    }

    public static Builder builder() {
        return new Builder();
    }

    public static CarGraph create() {
        //用builder创建DaggerCarGraph实例
        return new Builder().build();
    }

    private void initialize() {
        //创建提供汽油引擎的Provider和电动引擎的Provider
        //用put将他们存起来，合并成一个提供多引擎map的Provider
        this.mapOfStringAndIEngineProvider = MapFactory.<String, IEngine>builder(2)
            .put("Gas", (Provider) GasEngine_Factory.create())
            .put("Electric", (Provider) ElectricEngine_Factory.create())
            .build();
        //把提供多引擎map的Provider传入NewCar_Factory，
        //然后用DoubleCheck包一层，他会加锁、处理单例逻辑
        this.newCarProvider = DoubleCheck.provider(
            NewCar_Factory.create(mapOfStringAndIEngineProvider));
    }

    @Override
    public Car makeCar() {
        //1. 老的造车：姿势一，用makeCar直接造
        return new Car(new Engine());
    }

    @Override
    public void inject(DaggerActivity activity) {
        //2. 老的造车：姿势二，用@Inject注入 ↓
        injectDaggerActivity(activity);
    }

    private DaggerActivity injectDaggerActivity(DaggerActivity instance) {
        //2. 老的造车：姿势二，先创建后注入
        //实例的创建也用makeCar，如果我们接口没有定义这个方法，dagger会生成一个功能一样的getCar
        DaggerActivity_MembersInjector.injectMCar(instance, makeCar());
        return instance;
    }

    @Override
    public NewCar makeNewCar() {
        //3. 新的造车，从Provider获取
        return newCarProvider.get();
    }

    public static final class Builder {
        private Builder() {
        }
        public CarGraph build() {
            return new DaggerCarGraph();
        }
    }
}
  1. 老的造车：姿势一，用makeCar直接造

在造老车Car时，姿势一是直接调接口的makeCar方法来造，实现就是简单的new出实例。

  1. 老的造车：姿势二，用@Inject注入

姿势二用@Inject注入实例，可见他也是先调makeCar()得到实例，然后调DaggerActivity_MembersInjector.injectMCar进行注入，

//DaggerActivity_MembersInjector.java
@InjectedFieldSignature("com.holiday.srccodestudy.dagger.DaggerActivity.mCar")
public static void injectMCar(DaggerActivity instance, Car mCar) {
    //引用DaggerActivity的成员，为其赋值，可见mCar不能声明为private
    instance.mCar = mCar;
}
  1. 新的造车，从Provider获取

在造新车NewCar时，是从Provider获取的，跟进newCarProvider.get()，如果使用了单例@Singleton，NewCar_Factory会被DoubleCheck包一层，DoubleCheck会加锁和处理单例逻辑，我们直接看NewCar_Factory的get就行了，

//Factory<T> extends Provider<T>
class NewCar_Factory implements Factory<NewCar> {
    private final Provider<Map<String, IEngine>> engineMapProvider;

    public NewCar_Factory(Provider<Map<String, IEngine>> engineMapProvider) {
        this.engineMapProvider = engineMapProvider;
    }

    @Override
    public NewCar get() {
        //通过engineMapProvider获取多引擎map
        return newInstance(engineMapProvider.get());
    }

    public static NewCar_Factory create(Provider<Map<String, IEngine>> engineMapProvider) {
        return new NewCar_Factory(engineMapProvider);
    }

    public static NewCar newInstance(Map<String, IEngine> engineMap) {
        //new出新车实例
        return new NewCar(engineMap);
    }
}

看下多引擎map又是如何获取的，engineMapProvider.get()，

//MapFactory.java
//MapFactory extends AbstractMapFactory implements Factory
public Map<K, V> get() {
    //创建新的LinkedHashMap
    Map<K, V> result = newLinkedHashMapWithExpectedSize(contributingMap().size());
    //遍历已存入的引擎，存进新map
    for (Entry<K, Provider<V>> entry : contributingMap().entrySet()) {
        result.put(entry.getKey(), entry.getValue().get());
    }
    //返回不可修改的map
    return unmodifiableMap(result);
}

至此，dagger的各生产线流程就分析完了，

细枝

@Scope作用域、@Subcomponent子组件、还有SPI（Service Provider Interface）、grpc（谷歌的远程过程调用框架）等，都留到细枝篇来写啦。

使用场景

那dagger在Android中有哪些用武之地？首先是从架构角度，在谷歌示例中，结合了Activity、伪ViewModel、Repository、DataSource和Retrofit来使用dagger，（还没用过，不知道香不香、坑多不多，靠屏幕前的大佬们反馈了~）

然后我们在项目中的一些场景，是从业务角度切入，在个别复杂度较高的业务线上单独使用dagger。例如钱包业务，有大量实例和大量页面/视图存在多对多关系，比如钱包Act需要钱包Api、钱包用户信息Manager；充值Act需要支付Api、充值Service；银行卡列表View需要银行Service...像这种多对多、对象依赖关系杂乱无章的场景，很适合用dagger来帮我们注入。

@PurseScope //钱包作用域
@Component(modules = PurseModule.class) //由PurseModule提供实例
public interface PurseComponent {

    //为act注入
    void inject(退款详情Act xxxAct);
    void inject(银行卡首页Act xxxAct);
    void inject(钱包首页Act xxxAct);
    void inject(钱包设置Act xxxAct);
    void inject(余额首页Act xxxAct);
    //...

    //为view注入
    void inject(钱包首页GridContainer xxxGridContainer);
    void inject(银行卡列表View xxxView);

    //提供网络调用
    支付Api xxxApi();

    //提供钱包用户信息
    钱包用户信息Manager xxxManager();

    //...
}

然后看到PurseModule，用于提供各种实例，可以new、手动单例、工厂生产...

@Module
public class PurseModule {
    @Provides
    @PurseScope
    public 支付Api provide支付Api(...) {
        return new 支付Api(...);
    }

    @Provides
    @PurseScope
    public 用户信息Manager provide用户信息Manager(...) {
        return 用户信息Manager.get(...);
    }

    @Provides
    @PurseScope
    public 充值Service provide充值Service(...) {
        return new 充值ServiceFactory.create(...);
    }

    //...
}

尾声

简单总结下dagger的优缺点~

  • 优势：无反射、支持增量编译
  • 缺点：构建过程需要而外的io和编译时间、生成类会增大包体积、不够好用、

后续计划：dagger细枝、hilt、koin、顺便看看spring上的注入@Autowired是怎么做的...学海无涯啊~

系列文章：

参考资料

欢迎关注原创技术公众号：哈利迪ei

全部评论

相关推荐

不愿透露姓名的神秘牛友
11-27 10:48
点赞 评论 收藏
分享
昨天 23:28
门头沟学院 Java
点赞 评论 收藏
分享
10-23 23:38
长江大学 运维工程师
能改吗？
没看清楚就点了确定😥😥，刚好那天有事
牛客5655：其他公司的面试（事）吗
点赞 评论 收藏
分享
11-14 16:13
已编辑
重庆科技大学 测试工程师
双非二本
求建议
Amazarashi66：不进帖子我都知道🐮❤️网什么含金量
点赞 评论 收藏
分享
11-28 09:24
影石Insta360_深度学习算法工程师(准入职员工)
影石内推影石面经
自我介绍（3min左右）看你最近的工作是和bootloader相关的，汽车后视镜相关的，从7.8到3.6s的改进是比较显著的，那你有没有比较以前的不同的机制主要耗时在哪几个地方我看你一直在写x86平台的操作系统，基本是从基础到操作系统的构建工作，这中间持续开发的过程中有没有不太好理解，或者阻塞的事情呢这个启动加载器，比如从bios启动那部分是怎么完成的，或者说bootloader部分你做了什么呢，平台是什么呢（最开始我是在bochs上完成的）你现在是在x86下完成的，有没有考虑过arm呢，因为armv8也是64位，有没有想过去做二者的比较呢（过程中提到了看过电源管理的源码），你看的电源管理是在...
点赞 评论 收藏
分享
评论
点赞
收藏
分享

全站热榜

正在热议
# 拼多多求职进展汇总 #
240808次浏览 2051人参与
# 实习，投递多份简历没人回复怎么办 #
2448202次浏览 34802人参与
# 北方华创开奖 #
68053次浏览 558人参与
# 25届秋招总结 #
426228次浏览 4306人参与
# 虾皮求职进展汇总 #
100865次浏览 810人参与
# 地方国企笔面经互助 #
7418次浏览 18人参与
# 阿里云管培生offer #
65627次浏览 1768人参与
# ai智能作图 #
35780次浏览 436人参与
# 中兴求职进展汇总 #
471246次浏览 2453人参与
# 我在牛爱网找对象 #
75246次浏览 556人参与
# 双非有机会进大厂吗 #
106262次浏览 1334人参与
# 实习想申请秋招offer，能不能argue薪资 #
38075次浏览 313人参与
# 机械求职避坑tips #
24238次浏览 252人参与
# 发工资后，你做的第一件事是什么 #
10800次浏览 53人参与
# 25届机械人为了秋招做了哪些准备？ #
26825次浏览 366人参与
# 投格力的你，拿到offer了吗？ #
47929次浏览 337人参与
# 我的实习求职记录 #
6146286次浏览 84090人参与
# 投递实习岗位前的准备 #
1193942次浏览 18511人参与
# 机械人怎么评价今年的华为 #
158504次浏览 1354人参与
# 在职场上，你最讨厌什么样的同事 #
6494次浏览 98人参与
# 实习与准备秋招该如何平衡 #
726163次浏览 8569人参与
# 华为工作体验 #
112537次浏览 871人参与
牛客网
牛客企业服务