前言

考虑到这块代码的复杂性，我们以当前ProcessorComponent节点生成DaggerComponentProcessor_ProcessorComponent作为demo案例讲解。

在讲解前，我们必须先把路由图整理出来，该路由图的作用是依赖的关联生成对应的变量和代码块：

component代码实现核心在关系图文件夹下，灰常灰常重要

在熟悉下面demo前务必认真、多次、对照前面的关系图去理解当前路由图。

component代码生成器是ComponentGenerator类，该类的topLevelTypes执行componentImplementation.generate()完成代码生成逻辑，如下：

public TypeSpec generate() {
    return componentShard.generate();
}

如上代码所示，这里的componentShared（ShardImplementation类）表示当前正在处理的component碎片，也可以理解为每一个再处理的component节点会有一个ShardImplementation类作为碎片处理器。

下面对照ShardImplementation的generate理解component代码逻辑的生成.

ShardImplementation的generate完成component代码逻辑的生成

生成了DaggerComponentProcessor_ProcessorComponent类，讲解过程中细节方面自行对照该类进行理解。

一生成类名

**目标实现：**生成了DaggerComponentProcessor_ProcessorComponent作为类名。

代码逻辑：

classBuilder(name)，创建一个name的类；
name参数是通过ShardImplementation构造函数传递过来的参数；

在ComponentImplementation构造函数中新建ShardImplementation时，componentNames.get(graph.componentPath())就是name参数的值；

  @Inject
     ComponentImplementation(...){
 		...
 		this.componentShard = new ShardImplementation(componentNames.get(graph.componentPath()));
 		...
 }

ComponentNames.get方法获取生成的component节点生成的类名，这里我们知道使用的是rootName：

 ClassName get(ComponentPath componentPath) {
     return componentPath.atRoot()
             ? rootName
             //父节点生成的名称.currentComponent + "Impl"
             : rootName.nestedClass(namesByPath.get(componentPath) + "Impl");
 }

rootName在ComponentNames构造函数中实现：

@Inject ComponentNames( @TopLevel BindingGraph graph, KeyFactory keyFactory ) { this.rootName = getRootComponentClassName(graph.componentDescriptor()); ... }

如下代码可以看到生成component节点的类规则：

 public static ClassName getRootComponentClassName(ComponentDescriptor componentDescriptor) {
     checkState(!componentDescriptor.isSubcomponent());
     ClassName componentName = ClassName.get(componentDescriptor.typeElement());
     return ClassName.get(componentName.packageName(), "Dagger" + classFileName(componentName));
 }

生成的类在当前component节点同一个包下，并且类名是 "Dagger" + 当前component节点父类一级级的以"_"作为分隔符拼接到component节点，例如DaggerComponentProcessor_ProcessorComponent

##二当前生成的Component类继承component节点 ##

目标实现： 当前DaggerComponentProcessor_ProcessorComponent继承ProcessorComponent节点：

DaggerComponentProcessor_ProcessorComponent implements ComponentProcessor.ProcessorComponent

代码逻辑

TypeSpecs.addSupertype(builder, graph.componentTypeElement());

##三生成Creator内部类 ##

目标实现：

生成一个Factory类继承ComponentProcessor.ProcessorComponent.Factory：

  private static final class Factory implements ComponentProcessor.ProcessorComponent.Factory {
    @Override
    public ComponentProcessor.ProcessorComponent create(XProcessingEnv xProcessingEnv,
        ImmutableSet<BindingGraphPlugin> externalPlugins) {
      Preconditions.checkNotNull(xProcessingEnv);
      Preconditions.checkNotNull(externalPlugins);
      return new DaggerComponentProcessor_ProcessorComponent(xProcessingEnv, externalPlugins);
    }
  }

代码逻辑：

调用addCreator()方法；
调用ComponentCreatorImplementationFactory.create用于生成creator内部类，并且存储于ComponentCreatorImplementation对象。这里调用的是BuilderForCreatorDescriptor对象的build方法：

（0）生成的creator类名：
① componentImplementation.getCreatorName()：调用getCreatorName方法获取；
② componentNames.getCreatorName(graph.componentPath())调用getCreatorName方法获取creator类名，如下所示表示生成当前DaggerComponentProcessor_ProcessorComponent内部类
```
 	rootName.nestedClass(creatorNamesByPath.get(componentPath))
```
③ creatorNamesByPath变量在ComponentNames类构造函数中定义，调用creatorNamesByPath方法，该方法作用：实现Factory模式下使用Factory作为类名，Builder模式下使用Builder作为类名，所以当前生成的类名为：Factory
（1）setModifiers()：修饰符private static final
（2）setSupertype()：当前creator节点继承ComponentProcessor.ProcessorComponent.Factory
（3）addConstructor()：添加构造函数，如果当前不存在父级component，那么使用默认构造函数，这里不另外生成；
（4）this.fields = addFields()：添加变量，这里针对的是Builder模式下的setterMethod方法的参数，当前是Factory模式，所以该变量为空；
（5）addSetterMethods()：Builder模式下的setterMethod方法在Creator类中创建新的方法，当前是Factory模式，所以这里没有实现；
（6） addFactoryMethod()：Factory模式下的方法或Builder模式下的buildMethod方法用于业务逻辑实现。这里针对Factory做如下操作：
① factoryMethodBuilder():重写create方法,方法类型是ComponentProcessor.ProcessorComponent
② create修饰符和返回类型：public修饰，方法返回类型是ComponentProcessor.ProcessorComponent
③ factoryMethodParameters()：create方法参数,沿用ProcessorComponent.Factory的create方法参数
④ create方法添加代码块:

