理解Dagger2在SystemUI中的使用

最近在修改systemUI时，发现大量使用了dagger2，如果不了解一下，system ui的代码就会难以理解。从网上转载一篇写的很好的关于Dagger2在system ui中使用的文章：SystemUI 与 Dagger2 框架

Dagger2 注解基础

结构

Dagger2 要实现一个完整的依赖注入，必不可少的元素有三种，Module，Component，Container。

Container 就是可以被注入的容器，Container 拥有需要被初始化的元素。需要被初始化的元素必须标上 @Inject，只有被标上 @Inject 的元素才会被自动初始化。被注解的构造方法会自动编译生成一个Factory工厂类提供该类对象。

Module 可以说就是依赖的原材料的制造工厂，所有需要被注入的元素的实现都是从 Module 生产并且封装起来，然后交给注入器 Component。

Component 相当于中间的运输员，将 Module 中产生的依赖对象自动注入到 Container 中。

一些常用的注解

@Inject

用 @Inject 注解标注目标类中依赖类的实例对象
用 @Inject 注解标注依赖类的构造函数
若其他类还依赖于另外的类，则重复进行上面2个步骤

@Component

所有的 Component 都必须以接口形式定义，使用 @Component 注解的接口一般直接命名为 XXXComponent
Dagger2 框架将自动生成该 Component 的实现类，对应的类名是 DaggerXXXComponent
添加注入方法，一般使用 inject 做为方法名，方法参数为对应的 Container，调用该方法进行注入，有参数的方法返回值类型是void
注入方法也可以没有输入参数，但是必须有返回值，返回的实例会先从事先定义的 Module 中查找，如果找不到，则会使用该类中带 @Inject 的构造方法来生成，同时也会递归注入构造方法的参数以及带 @Inject 的成员变量

@Module

Module 是一个简单的工厂类，添加注解 @Module 注明本类属于 Module
Module 里面的方法都是创建相应类实例的方法
在 Module 中添加注解 @Provides 注明该方法是用来提供依赖对象的特殊方法
注：一个 Component 可以包含多个 Module ，这样 Component 获取依赖时候会自动从多个 Module 中查找获取，Module 间不能有重复方法。添加多个 Module 有两种方法，一种是在 Component 的注解 @Component(modules={×××.class，×××.class}) 添加多个 modules，另外一种是在可以被使用的 Module 标签中的添加其他 modules： @Module(includes={×××.class，×××.class})

@Provides

通过 @Provides 标注该 Module 可以向外界提供的类的实例对象的方法
Module 中 @Provides 方法可以带输入参数，其参数由 Module 集合中的其他 @Provides 方法的返回值提供
如果2中找不到 @Provides 方法提供对应参数的对象，则其会自动查找参数类中带 @Inject 的无参构造生成对象

@Binds

使用 @Inject 初始化对象时如果需要初始化的是接口的实例，这时候就需要用到 @Binds
方法中必须有且只有一个参数，必须是接口的实现类
实现类必须提供 @Inject 的构造或 Module 中以 @Provides 形式提供
@Binds 相当于是在接口或者抽象类中代替 @Provides

@Named

@Named 是基于 String 的限定符
有两个相同的依赖（都继承某一个父类或者都实现某一个接口）可以提供，这个时候就需要用 @Named 来区分，使用方法为 @Named(“AAA”)，@Named(“BBB”)
拥有相同 @Named 的 @Inject 成员变量与 @Provides 方法才能被对应起来使用

扫描二维码关注公众号，回复： 15006221 查看本文章

@Qualifier

@Qualifier 用来注解接口作为自定义区分标志
使用此注解的接口 xxx.java 可以当做注解标签进行使用，@xxx

@Singleton与@Scope

顾名思义使用 @Singleton 是用来标注单例对象的
在 Component 里的方法添加 @Singleton，同时在 Module 对应的 @Provides 方法上也添加 @Singleton，这样一来每次注入的都会是同一个对象
@Scope 是注解的注解， Scope机制可以保证在 Scope 标记的 Component 作用域内 ，类会保持单例，@Singleton 是 @Scope 的一个默认实现

@Subcomponent

