Android Jetpack Startup库分析

Posted 2022-12-05 yubo_725

简介

App Startup 库提供了一种在应用程序启动时初始化组件的简单、高效的方法。库开发人员和应用程序开发人员都可以使用 App Startup 来简化启动顺序并明确设置初始化顺序。

App Startup 允许您定义共享单个内容提供者的组件初始值设定项，而不是为您需要初始化的每个组件定义单独的内容提供程序。这可以显着缩短应用程序启动时间。

使用方法

单个Initializer

通过下面的配置在项目中引入Startup库：

dependencies 
    implementation("androidx.startup:startup-runtime:1.0.0")

要完成某些初始化工作，我们需要自定义一个Initializer类，比如如下代码：

package com.yb.testjetpack

import android.content.Context
import android.util.Log
import androidx.startup.Initializer

// 自定义Initializer，必须实现Initializer接口
class MyInitializer : Initializer<Unit> 
    companion object 
        private const val TAG = "MyInitializer"
    

    // 在这里完成某些初始化工作
    override fun create(context: Context): Unit 
        Log.d(TAG, "create: do some init...")
    

    // 该方法返回MyInitializer初始化前依赖的其他Initializer，这些Initializer会先执行
    override fun dependencies(): MutableList<Class<out Initializer<*>>> 
        return arrayListOf()
    

然后在项目的AndroidManifest.xml文件中注册这个Initializer：

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="$applicationId.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="com.yb.testjetpack.MyInitializer"
        android:value="androidx.startup" />
</provider>

通过以上简单的3步即可将Startup库应用在项目中，我们运行项目时，MyInitializer类中的onCreate方法会自动得到调用。

多个Initializer

以上介绍的是项目中只有一个Initializer的情况，其实项目中也可以定义多个不同的Initializer。

在上面的代码中，我们可以发现Initializer接口中有个dependencies方法，这个方法的返回值是一个数组，代表当前Initializer的初始化依赖的其他Initializer，下面举个例子说明应用中存在多个不同Initializer时的处理方法：

假设当前应用中有三个不同的Initializer：

• MyInitializer
• FirstInitializer
• SecondInitializer

这三个Initializer的初始化有一些特定的顺序：SecondInitializer的初始化依赖FirstInitializer，而FirstInitializer的初始化依赖MyInitializer，即MyInitializer最先执行，其次是FirstInitializer执行，最后是SecondInitializer，那么这三个Initializer的写法如下：

// MyInitializer
class MyInitializer : Initializer<Unit> 
    companion object 
        private const val TAG = "MyInitializer"
    

    // 在这里完成某些初始化工作
    override fun create(context: Context): Unit 
        Log.d(TAG, "create: do some init...")
    

    // 该方法返回MyInitializer初始化前依赖的其他Initializer，这些Initializer会先执行
    override fun dependencies(): MutableList<Class<out Initializer<*>>> 
    	// MyInitializer的初始化不依赖其他任何Initializer，返回一个空列表即可
        return arrayListOf()
    


// FirstInitializer
class FirstInitializer : Initializer<String> 

    companion object 
        private const val TAG = "FirstInitializer"
    

    override fun create(context: Context): String 
        Log.d(TAG, "create: init FirstInitializer...")
        return "FirstInitializer"
    

    override fun dependencies(): MutableList<Class<out Initializer<*>>> 
    	// FirstInitializer的初始化依赖MyInitializer
        return arrayListOf(MyInitializer::class.java)
    



// SecondInitializer
class SecondInitializer : Initializer<Unit> 

    companion object 
        private const val TAG = "SecondInitializer"
    

    override fun create(context: Context) 
        Log.d(TAG, "create: init SecondInitializer...")
    

    override fun dependencies(): MutableList<Class<out Initializer<*>>> 
        // SecondInitializer的初始化依赖FirstInitializer
        return arrayListOf(FirstInitializer::class.java)
    

然后在AndroidManifest.xml文件中注册Initializer。