④a：对参数加上notNull处理：

 	Preconditions.checkNotNull(xProcessingEnv);
     Preconditions.checkNotNull(externalPlugins);

④b：创建DaggerComponentProcessor_ProcessorComponent对象，代码块：return new DaggerComponentProcessor_ProcessorComponent(xProcessingEnv, externalPlugins);
以上生成ComponentCreatorImplementation对象:当前Factory类、Factory类名、变量（不存在变量）作为参数

将当前生成的ComponentCreatorImplementation对象存储在当前正在处理的ProcessorComponent对应的ComponentImplementation对象的属性的ShardImplementation对象的typeSpecsMap集合中，TypeSpecKind类型使用COMPONENT_CREATOR表示。

##四生成factoryMethod方法 ##

该方法的作用是实例化Factory对象。

**目标实现：**生成factory()方法

  public static ComponentProcessor.ProcessorComponent.Factory factory() {
    return new Factory();
  }

业务逻辑：

判断当前是否是subcomponent节点，因为不是所以调用createRootComponentFactoryMethod方法；
在当前ProcessorComponent存在Factory情况下，生成一个方法factory方法；

（1）先校验，当前ProcessorComponent不能存在方法名是factory&&factory方法无参&&没有使用static修饰，否则报错。还好我们存在的ProcessorComponent中的factory方法使用了static修饰了，否则即报错。
（2）生成的方法名是factory，public static修饰，ComponentProcessor.ProcessorComponent.Factory作为返回类型，代码块return new Factory()；

##五生成InterfaceMethod接口方法 ##

这里的逻辑极其复杂，一定要先认真查看上面的路由关系图，是当前实现component代码实现核心的关系图。

当前方法的作用是重写ProcessorComponent的入口方法，并且对当前入口方法实现，并且该入口方法实现过程中的依赖的一步步实现。

目标实现：

重写入口方法：DaggerComponentProcessor_ProcessorComponent重写了inject方法；

 @Override
 public void inject(ComponentProcessor processor) {
 	injectComponentProcessor(processor);
 }

入口方法的实现的代码块实现的方法：injectComponentProcessor(processor)代码块实现的injectComponentProcessor方法；

（1）injectComponentProcessor方法的实现

 @CanIgnoreReturnValue
 private ComponentProcessor injectComponentProcessor(ComponentProcessor instance) {
 	ComponentProcessor_MembersInjector.injectInjectBindingRegistry(instance, (InjectBindingRegistry) injectBindingRegistryImplProvider.get());
 	ComponentProcessor_MembersInjector.injectFactoryGenerator(instance, sourceFileGeneratorOfProvisionBinding());
 	ComponentProcessor_MembersInjector.injectMembersInjectorGenerator(instance, sourceFileGeneratorOfMembersInjectionBinding());
 	ComponentProcessor_MembersInjector.injectProcessingSteps(instance, immutableListOfXProcessingStep());
 	ComponentProcessor_MembersInjector.injectValidationBindingGraphPlugins(instance, validationBindingGraphPlugins());
 	ComponentProcessor_MembersInjector.injectExternalBindingGraphPlugins(instance, externalBindingGraphPlugins());
 	ComponentProcessor_MembersInjector.injectClearableCaches(instance, setOfClearableCache());
 	return instance;
 }

（2）ComponentProcessor_MembersInjector类的实现，代码自行去查看

代码块实现的依赖的一步步实现：injectComponentProcessor方法中(InjectBindingRegistry) injectBindingRegistryImplProvider.get()、sourceFileGeneratorOfProvisionBinding()等，以及sourceFileGeneratorOfProvisionBinding()方法的实现，以及该方法的依赖，依赖的依赖...
```
   private SourceFileGenerator<ProvisionBinding> sourceFileGeneratorOfProvisionBinding() {
     return SourceFileGeneratorsModule_FactoryGeneratorFactory.factoryGenerator(factoryGenerator(), bindCompilerOptionsProvider.get());
   }
```

（1）factoryGenerator方法实现

 	  private FactoryGenerator factoryGenerator() {
 	    return FactoryGenerator_Factory.newInstance(xFiler(), sourceVersion(), daggerTypesProvider.get(), daggerElementsProvider.get(), bindCompilerOptionsProvider.get(), kotlinMetadataUtil());
 	  }

（2）SourceFileGeneratorsModule_FactoryGeneratorFactory生成，代码不表；
...还有很长的依赖，下面我们看业务逻辑讲解

业务逻辑：###

由于涉及内容过多、过长，我们只对典型的讲解，如果真的想要透彻理解，还需要认证查看源码，这相当于只是讲解了同类型的生成规则。

业务逻辑代码和生成的代码不要混淆了。

ComponentRequestRepresentations的getComponentMethod方法：在DaggerComponentProcessor_ProcessorComponent类中重写ProcessorComponent的inject方法，并且将该方法存储在methodSpecsMap集合中，类型是MethodSpecKind.COMPONENT_METHOD:

DaggerComponentProcessor_ProcessorComponent类中生成的代码：

 	@Override
 	public void inject(ComponentProcessor processor) {
 		injectComponentProcessor(processor);//代码块的实现
 	}

业务逻辑代码：

 	//生成的方法继承自componentMethod方法
     return MethodSpec.overriding(
             componentMethod.methodElement(),
             MoreTypes.asDeclared(graph.componentTypeElement().asType()),
             types)
             .addCode(
                     //生成的新方法会关联到一系列的额外的代码
                     getRequestRepresentation(request)

                             .getComponentMethodImplementation(componentMethod, componentImplementation))
             .build();

