Android架構進階之深入理解AppStartup原理

作者： Android開發編程 2021-09-10 07:31:54

移動開發 Android

Android Startup提供一種在應用啟動時能夠更加簡單、高效的方式來初始化組件。開發人員可以使用Android Startup來簡化啟動序列，并顯式地設置初始化順序與組件之間的依賴關系。

[[422993]]

前言

Android Startup提供一種在應用啟動時能夠更加簡單、高效的方式來初始化組件。開發人員可以使用Android Startup來簡化啟動序列，并顯式地設置初始化順序與組件之間的依賴關系;

今天我們就來聊聊

一、使用步驟簡單介紹

使用 AndroidX App Startup 來運行所有依賴項的初始化有兩種方式：

自動初始化;

手動初始化(也是延遲初始化);

1、自動初始化

在 build.gradle 文件內添加依賴;

implementation "androidx.startup:startup-runtime:1.0.0-alpha01"

實現 Initializer 接口，并重寫兩個方法，來初始化組件;

public class MvpInitializer implements Initializer<Void> { 
    @NonNull 
    @Override 
    public Void create(@NonNull Context context) { 
         MvpManager.init(context); 
         return null; 
    } 
    @NonNull 
    @Override 
    public List<Class<? extends Initializer<?>>> dependencies() { 
        return new ArrayList<>(); 
    } 
} 
    ...... 
}

create(Context): 這里進行組件初始化工作;

dependencies(): 返回需要初始化的列表，同時設置 App 啟動時依賴庫運行的順序;

在 AndroidManifest.xml 文件中注冊 InitializationProvider;

<application> 
        <provider 
            android:authorities="${applicationId}.androidx-startup" 
            android:name="androidx.startup.InitializationProvider" 
            android:exported="false" 
            tools:node="merge" > 
          <!-- 自動初始化 --> 
            <meta-data android:name="com.test.Initializer" android:value="androidx.startup"/> 
    </provider> 
</application>

App 啟動的時 App Startup 會讀取 AndroidManifest.xml 文件里面的 InitializationProvider 下面的聲明要初始化的組件，完成自動初始化工作;

2、手動初始化(也是延遲初始化)

在 build.gradle 文件內添加依賴;

創建一個類 LibaryD 實現 Initializer 接口，并重寫兩個方法，來初始化組件;

在 AndroidManifest.xml 文件中注冊 InitializationProvider

<application> 
        <provider 
            android:name="androidx.startup.InitializationProvider" 
            android:authorities="${applicationId}.androidx-startup" 
            android:exported="false" 
            tools:node="merge"> 
            <!-- 手動初始化（也是延遲初始化） --> 
            <meta-data 
                android:name="com.test.Initializer" 
                android:value="androidx.startup" 
                tools:node="remove" /> 
        </provider> 
    </application>

只需要在標簽內添加 tools:node="remove" 清單合并工具會將它從清單文件中刪除;
在需要的地方進行初始化，調用以下代碼進行初始化;
Initializer.getInstance(context).initializeComponent(Initializer::class.java);
如果組件初始化之后，再次調用 AppInitializer.initializeComponent() 方法不會再次初始化;
手動初始化(也是延遲初始化)是非常有用的，組件不需要在 App 啟動時運行，只需要在需要它地方運行，可以減少 App 的啟動時間，提高啟動速度;

二、源碼分析

1、InitializationProvider

在AndroidManifest文件中配置的組件名必須為androidx.startup.InitializationProvider，現在我們來看這個類的源碼;

InitializationProvider.java 
public final class InitializationProvider extends ContentProvider { 
    @Override 
    public boolean onCreate() { 
        Context context = getContext(); 
        if (context != null) { 
            初始化 
            AppInitializer.getInstance(context).discoverAndInitialize(); 
        } else { 
            throw new StartupException("Context cannot be null"); 
        } 
        return true; 
    } 
    @Override 
    public Cursor query(...) { 
        throw new IllegalStateException("Not allowed."); 
    } 
    @Override 
    public String getType(...) { 
        throw new IllegalStateException("Not allowed."); 
    } 
    @Nullable 
    @Override 
    public Uri insert(...) { 
        throw new IllegalStateException("Not allowed."); 
    } 
    @Override 
    public int delete(...) { 
        throw new IllegalStateException("Not allowed."); 
    } 
    @Override 
    public int update(...) { 
        throw new IllegalStateException("Not allowed."); 
    } 
}

InitializationProvider其實也是利用了 ContentProvider 的啟動機制，在ContentProvider#onCreate(...)中執行初始化;

ContentProvider 的其他方法是沒有意義的，所以都拋出了IllegalStateException;

2、自動初始化分析

App Startup 在 ContentProvider 中調用了AppInitializer#discoverAndInitialize()執行自動初始化;

AppInitializer是 App StartUp 框架的核心類，整個 App Startup 框架的代碼其實非常少，其中很大部分核心代碼都在 AppInitializer 類中;

2.1.AppInitializer.java discoverAndInitialize