你可以将这三个Initializer都注册，像这样：

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="$applicationId.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="com.yb.testjetpack.MyInitializer"
        android:value="androidx.startup" />
    <meta-data
        android:name="com.yb.testjetpack.FirstInitializer"
        android:value="androidx.startup" />
    <meta-data
        android:name="com.yb.testjetpack.SecondInitializer"
        android:value="androidx.startup" />
</provider>

也可以只注册最后一个被调用的Initializer

比如以上三个Initializer的调用顺序是：MyInitializer – FirstInitializer – SecondInitializer

那么在AndroidManifest.xml文件中，注册SecondInitializer即可：

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="$applicationId.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="com.yb.testjetpack.SecondInitializer"
        android:value="androidx.startup" />
</provider>

Initializer懒加载

以上介绍的单一Initializer和多个Initializer在注册到AndroidManifest.xml文件中后，不需要在代码中显式调用，App启动时即可自动完成Initializer中onCreate方法的执行，其原理会在后面详细说明。

某些时候我们可能并不需要模块在App启动时就立刻初始化，而是希望通过调用Java代码完成初始化。

如果你只想禁用单个Initializer的自动初始化，可以这么做：

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="$applicationId.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="com.yb.testjetpack.MyInitializer"
        tools:node="remove" />
</provider>

注意meta-data中的tools:node="remove"属性，这个配置并非简单的删除条目，而是确保合并工具也从所有其他合并的清单文件中删除条目。

如果你想禁用所有的Initializer的自动初始化，可以这么做：

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="$applicationId.androidx-startup"
    tools:node="remove" />

然后使用Java或Kotlin代码完成某个Initializer手动的初始化，比如下面的代码展示了在点击TextView后初始化MyInitializer：

findViewById<TextView>(R.id.text).setOnClickListener 
    AppInitializer.getInstance(this).initializeComponent(MyInitializer::class.java)

Startup库原理解析

你是不是和我一样好奇为啥Startup库不需要显式的执行初始化代码即可自动帮我们完成create方法中代码的执行？

通过Startup库的源码可以找到答案：Startup库使用了ContentProvider，而ContentProvider在注册到AndroidManifest.xml文件中后，ContentProvider中的onCreate方法会在Application的attachBaseContext方法之后，onCreate方法之前被调用。本篇不详细讨论ContentProvider的启动流程，仅仅解析Startup库的源码。

Startup库的源码非常少，仅有5个类，如下图所示：

其中Initializer是一个接口，其中定义了两个方法：create() dependencies()，源码如下：

/**
 * Initializers can be used to initialize libraries during app startup, without the need to use additional android.content.ContentProviders.
 * Type parameters:
 * <T> – The instance type being initialized
 */
public interface Initializer<T> 

    /**
     * Initializes and a component given the application @link Context
     *
     * @param context The application context.
     */
    @NonNull
    T create(@NonNull Context context);

    /**
     * @return A list of dependencies that this @link Initializer depends on. This is
     * used to determine initialization order of @link Initializers.
     * <br/>
     * For e.g. if a @link Initializer `B` defines another
     * @link Initializer `A` as its dependency, then `A` gets initialized before `B`.
     */
    @NonNull
    List<Class<? extends Initializer<?>>> dependencies();

根据源码上的注释可以知道，T表示即将被初始化的实例类型。

Startup库之所以可以在App启动时自动被执行，主要的类还是InitializationProvider，这个类继承了ContentProvider，其onCreate方法源码如下：

@Override
public boolean onCreate() 
    Context context = getContext();
    if (context != null) 
        AppInitializer.getInstance(context).discoverAndInitialize();
     else 
        throw new StartupException("Context cannot be null");
    
    return true;

这里的关键代码是AppInitializer.getInstance(context).discoverAndInitialize();

discoverAndInitialize()方法会去AndroidManifest.xml文件中查找<meta-data>标签，并过滤出值为androidx.startup的标签，接着通过反射去实例化我们自定义的Initializer，代码如下：