injectComponentProcessor(processor);代码块及其后续一系列的实现通过getRequestRepresentation(request).getComponentMethodImplementation(componentMethod, componentImplementation)业务逻辑代码实现

通过路由关系图我们找到getRequestRepresentation(request)实际返回的是MembersInjectionRequestRepresentation对象，执行getComponentMethodImplementation方法，如何找到？

（1）当前request参数的key使用ProcessorComponent接口的inject方法中的ComponentProcessor对象作为type；
（2）通过Resolved解析关系图我们知道(自行查看)，该ComponentProcessor对象作为type生成的key匹配到ComponentProcessor作为type作为key对象（ComponentProcessor使用Inject修饰的7个变量）生成MembersInjectionBinding对象；
（3）通过路由component代码实现核心关系图我们最终定位到MembersInjectionRequestRepresentation对象

MembersInjectionRequestRepresentation对象执行getComponentMethodImplementation方法，因为ComponentProcessor类存在Inject修饰的变量，并且返回类型是void，所以使用调用如下代码：
```
 CodeBlock.of("$L;", membersInjectionInvocation(parameter, requestingClass).codeBlock())
```
执行membersInjectionInvocation方法，该方法调用MembersInjectionMethods类的getInjectExpression方法，参数是 ① binding.key() - 表示：ComponentProcessor类作为type的key对象、 ② CodeBlock.of("$N", target) - 表示：代码块ComponentProcessor processor、 ③ requestingClass - 表示：DaggerComponentProcessor_ProcessorComponent类名：

（1）该方法的目标实现：获取代码块injectComponentProcessor(processor);，以及该代码块后续的一系列操作；

（2）核心逻辑代码：

 //核心部件
 Expression expression =
         reentrantComputeIfAbsent(

                 injectMethodExpressions, key, k -> injectMethodExpression(binding, requestingClass));

injectMethodExpression方法生成目标方法injectComponentProcessor，及其后续的实现：

（1）生成方法名规则："inject" + 当前ComponentProcessor名称；

（2）当前方法使用private修饰，返回类型是ComponentProcessor，方法加上CanIgnoreReturnValue注解，参数ComponentProcessor instance,并且将当前方法作为代码块(实现目标：injectComponentProcessor(processor);)返回到上一步，该方法目标实现(及其后续一系列代码)

   @CanIgnoreReturnValue
   private ComponentProcessor injectComponentProcessor(ComponentProcessor instance) {
 	//代码块x部分 start
     ComponentProcessor_MembersInjector.injectInjectBindingRegistry(instance, (InjectBindingRegistry) injectBindingRegistryImplProvider.get());
     ComponentProcessor_MembersInjector.injectFactoryGenerator(instance, sourceFileGeneratorOfProvisionBinding());
     ComponentProcessor_MembersInjector.injectMembersInjectorGenerator(instance, sourceFileGeneratorOfMembersInjectionBinding());
     ComponentProcessor_MembersInjector.injectProcessingSteps(instance, immutableListOfXProcessingStep());
     ComponentProcessor_MembersInjector.injectValidationBindingGraphPlugins(instance, validationBindingGraphPlugins());
     ComponentProcessor_MembersInjector.injectExternalBindingGraphPlugins(instance, externalBindingGraphPlugins());
     ComponentProcessor_MembersInjector.injectClearableCaches(instance, setOfClearableCache());
 	//代码块部分 end
     return instance;
   }

代码块x部分的业务逻辑实现代码：

 	//核心：方法的代码实现
    methodBuilder.addCode(

        InjectionMethods.InjectionSiteMethod.invokeAll(
                injectionSites(binding),
                shardImplementation.name(),
                instance,
                membersInjectedType,
                request ->
                        //这才是延伸到后面需要的方法的重头戏
                        //e.g.
                        //1.InjectBindingRegistry
                        bindingExpressions
                                .getDependencyArgumentExpression(request, shardImplementation.name())
                                .codeBlock(),
                types,
                metadataUtil));

InjectionMethods.InjectionSiteMethod.invokeAll方法实现ComponentProcessor_MembersInjector类的生成以及代码块x部分代码块，该方法主要对ComponentProcessor类中7个使用Inject修饰的变量遍历调用invoke方法；
invoke方法：

（1）代码块中参数的引入代码如下，非常核心，该方法的目的是通过函数式调用外部方法，在于配合当前生成的方法引入方法参数。

 	if (!injectionSite.dependencies().isEmpty()) {
         arguments.addAll(
                 injectionSite.dependencies().stream().map(dependencyUsage).collect(toList()));
     }

（1）备注 - 这里实现的是MembersInjectionMethods类中前面提到的injectMethodExpression方法，我们会在下面讲解，这里暂且不表

 	bindingExpressions
             .getDependencyArgumentExpression(request, shardImplementation.name())
             .codeBlock()

（2）生成ComponentProcessor_MembersInjector类名逻辑代码：

     //生成的类名：当前Inject节点所在父类 + "_MembersInjector"
     //e.g.ComponentProcessor_MembersInjector
     ClassName enclosingClass =
             membersInjectorNameForType(asType(injectionSite.element().getEnclosingElement()));

（3）逻辑代码create方法：ComponentProcessor类中使用Inject修饰的变量生成ComponentProcessor_MembersInjector类的对应方法：

① 方法名生成逻辑：

 	String methodName = methodName(injectionSite);

