/ 今日科技快讯 /
近日,南昌市人民政府与新电商平台拼多多签订战略框架协议,共同启动“南昌优品”电商直播消费节、“南昌优品馆”线上大型展销专场等系列活动。
/ 作者简介 /
这周时间特别的短,明天就是端午节了,提前祝大家端午节快乐!
本篇文章来自xiao哥哥998的投稿,分享了Android架构组件--App Startup学习笔记,相信会对大家有所帮助!
xiao哥哥998博客地址:
https://blog.csdn.net/qq_40909351
/ 解决的问题 /
一般需要初始化的sdk都会对外提供一个初始化方法供外界调用,如:
public class App extends Application {
@Override
public void onCreate() {
super.onCreate();
Sdk1.init(this);
}
}
对调用者很不友好。另一种做法是使用ContentProvider初始化,如下:
public class Sdk1InitializeProvider extends ContentProvider {
@Override
public boolean onCreate() {
Sdk1.init(getContext());
return true;
}
...
}
然后在AndroidManifest.xml文件中注册这个privoder,如下:
这样初始化的逻辑就由Sdk开发者在内部完成了。
但是,如果一个app依赖了很多需要初始化的sdk,如果都放在一个ContentProvider中会导致此ContentProvider代码数量增加。而且每增加一个需要初始化的sdk都要对该ContentProvider文件做改动,不方便合作开发。而如果每个sdk都采用同样的方式将会带来性能问题。App Startup library可以有效解决这个问题。
/ 使用App Startup /
添加依赖
在App模块的build.gradle文件中添加依赖:
dependencies {
implementation "androidx.startup:startup-runtime:1.0.0-alpha01"
}
实现Initializer
app通过Initializer
public interface Initializer {
@NonNull
T create(@NonNull Context context);
@NonNull
List>> dependencies();
}
例如有一个Sdk1如下:
public class Sdk1 {
private static final String TAG = "Sdk1";
private static Context sApplicationContext;
private static volatile Sdk1 sInstance;
public static void init(Context applicationContext){
sApplicationContext = applicationContext;
Log.e(TAG, "Sdk1 is initialized");
}
public static Sdk1 getInstance(){
if (sInstance == null) {
synchronized (Sdk1.class){
if (sInstance == null) {
sInstance = new Sdk1();
}
}
}
return sInstance;
}
private Sdk1(){
}
public void printApplicationName(){
Log.e(TAG, sApplicationContext.getPackageName());
}
}
sdk1对外提供Sdk1类,包含初始化方法init(Context),实例获取方法getInstance()和对外的服务方法printApplicationName()。为了使用App Startup,需要提供一个初始化器如下:
public class Sdk1Initializer implements Initializer {
@NonNull
@Override
public Sdk1 create(@NonNull Context context) {
Sdk1.init(context);
return Sdk1.getInstance();
}
@NonNull
@Override
public List>> dependencies() {
return Collections.emptyList();
}
}
泛型T为待初始化的Sdk对外提供的对象类型;create(Context)方法是该Sdk初始化
逻辑写入的地方,其参数context为Application Context,同时需要返回一个Sdk对外提供的对象实例。
dependencies()方法则需要返回一个列表,这个列表需要给出一个该Sdk依赖的其它
Sdk的初始化器,也就是这个列表决定了哪些sdk会在这个sdk之前初始化,如果这个sdk是独立的没有依赖与其它的sdk,可以将该方法返回一个空列表(如Sdk1Initializer的实现)。
但是如果这个sdk依赖于其它的sdk,必须在其它sdk初始化之后才能初始化,则需要在dependencies()方法中指明。例如现在有一个sdk2也需要初始化,且它必须在sdk1初始化之后才能初始化,那么sdk2的初始化器的实现如下:
public class Sdk2Initializer implements Initializer {
@NonNull
@Override
public Sdk2 create(@NonNull Context context) {
Sdk2.init(context);
return Sdk2.getInstance();
}
@NonNull
@Override
public List>> dependencies() {
List>> dependencies = new ArrayList<>();
dependencies.add(Sdk1Initializer.class);
return dependencies;
}
}
在dependencies()方法中指明了Sdk2的依赖项,因此App Startup会在初始化sdk2之前先初始化sdk1。
注册Provider和Initializer>
我们需要告诉App Startup我们实现了哪些Sdk初始化器(Sdk1Initializer、Sdk2Initializer)。同时App Startup并没有提供AndroidManifest.xml文件,因此App Startup用到的provider同样需要注册。在app的AndroidManifest.xml文件添加如下代码:
通常每一个初始化器对应一个
可以不用在AndroidManifest.xml文件中显式地指明,因为App Startup已经通过
注册的Sdk2Initializer找到它了。
这里的
也就是("androidx.startup"),否则将不生效。
如果有一个sdk3内部通过App Startup帮助使用者处理了初始化,那么sdk3的AndroidManifest.xml文件中已经存在了InitializationProvider的provider标签,此时会与app模块中的冲突,因此在app模块的provider标签中指明tools:node="merge",通过AndroidManifest.xml文件的合并机制。
/ App Startup实现懒加载 /
为了减少app启动时间,对于一些非必须的初始化应该在app启动后、sdk使用前完成初始化,使用在provider中注册的方法不能达到这个目的。App StartUp提供了AppInitializer来解决这个问题。如下,在需要初始化的位置使用AppInitializer:
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(TAG, "MainActivity Created");
AppInitializer.getInstance(getApplicationContext())
.initializeComponent(Sdk2Initializer.class);
Sdk1.getInstance().printApplicationName();
}
}
同时需要修改AndroidManifest.xml文件中的对应初始化器的
通过tools:node="remove"来标记该初始化器。这样会在AndroidManifest.xml文件合并时将这个
/ 剖析App StartUp /
App StartUp的设计思路比较简单,就是将多个需要初始化的Sdk在一个provider中完成,从而减少多个provider带来的性能问题和繁杂的AndroidManifest.xml文件声明。目前App StartUp为1.0.0-alpha01版本,其代码结构非常简单。
只有五个类文件,除去StartupException和StartupLogger,其核心类只有三个。
Intializer.java的作用很简单,就是为lib的使用者提供了接入的方法,因此不再赘述。
InitializationProvider.java是App StartUp中使用的单一的provider,所有注册的初始化将在这个provider中完成。App StartUp只重写了onCreate()方法:
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;
}
...
可以看到,在onCreate()方法中执行了扫描和初始化注册的组件。其实现方法在AppInitializer.java中。AppInitializer内部是一个单例实现,它的getInstance(Context)方法传入的是Application级别的Context,并将其传递给注册的各Intializer,首先看discoverAndInitialize()方法:
@SuppressWarnings("unchecked")
void discoverAndInitialize() {
try {
Trace.beginSection(SECTION_NAME);
// 扫描并获取Manifest文件中的 `InitializationProvider`这个组件中注册的
// 信息
ComponentName provider = new ComponentName(mContext.getPackageName(),
InitializationProvider.class.getName());
ProviderInfo providerInfo = mContext.getPackageManager()
.getProviderInfo(provider, GET_META_DATA);
Bundle metadata = providerInfo.metaData;
// 然后遍历标签,获取到每个标签的 `Initializer`并对其初始化
String startup = mContext.getString(R.string.androidx_startup);
if (metadata != null) {
Set> initializing = new HashSet<>();
Set keys = metadata.keySet();
for (String key : keys) {
// 注意这里会用标签的value属性的值和`@string/androidx_startup`
// 对比,只有是这个值的标签才会被初始化。
String value = metadata.getString(key, null);
if (startup.equals(value)) {
Class> clazz = Class.forName(key);
if (Initializer.class.isAssignableFrom(clazz)) {
Class extends Initializer>> component =
(Class extends Initializer>>) clazz;
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();
}
}
discoverAndInitialize()方法首先扫描清单文件获取到需要初始化的初始化器Initializer,然后执行初始化操作,即调用doInitialize(Class extends Initializer>>, Set
@NonNull
@SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
T doInitialize(
@NonNull Class extends Initializer>> component,
@NonNull Set> initializing) {
synchronized (sLock) {
boolean isTracingEnabled = Trace.isEnabled();
try {
if (isTracingEnabled) {
Trace.beginSection(component.getSimpleName());
}
// `initializing`存储着正在初始化的初始化器。
// 这个判断是要解决循环依赖的问题,比如 `Sdk1Initializer`依赖了它本身,或者是
// `Sdk1Initializer` 依赖了 `Sdk2Initializer`,同时 `Sdk2Initializer` 又
// 依赖了 `Sdk1Initializer`,这是存在逻辑错误的,因此需要排除。
if (initializing.contains(component)) {
String message = String.format(
"Cannot initialize %s. Cycle detected.", component.getName()
);
throw new IllegalStateException(message);
}
// `mInitialized` 是一个 `Map, Object>`,它缓存了已经执行过初始化的
// `Initializer`的 `Class` 对象和初始化的结果,通过这种方法来避免重复初始化。
Object result;
if (!mInitialized.containsKey(component)) {
// 这是这个初始化器还没被初始化的情况。
initializing.add(component);
try {
// 首先构造一个该初始化器的实例
Object instance = component.getDeclaredConstructor().newInstance();
Initializer> initializer = (Initializer>) instance;
// 读取它的依赖关系,如果有依赖的初始化器,要先对他们做初始化。
List>> dependencies =
initializer.dependencies();
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()));
}
// 调用初始化器的 `create(Context)`方法,执行具体的初始化逻辑。
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();
}
}
}
doInitialize(Class extends Initializer>>, Set
用来做懒加载的initializeComponent(Class extends Initializer
@NonNull
@SuppressWarnings("unused")
public T initializeComponent(@NonNull Class extends Initializer> component) {
return doInitialize(component, new HashSet>());
}
/ App Startup利弊 /
优点:
解决了多个sdk初始化导致Application文件和Mainfest文件需要频繁改动的问题,同时也减少了Application文件和Mainfest文件的代码量,更方便维护了
方便了sdk开发者在内部处理sdk的初始化问题,并且可以和调用者共享一个ContentProvider,减少性能损耗。
提供了所有sdk使用同一个ContentProvider做初始化的能力,并精简了sdk的使用流程。
符合面向对象中类的单一职责原则
有效解耦,方便协同开发
缺点:
会通过反射实例化Initializer<>的实现类,在低版本系统中会有一定的性能损耗。
必须给Initializer<>的实现类提供一个无参构造器,当然也不能算是缺点,如果缺少的话新版的android studio会通过lint检查给出提醒。
导致类文件增多,特别是有大量需要初始化的sdk存在时。
版本较低,还没有发行正式版。
推荐阅读:
我的新书,《第一行代码 第3版》已出版!
我新开发了一个特别好用的开源库
巧用MVVM搭建GitHub客户端
欢迎关注我的公众号
学习技术或投稿
长按上图,识别图中二维码即可关注