@Subcomponent 用于拓展原有 Component，它与 @Component(dependencies=XXComponent.classs) 类似
@Subcomponent 注解不会在编译后生成Dagger前缀的容器类，而是体现在父 Component 的私有内部类
Subcomponent 既拥有父 Component 拥有的 Scope，也拥有自己的 Scope
在父 Component 中显式添加添加返回 SubComponent 的方法后，继承关系才成立，SubComponent 能自动在父 Component 中查找缺失的依赖

注入方式

Provider与Lazy

Provider和Lazy都是用于包装Container中需要被注入的类型，Lazy用于延迟加载，Provide用于强制重新加载。
Provider保证每次重新加载，但是并不意味着每次返回的对象都是不同的，只有Module的Provide方法每次都创建新实例时，Provider每次get()的对象才不相同。
Lazy != Singleton，如果有两个不同的Lazy对象，那么他们get()的对象也是不同的。

示例：

  @Module
    final class CounterModule {
    
    
        int next = 100;

        @Provides
        Integer provideInteger() {
    
    
            System.out.println("computing...");
            return next++;
        }
    }

    // Provider 注入
    final class ProviderCounter {
    
    
        @Inject Provider<Integer> provider;
        void print() {
    
    
            System.out.println("printing...");
            System.out.println(provider.get());
            System.out.println(provider.get());
            System.out.println(provider.get());
    }
    /**    
     *    打印结果：
     *     printing...
     *     computing...
     *     100
     *     computing...
     *     101
     *     computing...
     *     102
     */

    // Lazy 注入
    final class LazyCounter {
    
    
        @Inject Lazy<Integer> Lazy;
        void print() {
    
    
            System.out.println("printing...");
            System.out.println(Lazy.get());
            System.out.println(Lazy.get());
            System.out.println(Lazy.get());
    }
    /**    
     *    打印结果：
     *     printing...
     *     computing...
     *     100
     *     100
     *     100
     */

Dagger2 导航

Android Studio 针对 Dagger2 的导航进行了支持，方便开发者快速回溯依赖关系。

点击向上的箭头可以查看该实例注入的提供方
点击向下的树形图会转到或展开该实例被用作依赖项的位置或列表

Dagger2 在 SystemUI 里的应用

SystemUI里面大量的模块都使用了此注入方式，比如StatusBar，QS，Keyguard等。
下面以 Android 11 源码的SystemUI来详细说明。

定义清单列表

SystemUI的application标签定义了一个appComponentFactory属性

<application
    android:name=".SystemUIApplication"
    ...
    tools:replace="android:appComponentFactory"
    android:appComponentFactory=".SystemUIAppComponentFactory">

    ...

    <service ...
    />

    <activity ...
    />

    <reveiver ...
    />

    ...

</application>

这个属性是用来控制manifest清单文件里的组件的初始化，在manifest清单文件里的组件构建对象时会调用下面这些方法。

启动Application

随着SystemServer发出启动SystemUIService的请求，SystemUI的Application将首先被实例化。在实例化之前，指定的AppComponentFactory实现类将会收到回调。

1.调用super得到Application实例之后向其注册Context准备完毕的回调，该回调会执行SystemUIFactory和各组件的初始化：

public class SystemUIAppComponentFactory extends AppComponentFactory {
    
    
    @Inject
    public ContextComponentHelper mComponentHelper;
    ...
    @Override
    public Application instantiateApplicationCompat(
            @NonNull ClassLoader cl, @NonNull String className)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    
    
        Application app = super.instantiateApplicationCompat(cl, className);
        if (app instanceof ContextInitializer) {
    
    
            // 注册Context成功取得的回调
            ((ContextInitializer) app).setContextAvailableCallback(
                    context -> {
    
    
                        SystemUIFactory.createFromConfig(context);
                        // 注入SystemUIAppComponentFactory对象
                        SystemUIFactory.getInstance().getRootComponent().inject(
                                SystemUIAppComponentFactory.this);
                    }
            );
        }

        return app;
    }
    ...
}

2.在SystemUIApplication onCreate时执行上述回调, 构建SystemUIFactory，并对它进行初始化：

public class SystemUIApplication extends Application implements
        SystemUIAppComponentFactory.ContextInitializer {
    
    
    ...
    @Override
    public void setContextAvailableCallback(
            SystemUIAppComponentFactory.ContextAvailableCallback callback) {
    
    
        mContextAvailableCallback = callback;
    }

    @Override
    public void onCreate() {
    
    
        ...
        // 执行回调
        mContextAvailableCallback.onContextAvailable(this);
        // 获取 SystemUIRootComponent，很多组件都是通过它注入的
        mRootComponent = SystemUIFactory.getInstance().getRootComponent();
        // 通过 SystemUIRootComponent 定义的注入方法获得 ContextComponentHelper 对象
        mComponentHelper = mRootComponent.getContextComponentHelper();
        ...
    }
}

3.创建SystemUIFactory实例，并初始化SystemUI 的Dagger组件，并向Dependency实例注入依赖：

public class SystemUIFactory {
    
    
    ...
    public static void createFromConfig(Context context) {
    
    
        ...
        try {
    
    
            Class<?> cls = null;
            cls = context.getClassLoader().loadClass(clsName);
            // 创建SystemUIFactory实例
            mFactory = (SystemUIFactory) cls.newInstance();
            // 初始化SystemUIFactory
            mFactory.init(context);
        }
    }

    private void init(Context context) {
    
    
        // 取得SystemUI的Dagger组件实例
        mRootComponent = buildSystemUIRootComponent(context);
        // 创建Dependency实例
        Dependency dependency = new Dependency();
        // 将Dependency绑定到子组件DependencyInjector中，这里会通过Component将各类依赖注入Dependency
        mRootComponent.createDependency().createSystemUI(dependency);
        // 初始化Dependency
        dependency.start();
    }

    // 初始化Dagger组件
    protected SystemUIRootComponent buildSystemUIRootComponent(Context context) {
    
    
        return DaggerSystemUIRootComponent.builder() 
                .dependencyProvider(new DependencyProvider())
                .contextHolder(new ContextHolder(context))
                .build();
    }
    ...
}

4.Dependency里掌管着各式各样的依赖，被依赖的各实例通过Map管理。每个依赖都通过LazyDependencyCreator将各实例对应的懒加载回调缓存进去，然后保存在Map mProviders里。其后在各实例真正使用时调用createDependency() 进行创建：

public class Dependency {
    
    
    // 使用class作为key将对应实例缓存
    private final ArrayMap<Object, Object> mDependencies = new ArrayMap<>();
    // 同样的class的key缓存实例的懒加载回调
    private final ArrayMap<Object, LazyDependencyCreator> mProviders = new ArrayMap<>();

    protected void start() {
    
    
        // 构建LazyDependencyCreator放入mProviders，回调取得对应实例
        mProviders.put(TIME_TICK_HANDLER, mTimeTickHandler::get);
        mProviders.put(BG_LOOPER, mBgLooper::get);
        mProviders.put(MAIN_LOOPER, mMainLooper::get);
        mProviders.put(MAIN_HANDLER, mMainHandler::get);
        mProviders.put(ActivityStarter.class, mActivityStarter::get);
        mProviders.put(BroadcastDispatcher.class, mBroadcastDispatcher::get);
        ...
    }

    // 根据class查询 mDependencies里的缓存
    private synchronized <T> T getDependencyInner(Object key) {
    
    
        T obj = (T) mDependencies.get(key);
        if (obj == null) {
    
    
            // 尚未缓存的话通过懒加载回调获取注入的实例并缓存进 mDependencies
            obj = createDependency(key);
            mDependencies.put(key, obj);
            if (autoRegisterModulesForDump() && obj instanceof Dumpable) {
    
    
                mDumpManager.registerDumpable(obj.getClass().getName(), (Dumpable) obj);
            }
        }
        return obj;
    }

    // 根据class查询 mProviders里的懒加载回调
    protected <T> T createDependency(Object cls) {
    
    
        Preconditions.checkArgument(cls instanceof DependencyKey<?> || cls instanceof Class<?>);
        LazyDependencyCreator<T> provider = mProviders.get(cls);
        if (provider == null) {
    
    
            throw new IllegalArgumentException("Unsupported dependency " + cls
                    + ". " + mProviders.size() + " providers known.");
        }
        // 里面的回调实现已经通过start()里的mProviders.put存入了，实际调用的就是各类Lazy.get()
        return provider.createDependency();
    }

    private interface LazyDependencyCreator<T> {
    
    
        // 封装好的回调
        T createDependency();
    }
}

启动SystemUIService

创建好Application后，会启动SystemUIService这个主Service，然后逐个启动其他组件。

public class SystemUIService extends Service {
    
    
    ...
    @Override
    public void onCreate() {
    
    
        super.onCreate();

        // Start all of SystemUI
        ((SystemUIApplication) getApplication()).startServicesIfNeeded();
        ...
    }
    ...
}

启动各类服务组件

回到 SystemUIApplication

public class SystemUIApplication {
    
    
    ...
    public void startServicesIfNeeded() {
    
    
        // 各services定义在 R.array.config_systemUIServiceComponents 里面
        String[] names = SystemUIFactory.getInstance().getSystemUIServiceComponents(getResources());
        startServicesIfNeeded(/* metricsPrefix= */ "StartServices", names);
    }

    private void startServicesIfNeeded(String metricsPrefix, String[] services) {
    
    
        ...
        final int N = services.length;
        for (int i = 0; i < N; i++) {
    
    
            String clsName = services[i];
            ...
            try {
    
    
                // 通过class name从ContextComponentHelper中获取对应组件的实例
                SystemUI obj = mComponentHelper.resolveSystemUI(clsName);
                if (obj == null) {
    
    
                    Constructor constructor = Class.forName(clsName).getConstructor(Context.class);
                    obj = (SystemUI) constructor.newInstance(this);
                }
                mServices[i] = obj;
            } catch (ClassNotFoundException
                    | NoSuchMethodException
                    | IllegalAccessException
                    | InstantiationException
                    | InvocationTargetException ex) {
    
    
                throw new RuntimeException(ex);
            }

            if (DEBUG) Log.d(TAG, "running: " + mServices[i]);
            // 调用各组件实现的start()方法
            mServices[i].start();
            ...
        }
        ...
    }
}

其中 mComponentHelper 在上一节中有提到，下面讲解一下它的注入过程。
在 SystemUIRootComponent 中定义了 ContextComponentHelper 单例对象的获取方法，

@Singleton
@Component(modules = {
    
    
        ...
        SystemUIModule.class,
        SystemUIDefaultModule.class})
public interface SystemUIRootComponent {
    
    
    ...
    @Singleton
    ContextComponentHelper getContextComponentHelper();
    ...
}

上文dagger2注解基础里有提到，无参有返回值的方法，实例从定义的Module中查找，这里在 SystemUIModule 里可以找到，实际注入的是 ContextComponentResolver 对象，它是 ContextComponentHelper 的实现类：

@Module(includes = {
    
    
            ...
        },
        subcomponents = {
    
    StatusBarComponent.class,
                NotificationRowComponent.class,
                ExpandableNotificationRowComponent.class})
public abstract class SystemUIModule {
    
    
    ...
    @Binds
    public abstract ContextComponentHelper bindComponentHelper(
            ContextComponentResolver componentHelper);
    ...
}

由于该方法标了abstract并没有进行实现，所以实例对象会通过 ContextComponentResolver 里面带 @Inject 标签的构造方法来生成。

@Singleton
public class ContextComponentResolver implements ContextComponentHelper {
    
    
    private final Map<Class<?>, Provider<Activity>> mActivityCreators;
    private final Map<Class<?>, Provider<Service>> mServiceCreators;
    private final Map<Class<?>, Provider<SystemUI>> mSystemUICreators;
    private final Map<Class<?>, Provider<RecentsImplementation>> mRecentsCreators;
    private final Map<Class<?>, Provider<BroadcastReceiver>> mBroadcastReceiverCreators;

    @Inject
    ContextComponentResolver(Map<Class<?>, Provider<Activity>> activityCreators,
            Map<Class<?>, Provider<Service>> serviceCreators,
            Map<Class<?>, Provider<SystemUI>> systemUICreators,
            Map<Class<?>, Provider<RecentsImplementation>> recentsCreators,
            Map<Class<?>, Provider<BroadcastReceiver>> broadcastReceiverCreators) {
    
    
        mActivityCreators = activityCreators;
        mServiceCreators = serviceCreators;
        mSystemUICreators = systemUICreators;
        mRecentsCreators = recentsCreators;
        mBroadcastReceiverCreators = broadcastReceiverCreators;
    }
    ...

    /**
     * Looks up the SystemUI class name to see if Dagger has an instance of it.
     */
    @Override
    public SystemUI resolveSystemUI(String className) {
    
    
        return resolve(className, mSystemUICreators);
    }

    private <T> T resolve(String className, Map<Class<?>, Provider<T>> creators) {
    
    
        try {
    
    
            Class<?> clazz = Class.forName(className);
            Provider<T> provider = creators.get(clazz);
            return provider == null ? null : provider.get();
        } catch (ClassNotFoundException e) {
    
    
            return null;
        }
    }
}

这里的构造方法由于带了 @Inject，所以它的参数Map都会一起注入进去，那这些Map又是哪里来的呢，这里提一下dagger2的 MultiBindings。

首先在 Module 中多次定义一系列返回值类型相同的方法，这里以 SystemUIBinder 为例，如果需要的类型是Map，那么就使用 @IntoMap 和 对应key的 @MapKey 的实现 @ClassKey，@IntoMap 表示这些方法的返回值对象都要装入同一个Map集合中，@ClassKey 表示Map的key为class。
然后还必须加上 @Provides 标签，如果是接口或抽象类则用 @Binds。这样声明下来，dagger2 会自动为其注入 Map<Class<?>, Provider>，即把上面的 systemUICreators 给注入进去了。

/**
 * SystemUI objects that are injectable should go here.
 */
@Module(includes = {
    
    RecentsModule.class, StatusBarModule.class, BubbleModule.class,
        KeyguardModule.class})
public abstract class SystemUIBinder {
    
    
    /** Inject into AuthController. */
    @Binds
    @IntoMap
    @ClassKey(AuthController.class)
    public abstract SystemUI bindAuthController(AuthController service);

    /** Inject into Divider. */
    @Binds
    @IntoMap
    @ClassKey(Divider.class)
    public abstract SystemUI bindDivider(Divider sysui);
    ...

    /** Inject into StatusBar. */
    @Binds
    @IntoMap
    @ClassKey(StatusBar.class)
    public abstract SystemUI bindsStatusBar(StatusBar sysui);
    ...
}

以 bindsStatusBar 为例，参数 StatusBar 的实例又是由 StatusBarPhoneModule 提供的

/**
 * Dagger Module providing {@link StatusBar}.
 */
@Module(includes = {
    
    StatusBarPhoneDependenciesModule.class})
public interface StatusBarPhoneModule {
    
    
    /**
     * Provides our instance of StatusBar which is considered optional.
     */
    @Provides
    @Singleton
    static StatusBar provideStatusBar(
            Context context,
            NotificationsController notificationsController,
            LightBarController lightBarController,
            AutoHideController autoHideController,
            KeyguardUpdateMonitor keyguardUpdateMonitor,
            StatusBarIconController statusBarIconController,
            ...) {
    
    
        return new StatusBar(
                context,
                notificationsController,
                lightBarController,
                autoHideController,
                keyguardUpdateMonitor,
                statusBarIconController,
                ...);
    }
}

new StatusBar 对象所用到的参数，有些是通过内部自身带 @Inject 标签的构造方法注入，有些则是又再通过其他 Module 提供，这里就不再往下继续跟踪了。

到此，config_systemUIServiceComponents 里面定义的组件的实例对象注入过程就结束了。

总结

由于 SystemUI 模块内大部分结构都已经用上了 Dagger2 框架，本文旨在通过对 Dagger2 框架进行一些基础概念的总结，结合 SystemUI 部分的源码来了解其工作原理，这样在后续解读代码以及添加需求功能的时候可以用上。

作者：Soetsu
链接：https://www.jianshu.com/p/4b3651ea85a9
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。