② 生成方法逻辑在fieldProxy方法中实现，具体不表，自行查看。

（4）逻辑代码invokeMethod方法：步骤（3）在DaggerComponentProcessor_ProcessorComponent类中生成相应代码块，7个变量生成7个代码块如下：

 	ComponentProcessor_MembersInjector.injectInjectBindingRegistry(instance, (InjectBindingRegistry) injectBindingRegistryImplProvider.get());
     ComponentProcessor_MembersInjector.injectFactoryGenerator(instance, sourceFileGeneratorOfProvisionBinding());
     ComponentProcessor_MembersInjector.injectMembersInjectorGenerator(instance, sourceFileGeneratorOfMembersInjectionBinding());
     ComponentProcessor_MembersInjector.injectProcessingSteps(instance, immutableListOfXProcessingStep());
     ComponentProcessor_MembersInjector.injectValidationBindingGraphPlugins(instance, validationBindingGraphPlugins());
     ComponentProcessor_MembersInjector.injectExternalBindingGraphPlugins(instance, externalBindingGraphPlugins());
     ComponentProcessor_MembersInjector.injectClearableCaches(instance, setOfClearableCache());

下面我们再说说这里面的方法参数： (InjectBindingRegistry) injectBindingRegistryImplProvider.get()、sourceFileGeneratorOfProvisionBinding()、sourceFileGeneratorOfMembersInjectionBinding()、immutableListOfXProcessingStep()、validationBindingGraphPlugins()、externalBindingGraphPlugins()、setOfClearableCache()来源。

通过这里的实现可以对函数式有个更好的理解。

代码块的实现业务逻辑代码：

	//函数式
    request ->
            //这才是延伸到后面需要的方法的重头戏
            //e.g.
            //1.InjectBindingRegistry
            bindingExpressions
                    .getDependencyArgumentExpression(request, shardImplementation.name())
                    .codeBlock(),

特别强调：bindingExpressions.getDependencyArgumentExpression传递的参数request(表示ComponentProcessor使用Inject修饰的变量生成的依赖)和shardImplementation.name()(表示DaggerComponentProcessor_ProcessorComponent类)

后面的参数传递比较乱，业务逻辑方法的参数必须要整理清楚，否则非常容易搞错具体业务实现类。

代码块（一） `(InjectBindingRegistry) injectBindingRegistryImplProvider.get()`

表示代码块(InjectBindingRegistry) injectBindingRegistryImplProvider.get()的实现，以及该代码块实现需要的依赖。

实现该(InjectBindingRegistry) injectBindingRegistryImplProvider.get()代码块的逻辑代码如下：

调用ComponentRequestRepresentations类getDependencyArgumentExpression方法，用于生成injectBindingRegistryImplProvider.get()代码块,当前步骤涉及路由，我们先往下看，下下面重新讲解：
```
 Expression dependencyExpression = getDependencyExpression(bindingRequest, requestingClass);
```
因为InjectBindingRegistry类生成的依赖类型是RequestKind.INSTANCE && InjectBindingRegistry类不在DaggerComponentProcessor_ProcessorComponent类所在包下 && DaggerComponentProcessor_ProcessorComponent类可以访问到InjectBindingRegistry类，所以步骤1生成的代码块需要强转成(InjectBindingRegistry) injectBindingRegistryImplProvider.get()：
```
 if (dependencyRequest.kind().equals(RequestKind.INSTANCE)
         && !isTypeAccessibleFrom(dependencyType, requestingClass.packageName())
         && isRawTypeAccessible(dependencyType, requestingClass.packageName())) {
     return dependencyExpression.castTo(types.erasure(dependencyType));
 }
```

讲解完成了，我们这里详细说下：

Expression dependencyExpression = getDependencyExpression(bindingRequest, requestingClass)

getDependencyExpression方法具体实现如下：

  public Expression getDependencyExpression(BindingRequest request, ClassName requestingClass) {

    return getRequestRepresentation(request).getDependencyExpression(requestingClass);
}

通过路由关系图找到getRequestRepresentation方法返回的RequestRepresentation对象是DelegateRequestRepresentation类；

（1）Resolved解析关系图我们知道ComponentProcessor类使用Inject修饰的injectBindingRegistry变量匹配到InjectBindingRegistryModule接口的injectBindingRegistry方法;
（2）通过路由关系图最终解析到DelegateRequestRepresentation类；

DelegateRequestRepresentation类调用getDependencyExpression方法生成的Expression对象；

（1）该方法调用ComponentRequestRepresentations类的getDependencyExpression方法，参数request（当前InjectBindingRegistryModule接口的injectBindingRegistry方法的参数InjectBindingRegistryImpl类型生成的对象）和requestingClass(表示DaggerComponentProcessor_ProcessorComponent类)
（2）通过路由我们知道最终调用的是DerivedFromFrameworkInstanceRequestRepresentation对象的getDependencyExpression方法，参数是bindingRequest(binding.key(), RequestKind.INSTANCE)和FrameworkType.PROVIDER
① Resolved解析关系图我们知道InjectBindingRegistryModule接口的injectBindingRegistry方法匹配到的是InjectBindingRegistryImpl类（使用了Singlon注解）Inject修饰的构造函数；
②执行FrameworkType.to方法，返回的代码块是$L.get(),$L来源于componentRequestRepresentations.getDependencyExpression(frameworkRequest, requestingClass)，参数frameworkRequest（InjectBindingRegistryImpl类作为type生成的key和RequestKind.PROVIDER生成的对象）和requestingClass（表示DaggerComponentProcessor_ProcessorComponent类）