void discoverAndInitialize() 
    try 
        Trace.beginSection(SECTION_NAME);
        ComponentName provider = new ComponentName(mContext.getPackageName(),
                InitializationProvider.class.getName());
        ProviderInfo providerInfo = mContext.getPackageManager()
                .getProviderInfo(provider, GET_META_DATA);
        Bundle metadata = providerInfo.metaData;
        // startup为字符串"androidx.startup"
        String startup = mContext.getString(R.string.androidx_startup);
        if (metadata != null) 
            Set<Class<?>> initializing = new HashSet<>();
            // 获取AndroidManifest.xml中所有meta-data标签
            Set<String> keys = metadata.keySet();
            for (String key : keys) 
                String value = metadata.getString(key, null);
                // 匹配到"androidx.startup"，表示这个标签是自定义的Initializer
                if (startup.equals(value)) 
                	// 通过反射实例化自定义Initializer
                    Class<?> clazz = Class.forName(key);
                    if (Initializer.class.isAssignableFrom(clazz)) 
                        Class<? extends Initializer<?>> component =
                                (Class<? extends Initializer<?>>) clazz;
                        mDiscovered.add(component);
                        if (StartupLogger.DEBUG) 
                            StartupLogger.i(String.format("Discovered %s", key));
                        
                        // 初始化
                        doInitialize(component, initializing);
                    
                
            
        
     catch (PackageManager.NameNotFoundException | ClassNotFoundException exception) 
        throw new StartupException(exception);
     finally 
        Trace.endSection();
    


<T> T doInitialize(
        @NonNull Class<? extends Initializer<?>> component,
        @NonNull Set<Class<?>> initializing) 
    synchronized (sLock) 
        boolean isTracingEnabled = Trace.isEnabled();
        try 
            if (isTracingEnabled) 
                // Use the simpleName here because section names would get too big otherwise.
                Trace.beginSection(component.getSimpleName());
            
            if (initializing.contains(component)) 
                String message = String.format(
                        "Cannot initialize %s. Cycle detected.", component.getName()
                );
                throw new IllegalStateException(message);
            
            Object result;
            if (!mInitialized.containsKey(component)) 
                initializing.add(component);
                try 
                    Object instance = component.getDeclaredConstructor().newInstance();
                    Initializer<?> initializer = (Initializer<?>) instance;
                    List<Class<? extends Initializer<?>>> dependencies =
                            initializer.dependencies();
					// 如果依赖不为空，则先初始化依赖的Initializer
                    if (!dependencies.isEmpty()) 
                        for (Class<? extends Initializer<?>> clazz : dependencies) 
                            if (!mInitialized.containsKey(clazz)) 
                                doInitialize(clazz, initializing);
                            
                        
                    
                    if (StartupLogger.DEBUG) 
                        StartupLogger.i(String.format("Initializing %s", component.getName()));
                    
                    // 执行自定义Initializer中的create方法
                    result = initializer.create(mContext);
                    if (StartupLogger.DEBUG) 
                        StartupLogger.i(String.format("Initialized %s", component.getName()));
                    
                    initializing.remove(component);
                    mInitialized.put(component, result);
                 catch (Throwable throwable) 
                    throw new StartupException(throwable);
                
             else 
                result = mInitialized.get(component);
            
            return (T) result;
         finally 
            Trace.endSection();
        
    

写到这里你应该已经知道Startup库为甚么能自动执行初始化操作了吧，再想想我们使用LeakCanary库时，只是在build.gradle文件中添加了依赖：

debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.7'

再不需要其他代码的调用，LeakCanary就能自动检测内存泄漏问题，这种隐藏式的初始化，其原理和Startup库是一样的，都使用了ContentProvider。

Startup库优点

使用Startup库在某些情况下可以加速我们App的启动过程，具体可以查看如下两篇文章：

• 应用启动性能 | 介绍 App Startup 库
• Android 应用启动性能 | 延迟初始化