if (report.isClean()) {
MembersInjectionBinding binding = bindingFactory.membersInjectionBinding(type, resolvedType); // 6
registerBinding(binding, warnIfNotAlreadyGenerated); // 7
for (Optional supertype = types.nonObjectSuperclass(type);
supertype.isPresent();
supertype = types.nonObjectSuperclass(supertype.get())) {
getOrFindMembersInjectionBinding(keyFactory.forMembersInjectedType(supertype.get()));
}
return Optional.of(binding);
}
return Optional.empty();
}
private void registerBinding(ProvisionBinding binding, boolean warnIfNotAlreadyGenerated) {
provisionBindings.tryRegisterBinding(binding, warnIfNotAlreadyGenerated); // 8
if (binding.unresolved().isPresent()) {
provisionBindings.tryToGenerateBinding(binding.unresolved().get(), warnIfNotAlreadyGenerated);
}
}
注释1:将TypeElement转换成 DeclaredType
注释2:通过注释1获取的type,通过Key工厂获得一个Key
注释3:通过Key去内存中看看之前有没有缓存过该注解内容,如果缓存过则取缓存的的内容
注释4、5:在 messager上打印TypeElement信息
注释6、7:通过工厂模式创建出 注解信息 MembersInjectonBinding
,它是 ProvisionBinding
抽象类的子类,它的作用是描述一个被注解修饰的信息。然后调用 registerBinding()
注释8:将 注释7的 ProvisionBinding
注册到 provisionBindings中,它的类型是 BindingsCollection<ProvisionBinding>
,即专门用来收集注解信息。
到这里,通过 InjectProcessingStep.process()
方法,@Inject
修饰的所有信息,全都被注册到了 provisionBindings中。
我们都知道注解处理器无非就做两件事情:①收集注解信息 ②将这些信息写成Java文件
怎么实现第二步呢?在 BasicAnnotationProcessor
中,在调用完 process()
遍历执行完每个ProcessingStep后,还会执行postRound()
,它会让子类来实现。
在 @Inject中,其Java文件的产生是在 ComponentProcessor
中:
// ComponentProcessor.java
protected void postRound(RoundEnvironment roundEnv) {
statisticsCollector.roundFinished();
if (roundEnv.processingOver()) {
statisticsCollector.processingStopped();
} else {
try {
injectBindingRegistry.generateSourcesForRequiredBindings(
factoryGenerator, membersInjectorGenerator); // 1
} catch (SourceFileGenerationException e) {
e.printMessageTo(processingEnv.getMessager());
}
}
clearableCaches.forEach(ClearableCache::clearCache);
}
}
注释1:调用 injectBindingRegistry.generateSourcesForRequiredBindings实际上就是调用:InjectBindingRegistryImpl.generateSourcesForRequiredBindings()
:
// dagger/java/dagger/internal/codegen/validation/InjectBindingRegistryImpl.java
@Override
public void generateSourcesForRequiredBindings(
SourceFileGenerator factoryGenerator,
SourceFileGenerator membersInjectorGenerator)
throws SourceFileGenerationException {
provisionBindings.generateBindings(factoryGenerator); // 1
membersInjectionBindings.generateBindings(membersInjectorGenerator); // 2
}
注释1:生成 XXX_Factory 类的Java文件
注释2:生成 XXXX_MemberInjector 类的Java
由于其细节都是文件生成,到这里就不再讲解下去了。
虽然上面我讲解了只有关于 @Inject的注解处理,但是我相信触类旁通,Dagger2对其他的注解肯定也是做了类似的处理。
这里来总结一下 1.1、1.2节中所讲的知识。
(1)关于Dagger2 注解处理架构:
由于Dagger所要处理的注解很多, Inject、Module、Scope、Qualifier、Name、Component…为每个注解写一个Processor未免太枯燥,且难于管理,并且他们之间又存在着一些共性。
所以Dagger把这些共性抽了出来,并编写了 BasicAnnotationProcessor
继承自AbstractProcessor。
并且实现了内部类ProcessingStep
对应着每一个注解,它负责收集自己那部分注解修饰的信息。比如处理 @Inject
的 InjectProcessingStep
等。
BasicAnnotationPrcocessor.process()
会去遍历所有的 ProcessingStep.process()
收集信息。
BasicAnnotationPrcocessor.postRound()
还会去根据需要产生Java文件(当然有些注解产生文件的入口不在这里)
(2)关于 XXXProcessingStep
间接的继承了 ProcessingStep
,具备收集、注册信息的功能。
例如在 InjectProcessingStep
中,它会把收集到的 Element,通过访问者模式,将Element信息注册到集合BindingsCollection
中。
最后写文件的时候,就是根据这个集合的内容编写的。
===================================================================================
Dagger针对Android平台提供了专门的库来简化注入过程。需要我们添加额外的依赖库。
在Android中Dagger的注入是分层级的,有对应用层级全局属性或服务(OkHttp、Retrofit、Database)的注入,有对Activity中的变量注入,也有对Fragment中的变量注入,对应Component的层级如下图所示:
下面举几个例子,看下使用 dagger.android 在上面层级中的使用。
(1)创建 MainActivitySubComponent:
@Subcomponent
public interface MainActivitySubComponent extends AndroidInjector {
@Subcomponent.Builder
abstract class Builder extends AndroidInjector.Builder{}
}
MainActivitySubComponent
是MainActivity对应的Component,它是应用层级Component的子Component,所以使用 @Subcomponent注解。
MainActivitySubComponent 继承自 AndroidInjector
,AndroidInjector
是Android中的核心类(Activity、Fragment等)的注入器,可以完成对Activity或Fragment的成员变量的注入。
另外,我们还需要创建一个继承自AndroidInjector.Builder
的抽象类Builder,它的作用是创建 MainActivitySubComponent的实例。
(2)创建ActivityModule
@Module(subcomponents = MainActivitySubComponent.class)
public abstract class ActivityModule {
//返回MainActivity对应的注入器工厂
@Binds
@IntoMap
@ActivityKey(MainActivity.class)
abstract AndroidInjector.Factory<? extends Activity> bindMainActivityInjectorFactory(MainActivitySubComponent.Builder builder);
//返回其他Activity对应的注入器工厂
…
}
ActivityModule 可以提供各个Activity对应的AndroidInjector.Factory,也就是注入器工厂类。
subcomponents指定为MainActivitySubComponent,表示MainActivitySubComponent是任何使用ActivityModule的Component的子Component。
(3)创建应用层级的 AppComponent
@Component(modules = {AndroidInjectionModule.class, ActivityModule.class})
public interface AppComponent {
void inject(App instance);
}
应用层级的 AppComponent安装了两个Module,一个是 AndroidInjectionModule
(由dagger-android提供),一个是ActivityModule。
另外还提供注入到Application类中的注入方法inject,值得注意的是,inject方法中的参数为我们自定义的App类型,而非Application类。
(4)注入到 Application类
public class App extends Application implements HasActivityInjector {
@Inject
DispatchingAndroidInjector dispatchingAndroidInjector;
@Override
public void onCreate() {
super.onCreate();
DaggerAppComponent.create().inject(this);
}
@Override
public AndroidInjector activityInjector() {
return dispatchingAndroidInjector;
}
}
在应用的Application类中,我们需要实现接口HasActivityInjector
返回一个全局的Activity的注入器 dispatchingActivityInjector,而它的初始化由 AppComponent来完成,即由AppComponent对应生成的 DaggerAppComponent
在Application类的onCreate方法中注入。
(5)注入到MainActivity
@Override
protected void onCreate(Bundle savedInstanceState) {
AndroidInjection.inject(this);
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
在MainActivity的 onCreate()
中,调用 super.onCreate()
前使用 AndroidInjection对MainActivity进行注入。
这个注入过程又是怎么完成的呢?实际上:
-
AndroidInjection注入时会获取Application类里面的dispatchActivityInject
-
通过dispatchActivityInject查找到对应MainActivity的 AndroidInjector.Factory(即MainActivitySubComponent类中的Builder,该Buidler实现了AndroidInjector.Factory接口 )
-
然后使用Builder创建MainActivity的注入器AndroidInjector(即MainActivitySubComponent)
-
最终使用MainActvitySubComponent实现对MainActivity的注入,完成对MainActivity中对象的赋值。
我们可以看下 AndroidInjection.inject()
:
// AndroidInjection.java
public static void inject(Activity activity) {
checkNotNull(activity, “activity”);
Application application = activity.getApplication(); // 获取Application对象
if (!(application instanceof HasActivityInjector)) { // 希望Application实现了HasActivityInjector接口
throw new RuntimeException(
String.format(
“%s does not implement %s”,
application.getClass().getCanonicalName(),
HasActivityInjector.class.getCanonicalName()));
}
AndroidInjector activityInjector =
((HasActivityInjector) application).activityInjector(); // 获取Application中的 dispatchingAndroidInjector对象
checkNotNull(activityInjector, “%s.activityInjector() returned null”, application.getClass());
activityInjector.inject(activity); //调用这个对象的inject方法(就是调用了MainActivitySubComponent的inject)
}
(6)@ContributesAndroidInjector
通过上述的步骤,就可以完成对Activity的注入,但是整体略显繁琐,当我们想要注入某个Activity中,就必须要创建该Activity的Component,而且这些代码都是模板代码,不需要动脑子,另外每次增加一个Component,就要在ActivityModule的Subcomponent集合中添加它。
事实上,Activity对应的Component的创建可以使用注解 @ContributesAndroidInjector
自动生成。
我们只需要修改 ActivityModule就可以了:
@Module
public abstract class ActivityModule {
// //返回MainActivity对应的注入器工厂
// @Binds
// @IntoMap
// @ActivityKey(MainActivity.class)
// abstract AndroidInjector.Factory<? extends Activity> bindMainActivityInjectorFactory(MainActivitySubComponent.Builder builder);
@ContributesAndroidInjector
abstract MainActivity contributesMainActivityInjector();
}
2.2 MainActivity中TextView对象的注入
由于TextView对象需要TextViewModule提供,在构建MainActivity对应的Component时需要创建一个TextViewModule的实例,所以在ActivityModule中不能使用 @ContributesAndroidInjector自动生成MainActivitySubComponent,还是需要手动创建。
在MainActivitySubComponent内部类Builder中实现 seedInstance()
,并创建抽象方法textViewModule接收TextViewModule对象作为参数,在seedInstance()
中,调用 textViewModule方法传入一个TextViewModule实例。
这时MainActivityStubCoponent就具有注入TextView的能力。
@Subcomponent(modules = TextViewModule.class)
public interface MainActivitySubComponent extends AndroidInjector {
@Subcomponent.Builder
abstract class Builder extends AndroidInjector.Builder{
abstract void textViewModule(TextViewModule textViewModule);
@Override
public void seedInstance(MainActivity instance) {
textViewModule(new TextViewModule(instance));
}
}
}
Activiy对应的注入器一般作为Application对应注入器的 Subcomponent,而Fragment对应的注入器可以是其他Fragment、Activity或Application的对应Component的Subcomponent,这要看Fragment的Module是安装到哪个Component上。
现在我们在MainActivity内部的MainFragment中也注入一个Java对象,步骤如下:
(1)创建FragmentModule
在FragmentModule中使用注解 @ContributesAndroidInjector,这样就可以自动生成MainFragment对应的Component。
@Module
public abstract class FragmentModule {
@ContributesAndroidInjector
abstract MainActivity.MainFragment contributeMainActivityInjector();
}
(2)安装FragmentModule
那么生成的Component是作为谁的Subcomponent呢?这就要看FragmentModule安装在哪里了。
这里,我们将FragmentModule安装到AppComponent中,那么MainFragment的Component将是AppComponent的Subcomponent,代码如下:
@Component(modules = {AndroidInjectionModule.class, ActivityModule.class
, FragmentModule.class})
public interface AppComponent {
void inject(App instance);
}
(3)注入Application
在Application类中实现 HasFragmentInjector
接口,返回一个 dispatchingFragmentInjector
,它同样会被AppComponent注入,完成初始化,后续会使用它来完成Fragment的注入:
public class App extends Application implements HasActivityInjector, HasFragmentInjector {
@Inject
DispatchingAndroidInjector dispatchingAndroidInjector;
@Override
public void onCreate() {
super.onCreate();
DaggerAppComponent.create().inject(this);
}
@Override
public AndroidInjector<android.app.Fragment> fragmentInjector() {
return dispatchingAndroidInjector;
}
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级安卓工程师,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助,可以添加下面V无偿领取!(备注Android)
最后
其实Android开发的知识点就那么多,面试问来问去还是那么点东西。所以面试没有其他的诀窍,只看你对这些知识点准备的充分程度。so,出去面试时先看看自己复习到了哪个阶段就好。
虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。
这里附上上述的面试题相关的几十套字节跳动,京东,小米,腾讯、头条、阿里、美团等公司21年的面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
详细整理在GitHub可以见;
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
果你觉得这些内容对你有帮助,可以添加下面V无偿领取!(备注Android)**
[外链图片转存中…(img-4kXzCwIF-1710833814880)]
最后
其实Android开发的知识点就那么多,面试问来问去还是那么点东西。所以面试没有其他的诀窍,只看你对这些知识点准备的充分程度。so,出去面试时先看看自己复习到了哪个阶段就好。
虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。
这里附上上述的面试题相关的几十套字节跳动,京东,小米,腾讯、头条、阿里、美团等公司21年的面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
[外链图片转存中…(img-kDSUwcNU-1710833814881)]
详细整理在GitHub可以见;
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。