步骤2（2）②通过路由知道调用的是ProviderInstanceRequestRepresentation对象调用getDependencyExpression方法；

注： InjectionOrProvisionProviderCreationExpression对象（代码块被DoubleCheck.provider包裹）作为FrameworkFieldInitializer对象的参数；FrameworkFieldInitializer对象作为ProviderInstanceRequestRepresentation对象的参数；
（1）调用FrameworkFieldInitializer对象的memberSelect()：该方法作用是初始化变量，并且对该变量生成相关代码块实现变量实例化，该方法重点是调用initializeField()方法；
① 调用 InjectionOrProvisionProviderCreationExpression对象对象的creationExpression()方法，该方法实现InjectBindingRegistryImpl类生成的代码块：
①①调用generatedClassNameForBinding生成类名：InjectBindingRegistryImpl_Factory；
①②实现的代码块是DoubleCheck.provider(InjectBindingRegistryImpl_Factory.create(...))，这里的...调用componentRequestRepresentations.getCreateMethodArgumentsCodeBlock()方法实现具体代码块，这里暂且不表；
② 调用getOrCreateField()生成变量，并且最终生成this.injectBindingRegistryImplProvider = DoubleCheck.provider(InjectBindingRegistryImpl_Factory.create(...))代码块，变量如下：
```
	  @SuppressWarnings("rawtypes")
	  private Provider injectBindingRegistryImplProvider;
```

DoubleCheck.provider(InjectBindingRegistryImpl_Factory.create(...))中...调用componentRequestRepresentations.getCreateMethodArgumentsCodeBlock()方法实现是如下代码块的参数:

 this.injectBindingRegistryImplProvider = DoubleCheck.provider(InjectBindingRegistryImpl_Factory.create(
 	daggerElementsProvider, 
 	daggerTypesProvider, 
 	messagerProvider, 
 	injectValidatorProvider, 
 	keyFactoryProvider, 
 	bindingFactoryProvider, 
 	bindCompilerOptionsProvider));

上面代码块添加到ShardImplementation类的initializations集合，用于在DaggerComponentProcessor_ProcessorComponent类生成的initialize方法中实现的代码块收集。

同理得到如下代码块以及代码块的变量：

this.xProcessingEnvProvider = InstanceFactory.create(xProcessingEnvParam);
this.daggerElementsProvider = DoubleCheck.provider(ProcessingEnvironmentModule_DaggerElementsFactory.create(xProcessingEnvProvider));
this.daggerTypesProvider = DoubleCheck.provider(ProcessingEnvironmentModule_DaggerTypesFactory.create(xProcessingEnvProvider, daggerElementsProvider));
this.messagerProvider = ProcessingEnvironmentModule_MessagerFactory.create(xProcessingEnvProvider);
this.kotlinMetadataFactoryProvider = DoubleCheck.provider(KotlinMetadataFactory_Factory.create());
this.kotlinMetadataUtilProvider = KotlinMetadataUtil_Factory.create(kotlinMetadataFactoryProvider);
this.injectionAnnotationsProvider = InjectionAnnotations_Factory.create(daggerElementsProvider, kotlinMetadataUtilProvider);
this.membersInjectionValidatorProvider = MembersInjectionValidator_Factory.create(injectionAnnotationsProvider);
this.dependencyRequestValidatorProvider = DependencyRequestValidator_Factory.create(membersInjectionValidatorProvider, injectionAnnotationsProvider, kotlinMetadataUtilProvider, daggerElementsProvider);
this.processingOptionsProvider = ProcessingEnvironmentModule_ProcessingOptionsFactory.create(xProcessingEnvProvider);
this.processingEnvironmentCompilerOptionsProvider = ProcessingEnvironmentCompilerOptions_Factory.create(messagerProvider, processingOptionsProvider, daggerElementsProvider);
this.bindCompilerOptionsProvider = SingleCheck.provider((Provider) processingEnvironmentCompilerOptionsProvider);
this.injectValidatorProvider = DoubleCheck.provider(InjectValidator_Factory.create(daggerTypesProvider, daggerElementsProvider, dependencyRequestValidatorProvider, bindCompilerOptionsProvider, injectionAnnotationsProvider, kotlinMetadataUtilProvider));
this.keyFactoryProvider = KeyFactory_Factory.create(daggerTypesProvider, daggerElementsProvider, injectionAnnotationsProvider);
this.dependencyRequestFactoryProvider = DependencyRequestFactory_Factory.create(keyFactoryProvider, injectionAnnotationsProvider);
this.injectionSiteFactoryProvider = InjectionSiteFactory_Factory.create(daggerTypesProvider, daggerElementsProvider, dependencyRequestFactoryProvider);
this.bindingFactoryProvider = BindingFactory_Factory.create(daggerTypesProvider, daggerElementsProvider, keyFactoryProvider, dependencyRequestFactoryProvider, injectionSiteFactoryProvider, injectionAnnotationsProvider, kotlinMetadataUtilProvider);
this.injectBindingRegistryImplProvider = DoubleCheck.provider    this.injectBindingRegistryImplProvider = DoubleCheck.provider(InjectBindingRegistryImpl_Factory.create(daggerElementsProvider, daggerTypesProvider, messagerProvider, injectValidatorProvider, keyFactoryProvider, bindingFactoryProvider, bindCompilerOptionsProvider));

针对处理过的代码块进行了存储记忆，下次再次执行直接调用之前用过的即可。