final Set<Class<? extends Initializer<?>>> mDiscovered; 
void discoverAndInitialize() { 
    獲取 androidx.startup.InitializationProvider 組件信息 
    ComponentName provider = new ComponentName(mContext.getPackageName(), InitializationProvider.class.getName()); 
    ProviderInfo providerInfo = mContext.getPackageManager().getProviderInfo(provider, GET_META_DATA); 
   androidx.startup 字符串 
    String startup = mContext.getString(R.string.androidx_startup); 
   獲取組件信息中的 meta-data 數據 
    Bundle metadata = providerInfo.metaData; 
    遍歷 meta-data 數據 
    if (metadata != null) { 
        Set<Class<?>> initializing = new HashSet<>(); 
        Set<String> keys = metadata.keySet(); 
        for (String key : keys) { 
            String value = metadata.getString(key, null); 
          判斷 meta-data 數據中，value 為 androidx.startup 的鍵值對 
            if (startup.equals(value)) { 
                Class<?> clazz = Class.forName(key); 
                 檢查指定的類是 Initializer 接口的實現類 
                if (Initializer.class.isAssignableFrom(clazz)) { 
                    Class<? extends Initializer<?>> component = (Class<? extends Initializer<?>>) clazz; 
                    將 Class 添加到 mDiscovered Set 中 
                    mDiscovered.add(component); 
                    初始化此組件 
                    doInitialize(component, initializing); 
                } 
            } 
        } 
    } 
} 
mDiscovered 用于判斷組件是否已經自動啟動 
public boolean isEagerlyInitialized(@NonNull Class<? extends Initializer<?>> component) { 
    return mDiscovered.contains(component); 
}

獲取androidx.startup.InitializationProvider組件信息(在各個 Module 中聲明的組件信息，會在manifest merger tool的處理下合并);
androidx.startup字符串;
獲取組件信息中的 meta-data 數據;
遍歷 meta-data 數據;
判斷 meta-data 數據中，value 為 androidx.startup 的鍵值對;
檢查指定的類是 Initializer 接口的實現類;
將 Class 添加到 mDiscovered Set 中，這將用于后續判斷組件是否已經自動啟動;
初始化此組件;

2.2.AppInitializer.java AppInitializer.java

private static final Object sLock = new Object(); 
緩存每個組件的初始化結果; 
final Map<Class<?>, Object> mInitialized; 
初始化此組件 
<T> T doInitialize(Class<? extends Initializer<?>> component, Set<Class<?>> initializing) { 
    對 sLock 加鎖 
    Object result; 
  判斷 initializing 中存在當前組件，說明存在循環依賴 
    if (initializing.contains(component)) { 
        String message = String.format("Cannot initialize %s. Cycle detected.", component.getName()); 
        throw new IllegalStateException(message); 
    } 
   檢查當前組件是否已初始化 
    if (!mInitialized.containsKey(component)) { 
        當前組件未初始化 
        記錄正在初始化 
        initializing.add(component); 
        通過反射實例化 Initializer 接口實現類 
        Object instance = component.getDeclaredConstructor().newInstance(); 
        Initializer<?> initializer = (Initializer<?>) instance; 
       遍歷所依賴的組件 
        List<Class<? extends Initializer<?>>> dependencies = initializer.dependencies(); 
        if (!dependencies.isEmpty()) { 
            for (Class<? extends Initializer<?>> clazz : dependencies) { 
                如果所依賴的組件未初始化，遞歸執行初始化 
                if (!mInitialized.containsKey(clazz)) { 
                    doInitialize(clazz, initializing); 注意：這里將 initializing 作為參數傳入 
                } 
            } 
        } 
       初始化當前組件 
        result = initializer.create(mContext); 
       移除正在初始化記錄 
        initializing.remove(component); 
        緩存初始化結果 
        mInitialized.put(component, result); 
    } else { 
        當前組件已經初始化，直接返回 
        result = mInitialized.get(component); 
    } 
     return (T) result; 
}

對 sLock 加鎖;
判斷 initializing 中存在當前組件，說明存在循環依賴(這是因為遞歸初始化所依賴的組件時，會將 initializing 作為參數傳入，如果 initializing 中存在當前組件，說明依賴關系形成回環，如果不拋出異常，將形成無限遞歸);
檢查當前組件是否已初始化;
記錄正在初始化;
通過反射實例化 Initializer 接口實現類;
遍歷所依賴的組件，如果所依賴的組件未初始化，遞歸調用doInitialize(...)執行初始化;
初始化當前組件;
移除正在初始化記錄;
緩存初始化結果;

3、手動初始化源碼分析

手動初始化(懶加載)的源碼分析:

AppInitializer.java 
public <T> T initializeComponent(@NonNull Class<? extends Initializer<T>> component) { 
    調用 doInitialize(...) 方法： 
    return doInitialize(component, new HashSet<Class<?>>()); 
}

其實非常簡單，就是調用上一節的doInitialize(...)執行初始化。需要注意的是，這個方法是允許在子線程調用的，換句話說，自動初始化與手動初始化是存在線程同步問題的，那么 App Startup 是如何解決的呢?

前面有一個sLock沒有說嗎?其實它就是用來保證線程同步的鎖：

<T> T doInitialize(Class<? extends Initializer<?>> component, Set<Class<?>> initializing) { 
   對 sLock 加鎖 
    synchronized (sLock) { 
        ...  
    } 
}

總結

App Startup 是 Jetpack 的新成員，是為了解決因 App 啟動時運行多個 ContentProvider 會增加 App 的啟動時間的問題;

使用了一個 InitializationProvider 管理多個依賴項，消除了每個庫單獨使用 ContentProvider 成本，減少初始化時間;

App Startup 允許你自定義組件初始化順序;

App Startup 提供了一種延遲初始化組件的方法，減少 App 初始化時間;

責任編輯：武曉燕來源： Android開發編程