这里大家有没有一个疑问，这里例如InjectBindingRegistryImpl_Factory类在哪里实现的？？？，目前为止没发现，我们可以往后再看。

代码块（二） `sourceFileGeneratorOfProvisionBinding()`

sourceFileGeneratorOfProvisionBinding()代码块的实现，以及该代码块实现需要的依赖。

业务逻辑：

componentProcessor类中使用Inject修饰的变量factoryGenerator匹配到的是SourceFileGeneratorsModule类的factoryGenerator方法，那么在路由关系图中最终定位的是执行PrivateMethodRequestRepresentation类（SimpleMethodRequestRepresentation类作为参数）的getDependencyExpression方法：

 @Override
 Expression getDependencyExpression(ClassName requestingClass) {

     return Expression.create(
             returnType(),
             requestingClass.equals(shardImplementation.name())
                     ? methodCall()
                     : CodeBlock.of("$L.$L", shardImplementation.shardFieldReference(), methodCall()));
 }

调用methodCall()方法

     @Override
     protected CodeBlock methodCall() {
         return CodeBlock.of("$N()", methodName());
     }

（1）生成的方法名：sourceFileGeneratorOfProvisionBinding，规则是参数类型首字母小写然后使用Of拼接泛型，如果存在超过1个泛型，那么使用And拼接，核心代码如下：
```
 	KeyVariableNamer.name(request.key())
```

（2）①methodCall()方法生成的代码：

 	  private SourceFileGenerator<ProvisionBinding> sourceFileGeneratorOfProvisionBinding() {
 	    return SourceFileGeneratorsModule_FactoryGeneratorFactory.factoryGenerator(factoryGenerator(), bindCompilerOptionsProvider.get());
 	  }

② methodCall业务代码：

 	shardImplementation.addMethod(
             PRIVATE_METHOD,
             methodBuilder(methodName)
                     .addModifiers(PRIVATE)
                     .returns(TypeName.get(returnType()))
                     .addStatement(
                             "return $L",
                             wrappedRequestRepresentation
                                     .getDependencyExpression(shardImplementation.name())
                                     .codeBlock())
                     .build());

以上同样的方式生成factoryGenerator()方法，bindCompilerOptionsProvider.get()前面已经被生成，直接在记忆存储中拿过来用即可；

代码块（三） `sourceFileGeneratorOfMembersInjectionBinding()`###

sourceFileGeneratorOfMembersInjectionBinding()代码块的实现，以及该代码块实现需要的依赖。

雷同于以上方法在此不表

代码块（四） `immutableListOfXProcessingStep()`

immutableListOfXProcessingStep()代码块的实现，以及该代码块实现需要的依赖。

雷同于以上方法在此不表

代码块（五） `validationBindingGraphPlugins()`

validationBindingGraphPlugins()代码块的实现，以及该代码块实现需要的依赖。

雷同于以上方法在此不表

代码块（六）`externalBindingGraphPlugins()`

externalBindingGraphPlugins()代码块的实现，以及该代码块实现需要的依赖。

雷同于以上方法在此不表

代码块（七） `setOfClearableCache()`

setOfClearableCache()代码块的实现，以及该代码块实现需要的依赖。

雷同于以上方法在此不表

##六当前component节点中的subcomponent节点实现代码 ##

针对子component走一遍上面的方法，并且将生成的Component类存储于ShardImplementation类的typeSpecsMap集合，类型为TypeSpecKind.SUBCOMPONENT。

生成类名：TopLevelImplementationComponentImpl，并且该类是DaggerComponentProcessor_ProcessorComponent内部类；
TopLevelImplementationComponentImpl 继承 TopLevelImplementationComponent；

TopLevelImplementationComponent内部类Factory生成TopLevelImplementationComponentFactory类：

 private static final class TopLevelImplementationComponentFactory implements TopLevelImplementationComponent.Factory {
     private final DaggerComponentProcessor_ProcessorComponent processorComponent;
 
     private TopLevelImplementationComponentFactory(
         DaggerComponentProcessor_ProcessorComponent processorComponent) {
       this.processorComponent = processorComponent;
     }
 
     @Override
     public TopLevelImplementationComponent create(BindingGraph bindingGraph) {
       Preconditions.checkNotNull(bindingGraph);
       return new TopLevelImplementationComponentImpl(processorComponent, bindingGraph);
     }
   }

因为TopLevelImplementationComponentImpl类中不存在返回类型是subcomponent节点类型的方法，所以不需要调用createSubcomponentFactoryMethod方法；
对当前TopLevelImplementationComponentImpl类入口方法层层查找依赖，代码如下：
```
 CurrentImplementationSubcomponent.Builder currentImplementationSubcomponentBuilder()
```

（1）currentImplementationSubcomponentBuilder()方法的依赖的key匹配到CurrentImplementationSubcomponent节点（①component节点关系图-subcomponent节点生成的对象的key是subcomponent.creator作为type生成的key，②Resolved解析代码得知-SubcomponentDeclaration声明转换成的ProvisionBinding对象的key沿用SubcomponentDeclaration声明的key属性）；

（2）通过路由解析，我们SubcomponentCreatorRequestRepresentation类的getComponentMethodImplementation方法，其实调用的是getDependencyExpression方法（模板模式决定调用该方法），①逻辑代码如下：

 	@Override
     Expression getDependencyExpression(ClassName requestingClass) {
         //new subcomponent.creator(参数)，参数使用的是当前currentComponent及其直到父级component节点（排除当前currentComponent节点）
         return Expression.create(
                 binding.key().type().java(),
                 "new $T($L)",
                 shardImplementation.getSubcomponentCreatorSimpleName(binding.key()),
                 shardImplementation.componentFieldsByImplementation().values().stream()
                         .map(field -> CodeBlock.of("$N", field))
                         .collect(CodeBlocks.toParametersCodeBlock()));
     }

② 在TopLevelImplementationComponentImpl类中实现的目标代码：

     @Override
     public CurrentImplementationSubcomponent.Builder currentImplementationSubcomponentBuilder() {
       return new CurrentImplementationSubcomponentBuilder(processorComponent, topLevelImplementationComponentImpl);
     }

对TopLevelImplementationComponent接口关联的CurrentImplementationSubcomponent接口执行代码生成工作，我们插播一下，以start开始，end结束

TopLevelImplementationComponent接口关联的CurrentImplementationSubcomponent接口 start

在DaggerComponentProcessor_ProcessorComponent内部生成CurrentImplementationSubcomponentImpl类名；
CurrentImplementationSubcomponentImpl类继承CurrentImplementationSubcomponent；
对CurrentImplementationSubcomponent.Builder生成代码，逻辑如下：

（1）private static final 修饰；
（2）继承 CurrentImplementationSubcomponent.Builder；
（3）构造函数传递DaggerComponentProcessor_ProcessorComponent和TopLevelImplementationComponentImpl作为参数；外部传递值，并且将这两个参数生成类变量（private final修饰）；
（4）类添加变量:对Builder中使用@BindsInstance修饰的方法参数作为当前参数，并且使用private修饰;
（5）Builder类中的@BindsInstance修饰的方法重写
（6）Builder类中的build方法重写

（7）根据以上规则，生成的目标代码如下：

 	private static final class CurrentImplementationSubcomponentBuilder implements CurrentImplementationSubcomponent.Builder {
 	    private final DaggerComponentProcessor_ProcessorComponent processorComponent;
 	
 	    private final TopLevelImplementationComponentImpl topLevelImplementationComponentImpl;
 	
 	    private BindingGraph bindingGraph;
 	
 	    private Optional<ComponentImplementation> parentImplementation;
 	
 	    private Optional<ComponentRequestRepresentations> parentRequestRepresentations;
 	
 	    private Optional<ComponentRequirementExpressions> parentRequirementExpressions;
 	
 	    private CurrentImplementationSubcomponentBuilder(
 	        DaggerComponentProcessor_ProcessorComponent processorComponent,
 	        TopLevelImplementationComponentImpl topLevelImplementationComponentImpl) {
 	      this.processorComponent = processorComponent;
 	      this.topLevelImplementationComponentImpl = topLevelImplementationComponentImpl;
 	    }
 	
 	    @Override
 	    public CurrentImplementationSubcomponentBuilder bindingGraph(BindingGraph bindingGraph) {
 	      this.bindingGraph = Preconditions.checkNotNull(bindingGraph);
 	      return this;
 	    }
 	
 	    @Override
 	    public CurrentImplementationSubcomponentBuilder parentImplementation(
 	        Optional<ComponentImplementation> parentImplementation) {
 	      this.parentImplementation = Preconditions.checkNotNull(parentImplementation);
 	      return this;
 	    }
 	
 	    @Override
 	    public CurrentImplementationSubcomponentBuilder parentRequestRepresentations(
 	        Optional<ComponentRequestRepresentations> parentRequestRepresentations) {
 	      this.parentRequestRepresentations = Preconditions.checkNotNull(parentRequestRepresentations);
 	      return this;
 	    }
 	
 	    @Override
 	    public CurrentImplementationSubcomponentBuilder parentRequirementExpressions(
 	        Optional<ComponentRequirementExpressions> parentRequirementExpressions) {
 	      this.parentRequirementExpressions = Preconditions.checkNotNull(parentRequirementExpressions);
 	      return this;
 	    }
 	
 	    @Override
 	    public CurrentImplementationSubcomponent build() {
 	      Preconditions.checkBuilderRequirement(bindingGraph, BindingGraph.class);
 	      Preconditions.checkBuilderRequirement(parentImplementation, Optional.class);
 	      Preconditions.checkBuilderRequirement(parentRequestRepresentations, Optional.class);
 	      Preconditions.checkBuilderRequirement(parentRequirementExpressions, Optional.class);
 	      return new CurrentImplementationSubcomponentImpl(processorComponent, topLevelImplementationComponentImpl, bindingGraph, parentImplementation, parentRequestRepresentations, parentRequirementExpressions);
 	    }
 	  }

当前CurrentImplementationSubcomponent不存在返回类型是subcomponent的方法；
CurrentImplementationSubcomponent入口方法查找层层依赖关系（很重要），componentImplementation()方法表示入口方法：

（1）生成目标代码如下：

        @Override
 	    public ComponentImplementation componentImplementation() {
 	      return componentImplementationProvider.get();
 	    }

（2）return componentImplementationProvider.get();代码块是调用DerivedFromFrameworkInstanceRequestRepresentation类的getComponentMethodImplementation方法实现的，componentImplementationProvider.get();代码块的实现是调用getDependencyExpression()方法；
（3）componentRequestRepresentations.getDependencyExpression()方法完成对componentImplementationProvider的依赖实现工作，定位到调用ProviderInstanceRequestRepresentation类（FrameworkFieldInitializer对象作为当前类参数，并且InjectionOrProvisionProviderCreationExpression对象作为FrameworkFieldInitializer对象参数）的getDependencyExpression方法；
1）调用FrameworkFieldInitializer类memberSelect方法，initializeField方法执行的

① InjectionOrProvisionProviderCreationExpression类调用creationExpression方法，最终生成的代码块如下

       DelegateFactory.setDelegate(componentImplementationProvider,
               DoubleCheck.provider(
                       ComponentImplementation_Factory.create(
                               parentImplementationProvider,
                               provideChildComponentImplementationFactoryProvider,
                               componentRequestRepresentationsProvider,
                               componentCreatorImplementationFactoryProvider,
                               bindingGraphProvider,
                               componentNamesProvider,
                               processorComponent.bindCompilerOptionsProvider,
                               processorComponent.daggerElementsProvider,
                               processorComponent.daggerTypesProvider,
                               processorComponent.kotlinMetadataUtilProvider,
                               processorComponent.messagerProvider
                       )
               )
       );

② 当前Inect修饰的ComponentImplementation构造函数的参数作为依赖依次执行路由（自行认真查看路由）：
②.1 第一个参数，@ParentComponent Optional parent：匹配到的是CurrentImplementationSubcomponent.Builder接口下使用@BindsInstance修饰的parentImplementation方法，执行的是ProviderInstanceRequestRepresentation对象(FrameworkFieldInitializer对象作为当前类参数，InjectionOrProvisionProviderCreationExpression作为FrameworkFieldInitializer对象参数)的getDependencyExpression方法（为什么找到的是ProviderInstanceRequestRepresentation对象，因为requestKind是PROVIDER，沿用的是步骤5（2）DerivedFromFrameworkInstanceRequestRepresentation中的参数），创建变量private Provider<Optional<ComponentImplementation>> parentImplementationProvider;，最终实现的代码块：
```
 	this.parentImplementationProvider = InstanceFactory.create(parentImplementationParam);
```

②.2 第二个参数，ChildComponentImplementationFactory childComponentImplementationFactory：匹配到的是ChildComponentImplementationFactoryModule接口的provideChildComponentImplementationFactory方法；执行的是ProviderInstanceRequestRepresentation对象(FrameworkFieldInitializer对象作为当前类参数，InstanceFactoryCreationExpression作为FrameworkFieldInitializer对象参数)的getDependencyExpression方法，最终实现的代码块：

       this.provideChildComponentImplementationFactoryProvider =
               CurrentImplementationSubcomponent_ChildComponentImplementationFactoryModule_ProvideChildComponentImplementationFactoryFactory.
                       create(
                               topLevelImplementationComponentImpl.currentImplementationSubcomponentBuilderProvider,
                               componentImplementationProvider, componentRequestRepresentationsProvider,
                               componentRequirementExpressionsProvider
                       );

②.3-5同理，在此不表
②.6 下面的参数都是从父级类中沿用，在此不表。

CurrentImplementationSubcomponent不存在childComponent节点；
如果当前currentComponent的绑定超出了3500，那么以3500为一个单位，对每个单位生成对应的类；
实现CurrentImplementationSubcomponentImpl构造函数和 initialize方法；
CurrentImplementationSubcomponentImpl类修饰符 private static final
类中添加变量：这里才算真正添加变量，前面工作都是收集在一个集合中；

为什么要这么做？为了处理先后顺序；

添加类中的的方法；
添加类的内部类；
没用上，这里不管它了。

TopLevelImplementationComponent接口关联的CurrentImplementationSubcomponent接口 end

后面可以不表了，

##七如果当前component的绑定超出了3500，那么以3500为一个单位，对每个单位生成对应的类 ##

但是我不明白为什么，要在这里重新执行一遍generate方法。感觉多此一举！！！

总结

上面说的xx_Factory类在哪里生成，这里给的答案是在ComponentProcessor类中调用injectBindingRegistry.generateSourcesForRequiredBindings()方法，自行去查看.

很感谢自己坚持到最后，这里的代码真的是乱的一比！！！Dagger2.38.1最核心的源码部分已经讲解完毕了！后面还有针对如hint、android上的使用部分源码、架构（内部代码越是后面越是一团糟，可能是我个人能力有限，很多地方每一个思路，感觉代码是拼凑上去的，但是整体架构还是有值得我们学习和借鉴的）、Dagger注解的理解。

可在QQ群：575306647 讨论

源码解析github地址

8.Dagger2.38.1源码解析-Demo梳理component节点生成代码

前言

ShardImplementation的generate完成component代码逻辑的生成

一 生成类名

目标实现：

业务逻辑：###

代码块（一） (InjectBindingRegistry) injectBindingRegistryImplProvider.get()

代码块（二） sourceFileGeneratorOfProvisionBinding()

代码块（三） sourceFileGeneratorOfMembersInjectionBinding()###

代码块（四） immutableListOfXProcessingStep()

代码块（五） validationBindingGraphPlugins()

代码块（六）externalBindingGraphPlugins()

代码块（七） setOfClearableCache()

TopLevelImplementationComponent接口关联的CurrentImplementationSubcomponent接口 start

TopLevelImplementationComponent接口关联的CurrentImplementationSubcomponent接口 end

总结

一生成类名

代码块（一） `(InjectBindingRegistry) injectBindingRegistryImplProvider.get()`

代码块（二） `sourceFileGeneratorOfProvisionBinding()`

代码块（三） `sourceFileGeneratorOfMembersInjectionBinding()`###

代码块（四） `immutableListOfXProcessingStep()`

代码块（五） `validationBindingGraphPlugins()`

代码块（六）`externalBindingGraphPlugins()`

代码块（七） `setOfClearableCache()`