Android Dagger2 框架编译时注解处理模块深度剖析(二)

一、引言

在 Android 开发领域，依赖注入（Dependency Injection，简称 DI）是一种至关重要的设计模式，它能够显著降低代码的耦合度，增强代码的可测试性与可维护性。Dagger 2 作为一款广泛应用于 Android 和 Java 平台的依赖注入框架，其核心特性在于借助编译时注解处理来生成高效的依赖注入代码，从而避免了运行时反射带来的性能损耗。本文将深入探究 Dagger 2 框架的编译时注解处理模块，从源码层面详细解析其工作原理、实现机制以及各个关键步骤。

二、编译时注解处理基础

2.1 注解与注解处理器概述

注解（Annotation）是 Java 语言中的一种元数据机制，它为代码添加额外的信息，而不影响代码的实际逻辑。注解可以应用于类、方法、字段等元素上，用于提供配置信息、标记特定行为等。

注解处理器（Annotation Processor）则是在编译时对注解进行处理的工具。当 Java 编译器编译代码时，注解处理器会扫描代码中的注解，并根据注解的信息生成新的代码或执行特定的处理逻辑。注解处理器通常继承自 javax.annotation.processing.AbstractProcessor 类，并实现其 process 方法。

2.2 Java 注解处理流程

Java 注解处理的基本流程如下：

编译器启动：当开发者执行编译命令时，Java 编译器启动。
注解扫描：编译器在编译过程中扫描源代码中的注解。
注解处理器调用：如果发现有注解处理器注册，编译器会调用相应的注解处理器。
注解处理：注解处理器对扫描到的注解进行处理，可能会生成新的代码文件。
代码生成：注解处理器根据注解信息生成新的 Java 代码文件。
编译生成的代码：编译器继续编译生成的新代码文件。
编译完成：最终生成可执行的字节码文件。

2.3 注解处理器的注册

注解处理器需要在 META-INF/services 目录下创建一个名为 javax.annotation.processing.Processor 的文件，并在该文件中列出所有要注册的注解处理器的全限定类名。例如：

plaintext

java 复制代码

com.example.MyAnnotationProcessor

三、Dagger 2 编译时注解处理模块概述

3.1 Dagger 2 注解处理模块的作用

Dagger 2 的编译时注解处理模块是整个框架的核心部分，它负责在编译时解析 Dagger 2 相关的注解（如 @Inject、@Module、@Provides、@Component 等），并根据这些注解信息生成实现依赖注入所需的代码。通过编译时生成代码，Dagger 2 避免了运行时反射带来的性能开销，提高了应用的运行效率。

3.2 Dagger 2 主要注解介绍

3.2.1 `@Inject`

@Inject 注解用于标记需要注入的构造函数、字段或方法。当 Dagger 2 遇到被 @Inject 注解的元素时，会尝试为其提供依赖。

java

java 复制代码

import javax.inject.Inject;

// 标记构造函数可用于注入依赖
public class Engine {
    @Inject
    public Engine() {
        // 构造函数逻辑
    }
}

// 使用 @Inject 注解字段，表明该字段需要注入依赖
public class Car {
    @Inject
    Engine engine;

    public Car() {
        // 构造函数逻辑
    }
}

3.2.2 `@Module`

@Module 注解用于定义提供依赖的模块类。模块类中的方法可以提供各种依赖对象。

java

java 复制代码

import dagger.Module;
import dagger.Provides;

// 使用 @Module 注解标记该类为一个模块类
@Module
public class CarModule {
    // 使用 @Provides 注解标记的方法用于提供依赖
    @Provides
    public Engine provideEngine() {
        return new Engine();
    }
}

3.2.3 `@Provides`

@Provides 注解用于标记模块类中的方法，这些方法负责创建和提供依赖对象。

java

java 复制代码

import dagger.Module;
import dagger.Provides;

@Module
public class CarModule {
    @Provides
    public Tire provideTire() {
        return new Tire();
    }
}

3.2.4 `@Component`

@Component 注解用于定义组件接口，组件是连接依赖和注入点的桥梁。组件接口中定义的方法用于获取依赖对象或进行注入操作。

java

java 复制代码

import dagger.Component;

// 使用 @Component 注解标记该接口为一个组件接口，并指定使用的模块
@Component(modules = {CarModule.class})
public interface CarComponent {
    // 方法用于获取 Car 实例
    Car getCar();
    // 方法用于将依赖注入到 MainActivity 中
    void inject(MainActivity activity);
}

四、Dagger 2 注解处理器核心类解析

4.1 `DaggerProcessor` 类

DaggerProcessor 是 Dagger 2 注解处理的核心类，它继承自 AbstractProcessor 类，负责处理 Dagger 2 相关的注解。以下是简化后的 DaggerProcessor 类代码：

java

java 复制代码

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;
import java.util.Set;

// Dagger 2 注解处理器核心类
public class DaggerProcessor extends AbstractProcessor {

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        // 返回该注解处理器支持处理的注解类型
        return Set.of(
                "javax.inject.Inject",
                "dagger.Module",
                "dagger.Provides",
                "dagger.Component"
        );
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        // 返回该注解处理器支持的 Java 源代码版本
        return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // 处理注解的核心方法
        // 遍历所有支持的注解类型
        for (TypeElement annotation : annotations) {
            // 获取被该注解标记的所有元素
            Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(annotation);
            for (Element element : annotatedElements) {
                // 根据不同的注解类型进行不同的处理
                if (element.getAnnotation(Inject.class) != null) {
                    // 处理 @Inject 注解的元素
                    processInjectAnnotation(element);
                } else if (element.getAnnotation(Module.class) != null) {
                    // 处理 @Module 注解的元素
                    processModuleAnnotation(element);
                } else if (element.getAnnotation(Provides.class) != null) {
                    // 处理 @Provides 注解的元素
                    processProvidesAnnotation(element);
                } else if (element.getAnnotation(Component.class) != null) {
                    // 处理 @Component 注解的元素
                    processComponentAnnotation(element);
                }
            }
        }
        return true;
    }

    private void processInjectAnnotation(Element element) {
        // 处理 @Inject 注解的具体逻辑
        // 例如，解析构造函数、字段或方法的注入信息
    }

    private void processModuleAnnotation(Element element) {
        // 处理 @Module 注解的具体逻辑
        // 例如，解析模块类中的 @Provides 方法
    }

    private void processProvidesAnnotation(Element element) {
        // 处理 @Provides 注解的具体逻辑
        // 例如，解析提供依赖的方法的返回类型和参数
    }

    private void processComponentAnnotation(Element element) {
        // 处理 @Component 注解的具体逻辑
        // 例如，生成组件接口的实现类
    }
}

4.1.1 `getSupportedAnnotationTypes` 方法

该方法返回一个 Set<String> 集合，包含了该注解处理器支持处理的注解类型的全限定类名。在 Dagger 2 中，主要支持处理 @Inject、@Module、@Provides 和 @Component 注解。

4.1.2 `getSupportedSourceVersion` 方法

该方法返回该注解处理器支持的 Java 源代码版本。通常返回 SourceVersion.latestSupported() 以支持最新的 Java 版本。

4.1.3 `process` 方法

这是注解处理器的核心方法，用于处理扫描到的注解。在该方法中，首先遍历所有支持的注解类型，然后获取被该注解标记的所有元素。对于每个元素，根据其注解类型调用相应的处理方法。

4.2 注解解析工具类

Dagger 2 还使用了一些工具类来辅助解析注解信息，例如 AnnotationParser 类。以下是一个简化的 AnnotationParser 类示例：

java

java 复制代码

import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.TypeMirror;
import java.util.ArrayList;
import java.util.List;

// 注解解析工具类
public class AnnotationParser {

    // 解析 @Component 注解的模块信息
    public static List<TypeElement> parseComponentModules(Element componentElement) {
        List<TypeElement> moduleElements = new ArrayList<>();
        // 获取 @Component 注解的镜像
        AnnotationMirror componentAnnotation = getAnnotationMirror(componentElement, Component.class);
        if (componentAnnotation != null) {
            // 获取 @Component 注解的 modules 属性值
            for (AnnotationValue value : getAnnotationValue(componentAnnotation, "modules")) {
                if (value.getValue() instanceof DeclaredType) {
                    DeclaredType declaredType = (DeclaredType) value.getValue();
                    TypeElement moduleElement = (TypeElement) declaredType.asElement();
                    moduleElements.add(moduleElement);
                }
            }
        }
        return moduleElements;
    }

    // 获取元素上指定注解的镜像
    private static AnnotationMirror getAnnotationMirror(Element element, Class<?> annotationClass) {
        for (AnnotationMirror mirror : element.getAnnotationMirrors()) {
            DeclaredType annotationType = mirror.getAnnotationType();
            TypeElement annotationElement = (TypeElement) annotationType.asElement();
            if (annotationElement.getQualifiedName().contentEquals(annotationClass.getName())) {
                return mirror;
            }
        }
        return null;
    }

    // 获取注解的指定属性值
    private static List<AnnotationValue> getAnnotationValue(AnnotationMirror annotation, String attributeName) {
        List<AnnotationValue> values = new ArrayList<>();
        for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : annotation.getElementValues().entrySet()) {
            if (entry.getKey().getSimpleName().contentEquals(attributeName)) {
                if (entry.getValue().getValue() instanceof List) {
                    List<?> list = (List<?>) entry.getValue().getValue();
                    for (Object item : list) {
                        if (item instanceof AnnotationValue) {
                            values.add((AnnotationValue) item);
                        }
                    }
                }
            }
        }
        return values;
    }
}

4.2.1 `parseComponentModules` 方法

该方法用于解析 @Component 注解的 modules 属性，返回一个包含所有模块类元素的列表。

4.2.2 `getAnnotationMirror` 方法

该方法用于获取元素上指定注解的镜像，通过遍历元素的所有注解镜像，找到与指定注解类名匹配的镜像。

4.2.3 `getAnnotationValue` 方法

该方法用于获取注解的指定属性值，通过遍历注解的元素值映射，找到与指定属性名匹配的值。

五、`@Inject` 注解处理流程

5.1 扫描 `@Inject` 注解元素

在 DaggerProcessor 的 process 方法中，当扫描到 @Inject 注解的元素时，会调用 processInjectAnnotation 方法进行处理。以下是简化的处理逻辑：

java

java 复制代码

private void processInjectAnnotation(Element element) {
    if (element.getKind() == ElementKind.CONSTRUCTOR) {
        // 处理构造函数注入
        processConstructorInject((ExecutableElement) element);
    } else if (element.getKind() == ElementKind.FIELD) {
        // 处理字段注入
        processFieldInject((VariableElement) element);
    } else if (element.getKind() == ElementKind.METHOD) {
        // 处理方法注入
        processMethodInject((ExecutableElement) element);
    }
}

5.1.1 `processConstructorInject` 方法

java

java 复制代码

private void processConstructorInject(ExecutableElement constructorElement) {
    // 获取构造函数所在的类元素
    TypeElement enclosingElement = (TypeElement) constructorElement.getEnclosingElement();
    // 获取构造函数的参数列表
    List<? extends VariableElement> parameters = constructorElement.getParameters();
    for (VariableElement parameter : parameters) {
        // 处理构造函数的参数注入信息
        processParameterInject(parameter);
    }
    // 生成构造函数注入的相关代码
    generateConstructorInjectCode(enclosingElement, constructorElement);
}

5.1.2 `processFieldInject` 方法

java

java 复制代码

private void processFieldInject(VariableElement fieldElement) {
    // 获取字段所在的类元素
    TypeElement enclosingElement = (TypeElement) fieldElement.getEnclosingElement();
    // 生成字段注入的相关代码
    generateFieldInjectCode(enclosingElement, fieldElement);
}

5.1.3 `processMethodInject` 方法

java

java 复制代码

private void processMethodInject(ExecutableElement methodElement) {
    // 获取方法所在的类元素
    TypeElement enclosingElement = (TypeElement) methodElement.getEnclosingElement();
    // 获取方法的参数列表
    List<? extends VariableElement> parameters = methodElement.getParameters();
    for (VariableElement parameter : parameters) {
        // 处理方法的参数注入信息
        processParameterInject(parameter);
    }
    // 生成方法注入的相关代码
    generateMethodInjectCode(enclosingElement, methodElement);
}

5.2 生成注入代码

5.2.1 生成构造函数注入代码

java

java 复制代码

private void generateConstructorInjectCode(TypeElement enclosingElement, ExecutableElement constructorElement) {
    StringBuilder codeBuilder = new StringBuilder();
    // 生成类名
    String className = enclosingElement.getSimpleName().toString();
    codeBuilder.append("public class ").append(className).append("Injector {\n");
    // 生成构造函数注入逻辑
    codeBuilder.append("    public static ").append(className).append(" create() {\n");
    List<? extends VariableElement> parameters = constructorElement.getParameters();
    for (VariableElement parameter : parameters) {
        // 获取参数类型
        TypeMirror parameterType = parameter.asType();
        // 假设这里有一个方法可以获取依赖的实例
        codeBuilder.append("        ").append(getDependencyInstanceCode(parameterType)).append(";\n");
    }
    codeBuilder.append("        return new ").append(className).append("(");
    for (int i = 0; i < parameters.size(); i++) {
        if (i > 0) {
            codeBuilder.append(", ");
        }
        codeBuilder.append("param").append(i);
    }
    codeBuilder.append(");\n");
    codeBuilder.append("    }\n");
    codeBuilder.append("}");
    // 将生成的代码写入文件
    writeCodeToFile(codeBuilder.toString(), className + "Injector.java");
}

5.2.2 生成字段注入代码

java

java 复制代码

private void generateFieldInjectCode(TypeElement enclosingElement, VariableElement fieldElement) {
    StringBuilder codeBuilder = new StringBuilder();
    String className = enclosingElement.getSimpleName().toString();
    String fieldName = fieldElement.getSimpleName().toString();
    TypeMirror fieldType = fieldElement.asType();
    codeBuilder.append("public class ").append(className).append("FieldInjector {\n");
    codeBuilder.append("    public static void injectFields(").append(className).append(" instance) {\n");
    codeBuilder.append("        instance.").append(fieldName).append(" = ").append(getDependencyInstanceCode(fieldType)).append(";\n");
    codeBuilder.append("    }\n");
    codeBuilder.append("}");
    writeCodeToFile(codeBuilder.toString(), className + "FieldInjector.java");
}

5.2.3 生成方法注入代码

java

java 复制代码

private void generateMethodInjectCode(TypeElement enclosingElement, ExecutableElement methodElement) {
    StringBuilder codeBuilder = new StringBuilder();
    String className = enclosingElement.getSimpleName().toString();
    String methodName = methodElement.getSimpleName().toString();
    List<? extends VariableElement> parameters = methodElement.getParameters();
    codeBuilder.append("public class ").append(className).append("MethodInjector {\n");
    codeBuilder.append("    public static void injectMethod(").append(className).append(" instance) {\n");
    for (int i = 0; i < parameters.size(); i++) {
        VariableElement parameter = parameters.get(i);
        TypeMirror parameterType = parameter.asType();
        codeBuilder.append("        ").append(getDependencyInstanceCode(parameterType)).append(";\n");
    }
    codeBuilder.append("        instance.").append(methodName).append("(");
    for (int i = 0; i < parameters.size(); i++) {
        if (i > 0) {
            codeBuilder.append(", ");
        }
        codeBuilder.append("param").append(i);
    }
    codeBuilder.append(");\n");
    codeBuilder.append("    }\n");
    codeBuilder.append("}");
    writeCodeToFile(codeBuilder.toString(), className + "MethodInjector.java");
}

六、`@Module` 和 `@Provides` 注解处理流程

6.1 扫描 `@Module` 注解元素

在 DaggerProcessor 的 process 方法中，当扫描到 @Module 注解的元素时，会调用 processModuleAnnotation 方法进行处理。以下是简化的处理逻辑：

java

java 复制代码

private void processModuleAnnotation(Element element) {
    TypeElement moduleElement = (TypeElement) element;
    // 获取模块类中的所有方法
    List<? extends Element> members = moduleElement.getEnclosedElements();
    for (Element member : members) {
        if (member.getKind() == ElementKind.METHOD) {
            ExecutableElement methodElement = (ExecutableElement) member;
            if (methodElement.getAnnotation(Provides.class) != null) {
                // 处理 @Provides 注解的方法
                processProvidesAnnotation(methodElement);
            }
        }
    }
    // 生成模块类的相关代码
    generateModuleCode(moduleElement);
}

6.2 处理 `@Provides` 注解方法

java

java 复制代码

private void processProvidesAnnotation(ExecutableElement methodElement) {
    // 获取方法的返回类型
    TypeMirror returnType = methodElement.getReturnType();
    // 获取方法的参数列表
    List<? extends VariableElement> parameters = methodElement.getParameters();
    for (VariableElement parameter : parameters) {
        // 处理方法的参数注入信息
        processParameterInject(parameter);
    }
    // 生成 @Provides 方法的相关代码
    generateProvidesMethodCode(methodElement);
}

6.3 生成模块和 `@Provides` 方法代码

6.3.1 生成模块代码

java

java 复制代码

private void generateModuleCode(TypeElement moduleElement) {
    StringBuilder codeBuilder = new StringBuilder();
    String moduleName = moduleElement.getSimpleName().toString();
    codeBuilder.append("public class ").append(moduleName).append("ModuleWrapper {\n");
    // 生成模块类的构造函数
    codeBuilder.append("    private final ").append(moduleName).append(" module;\n");
    codeBuilder.append("    public ").append(moduleName).append("ModuleWrapper(").append(moduleName).append(" module) {\n");
    codeBuilder.append("        this.module = module;\n");
    codeBuilder.append("    }\n");
    // 生成模块类中 @Provides 方法的调用代码
    List<? extends Element> members = moduleElement.getEnclosedElements();
    for (Element member : members) {
        if (member.getKind() == ElementKind.METHOD) {
            ExecutableElement methodElement = (ExecutableElement) member;
            if (methodElement.getAnnotation(Provides.class) != null) {
                String methodName = methodElement.getSimpleName().toString();
                TypeMirror returnType = methodElement.getReturnType();
                codeBuilder.append("    public ").append(returnType.toString()).append(" ").append(methodName).append("() {\n");
                codeBuilder.append("        return module.").append(methodName).append("();\n");
                codeBuilder.append("    }\n");
            }
        }
    }
    codeBuilder.append("}");
    writeCodeToFile(codeBuilder.toString(), moduleName + "ModuleWrapper.java");
}

6.3.2 生成 `@Provides` 方法代码

java

java 复制代码

private void generateProvidesMethodCode(ExecutableElement methodElement) {
    StringBuilder codeBuilder = new StringBuilder();
    String moduleName = ((TypeElement) methodElement.getEnclosingElement()).getSimpleName().toString();
    String methodName = methodElement.getSimpleName().toString();
    TypeMirror returnType = methodElement.getReturnType();
    codeBuilder.append("public class ").append(moduleName).append(methodName).append("Provider {\n");
    codeBuilder.append("    private final ").append(moduleName).append("ModuleWrapper moduleWrapper;\n");
    codeBuilder.append("    public ").append(moduleName).append(methodName).append("Provider(").append(moduleName).append("ModuleWrapper moduleWrapper) {\n");
    codeBuilder.append("        this.moduleWrapper = moduleWrapper;\n");
    codeBuilder.append("    }\n");
    codeBuilder.append("    public ").append(returnType.toString()).append(" get() {\n");
    codeBuilder.append("        return moduleWrapper.").append(methodName).append("();\n");
    codeBuilder.append("    }\n");
    codeBuilder.append("}");
    writeCodeToFile(codeBuilder.toString(), moduleName + methodName + "Provider.java");
}

七、`@Component` 注解处理流程

7.1 扫描 `@Component` 注解元素

在 DaggerProcessor 的 process 方法中，当扫描到 @Component 注解的元素时，会调用 processComponentAnnotation 方法进行处理。以下是简化的处理逻辑：

java

java 复制代码

private void processComponentAnnotation(Element element) {
    TypeElement componentElement = (TypeElement) element;
    // 解析 @Component 注解的 modules 属性
    List<TypeElement> moduleElements = AnnotationParser.parseComponentModules(componentElement);
    // 生成组件接口的实现类代码
    generateComponentImplementationCode(componentElement, moduleElements);
}

7.2 生成组件接口实现类代码

java

java 复制代码

private void generateComponentImplementationCode(TypeElement componentElement, List<TypeElement> moduleElements) {
    StringBuilder codeBuilder = new StringBuilder();
    String componentName = componentElement.getSimpleName().toString();
    codeBuilder.append("public final class Dagger").append(componentName).append(" implements ").append(componentName).append(" {\n");
    // 生成模块包装类的成员变量
    for (TypeElement moduleElement : moduleElements) {
        String moduleName = moduleElement.getSimpleName().toString();
        codeBuilder.append("    private final ").append(moduleName).append("ModuleWrapper ").append(moduleName.toLowerCase()).append("ModuleWrapper;\n");
    }
    // 生成构造函数
    codeBuilder.append("    private Dagger").append(componentName).append("(");
    for (int i = 0; i < moduleElements.size(); i++) {
        TypeElement moduleElement = moduleElements.get(i);
        String moduleName = moduleElement.getSimpleName().toString();
        if (i > 0) {
            codeBuilder.append(", ");
        }
        codeBuilder.append(moduleName).append(" ").append(moduleName.toLowerCase()).append("Module");
    }
    codeBuilder.append(") {\n");
    for (TypeElement moduleElement : moduleElements) {
        String moduleName = moduleElement.getSimpleName().toString();
        codeBuilder.append("        this.").append(moduleName.toLowerCase()).append("ModuleWrapper = new ").append(moduleName).append("ModuleWrapper(").append(moduleName.toLowerCase()).append("Module);\n");
    }
    codeBuilder.append("    }\n");
    // 生成组件接口方法的实现
    List<? extends Element> members = componentElement.getEnclosedElements();
    for (Element member : members) {
        if (member.getKind() == ElementKind.METHOD) {
            ExecutableElement methodElement = (ExecutableElement) member;
            String methodName = methodElement.getSimpleName().toString();
            TypeMirror returnType = methodElement.getReturnType();
            codeBuilder.append("    @Override\n");
            codeBuilder.append("    public ").append(returnType.toString()).append(" ").append(methodName).append("() {\n");
            if (returnType.toString().contains("Car")) {
                // 假设这里是获取 Car 实例的逻辑
                codeBuilder.append("        Engine engine = ").append(getEngineInstanceCode()).append(";\n");
                codeBuilder.append("        return new Car(engine);\n");
            } else if (methodName.startsWith("inject")) {
                // 处理注入方法
                VariableElement parameter = methodElement.getParameters().get(0);
                TypeMirror parameterType = parameter.asType();
                codeBuilder.append("        ").append(parameterType.toString()).append(" instance = new ").append(parameterType.toString()).append("();\n");
                codeBuilder.append("        ").append(parameterType.toString()).append("FieldInjector.injectFields(instance);\n");
                codeBuilder.append("        return instance;\n");
            }
            codeBuilder.append("    }\n");
        }
    }
    // 生成创建组件实例的静态方法
    codeBuilder.append("    public static ").append(componentName).append(" create(");
    for (int i = 0; i < moduleElements.size(); i++) {
        TypeElement moduleElement =

八、依赖解析与图构建

8.1 依赖关系的表示

在 Dagger 2 的编译时注解处理中，需要将各个依赖关系进行清晰的表示，以便后续生成正确的注入代码。通常会使用图（Graph）这种数据结构来表示依赖关系，其中节点（Node）代表依赖对象，边（Edge）代表依赖关系。

8.1.1 节点类的定义

java

java 复制代码

import javax.lang.model.type.TypeMirror;

// 表示依赖图中的节点
class DependencyNode {
    private final TypeMirror type; // 节点所代表的类型
    private final boolean isSingleton; // 是否为单例

    public DependencyNode(TypeMirror type, boolean isSingleton) {
        this.type = type;
        this.isSingleton = isSingleton;
    }

    public TypeMirror getType() {
        return type;
    }

    public boolean isSingleton() {
        return isSingleton;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        DependencyNode that = (DependencyNode) o;
        return isSingleton == that.isSingleton && type.toString().equals(that.type.toString());
    }

    @Override
    public int hashCode() {
        return type.toString().hashCode() * 31 + (isSingleton ? 1 : 0);
    }
}

8.1.2 图类的定义

java

java 复制代码

import java.util.*;

// 表示依赖图
class DependencyGraph {
    private final Map<DependencyNode, Set<DependencyNode>> graph; // 图的邻接表表示

    public DependencyGraph() {
        this.graph = new HashMap<>();
    }

    // 添加节点
    public void addNode(DependencyNode node) {
        graph.putIfAbsent(node, new HashSet<>());
    }

    // 添加边
    public void addEdge(DependencyNode from, DependencyNode to) {
        graph.computeIfAbsent(from, k -> new HashSet<>()).add(to);
    }

    // 获取节点的所有依赖
    public Set<DependencyNode> getDependencies(DependencyNode node) {
        return graph.getOrDefault(node, Collections.emptySet());
    }
}

8.2 构建依赖图

在处理 @Inject、@Module 和 @Provides 注解时，会逐步构建依赖图。以下是构建依赖图的简化逻辑：

java

java 复制代码

import javax.lang.model.element.*;
import javax.lang.model.type.TypeMirror;
import java.util.*;

// 依赖图构建器
class DependencyGraphBuilder {
    private final DependencyGraph graph;

    public DependencyGraphBuilder() {
        this.graph = new DependencyGraph();
    }

    // 处理 @Inject 注解的元素
    public void processInjectElement(Element element) {
        if (element.getKind() == ElementKind.CONSTRUCTOR) {
            ExecutableElement constructor = (ExecutableElement) element;
            TypeElement enclosingElement = (TypeElement) constructor.getEnclosingElement();
            DependencyNode targetNode = createNode(enclosingElement.asType(), false);
            graph.addNode(targetNode);
            for (VariableElement parameter : constructor.getParameters()) {
                DependencyNode dependencyNode = createNode(parameter.asType(), false);
                graph.addNode(dependencyNode);
                graph.addEdge(targetNode, dependencyNode);
            }
        }
    }

    // 处理 @Provides 注解的方法
    public void processProvidesMethod(ExecutableElement methodElement) {
        TypeMirror returnType = methodElement.getReturnType();
        DependencyNode providedNode = createNode(returnType, false);
        graph.addNode(providedNode);
        for (VariableElement parameter : methodElement.getParameters()) {
            DependencyNode dependencyNode = createNode(parameter.asType(), false);
            graph.addNode(dependencyNode);
            graph.addEdge(providedNode, dependencyNode);
        }
    }

    // 创建节点
    private DependencyNode createNode(TypeMirror type, boolean isSingleton) {
        return new DependencyNode(type, isSingleton);
    }

    public DependencyGraph getGraph() {
        return graph;
    }
}

8.3 依赖解析算法

构建好依赖图后，需要进行依赖解析，以确定依赖对象的创建顺序。常用的算法是拓扑排序（Topological Sorting），它可以确保在创建某个依赖对象之前，其所有依赖都已经被创建。

java

java 复制代码

import java.util.*;

// 拓扑排序算法实现
class TopologicalSorter {
    public static List<DependencyNode> sort(DependencyGraph graph) {
        Map<DependencyNode, Integer> inDegree = new HashMap<>();
        for (DependencyNode node : graph.getNodes()) {
            inDegree.putIfAbsent(node, 0);
            for (DependencyNode dependency : graph.getDependencies(node)) {
                inDegree.put(dependency, inDegree.getOrDefault(dependency, 0) + 1);
            }
        }

        Queue<DependencyNode> queue = new LinkedList<>();
        for (Map.Entry<DependencyNode, Integer> entry : inDegree.entrySet()) {
            if (entry.getValue() == 0) {
                queue.add(entry.getKey());
            }
        }

        List<DependencyNode> sortedNodes = new ArrayList<>();
        while (!queue.isEmpty()) {
            DependencyNode node = queue.poll();
            sortedNodes.add(node);
            for (DependencyNode dependency : graph.getDependencies(node)) {
                int newInDegree = inDegree.get(dependency) - 1;
                inDegree.put(dependency, newInDegree);
                if (newInDegree == 0) {
                    queue.add(dependency);
                }
            }
        }

        if (sortedNodes.size() != graph.getNodes().size()) {
            throw new IllegalStateException("Graph contains a cycle");
        }

        return sortedNodes;
    }
}

九、代码生成优化

9.1 减少重复代码

在生成代码时，可能会出现大量重复的代码，例如创建依赖对象的逻辑。为了减少重复代码，可以使用模板方法和代码复用技术。

9.1.1 模板方法模式

java

java 复制代码

// 代码生成模板类
abstract class CodeGeneratorTemplate {
    protected final StringBuilder codeBuilder;

    public CodeGeneratorTemplate() {
        this.codeBuilder = new StringBuilder();
    }

    // 生成代码的主方法
    public final String generateCode() {
        startCode();
        generateBody();
        endCode();
        return codeBuilder.toString();
    }

    // 开始生成代码
    protected void startCode() {
        codeBuilder.append("package com.example.generated;\n\n");
    }

    // 生成代码主体，由子类实现
    protected abstract void generateBody();

    // 结束生成代码
    protected void endCode() {
        codeBuilder.append("}\n");
    }
}

// 具体的代码生成器
class CarInjectorGenerator extends CodeGeneratorTemplate {
    @Override
    protected void generateBody() {
        codeBuilder.append("public class CarInjector {\n");
        codeBuilder.append("    public static Car create() {\n");
        codeBuilder.append("        Engine engine = EngineProvider.get();\n");
        codeBuilder.append("        return new Car(engine);\n");
        codeBuilder.append("    }\n");
    }
}

9.2 优化单例对象的创建

对于单例对象，在生成代码时需要确保其在整个应用生命周期中只创建一次。可以使用静态变量和双重检查锁定机制来实现单例模式。

java

java 复制代码

// 单例对象提供者
class SingletonEngineProvider {
    private static volatile Engine instance;

    public static Engine get() {
        if (instance == null) {
            synchronized (SingletonEngineProvider.class) {
                if (instance == null) {
                    instance = new Engine();
                }
            }
        }
        return instance;
    }
}

9.3 生成高效的注入代码

在生成注入代码时，要尽量减少不必要的方法调用和对象创建，提高代码的执行效率。例如，对于字段注入，可以直接访问字段进行赋值，而不是通过方法调用。

java

java 复制代码

// 高效的字段注入代码
class CarFieldInjector {
    public static void injectFields(Car car) {
        car.engine = EngineProvider.get();
    }
}

十、错误处理与日志记录

10.1 注解解析错误处理

在解析注解时，可能会遇到各种错误，例如注解使用错误、依赖关系冲突等。需要对这些错误进行捕获和处理，并向开发者提供明确的错误信息。

java

java 复制代码

import javax.annotation.processing.Messager;
import javax.lang.model.element.Element;
import javax.tools.Diagnostic;

// 注解解析错误处理器
class AnnotationErrorHandler {
    private final Messager messager;

    public AnnotationErrorHandler(Messager messager) {
        this.messager = messager;
    }

    // 处理注解解析错误
    public void handleError(Element element, String message) {
        messager.printMessage(Diagnostic.Kind.ERROR, message, element);
    }
}

10.2 日志记录

在注解处理过程中，添加日志记录可以帮助开发者调试和理解注解处理的流程。可以使用 Java 的 java.util.logging 或其他日志框架进行日志记录。

java

java 复制代码

import java.util.logging.Level;
import java.util.logging.Logger;

// 日志记录器
class AnnotationProcessorLogger {
    private static final Logger LOGGER = Logger.getLogger(AnnotationProcessorLogger.class.getName());

    public static void logInfo(String message) {
        LOGGER.log(Level.INFO, message);
    }

    public static void logWarning(String message) {
        LOGGER.log(Level.WARNING, message);
    }

    public static void logError(String message) {
        LOGGER.log(Level.SEVERE, message);
    }
}

10.3 错误处理示例

在 DaggerProcessor 中，可以使用错误处理和日志记录机制：

java

java 复制代码

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import java.util.Set;

public class DaggerProcessor extends AbstractProcessor {
    private AnnotationErrorHandler errorHandler;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.errorHandler = new AnnotationErrorHandler(processingEnv.getMessager());
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return Set.of(
                "javax.inject.Inject",
                "dagger.Module",
                "dagger.Provides",
                "dagger.Component"
        );
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement annotation : annotations) {
            Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(annotation);
            for (Element element : annotatedElements) {
                try {
                    if (element.getAnnotation(Inject.class) != null) {
                        processInjectAnnotation(element);
                    } else if (element.getAnnotation(Module.class) != null) {
                        processModuleAnnotation(element);
                    } else if (element.getAnnotation(Provides.class) != null) {
                        processProvidesAnnotation(element);
                    } else if (element.getAnnotation(Component.class) != null) {
                        processComponentAnnotation(element);
                    }
                } catch (Exception e) {
                    errorHandler.handleError(element, "Error processing annotation: " + e.getMessage());
                    AnnotationProcessorLogger.logError("Error processing annotation on element: " + element + ", error: " + e.getMessage());
                }
            }
        }
        return true;
    }

    // 其他处理方法...
}

十一、Dagger 2 编译时注解处理的性能优化

11.1 增量编译支持

为了提高编译效率，Dagger 2 支持增量编译。增量编译只处理发生变化的源文件，而不是重新编译整个项目。可以通过以下方式实现增量编译：

11.1.1 记录编译状态

在每次编译时，记录源文件的修改时间和生成的代码文件信息。下次编译时，比较源文件的修改时间，如果源文件没有变化，则跳过该文件的注解处理。

java

java 复制代码

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

// 编译状态记录器
class CompilationStateRecorder {
    private static final String STATE_FILE = "compilation_state.txt";
    private final Map<String, Long> sourceFileTimestamps;

    public CompilationStateRecorder() {
        this.sourceFileTimestamps = new HashMap<>();
        loadState();
    }

    // 加载编译状态
    private void loadState() {
        Path stateFilePath = Paths.get(STATE_FILE);
        if (Files.exists(stateFilePath)) {
            try {
                List<String> lines = Files.readAllLines(stateFilePath);
                for (String line : lines) {
                    String[] parts = line.split(":");
                    if (parts.length == 2) {
                        sourceFileTimestamps.put(parts[0], Long.parseLong(parts[1]));
                    }
                }
            } catch (IOException e) {
                AnnotationProcessorLogger.logWarning("Error loading compilation state: " + e.getMessage());
            }
        }
    }

    // 检查源文件是否有变化
    public boolean hasFileChanged(String sourceFilePath) {
        File sourceFile = new File(sourceFilePath);
        long currentTimestamp = sourceFile.lastModified();
        long previousTimestamp = sourceFileTimestamps.getOrDefault(sourceFilePath, 0L);
        return currentTimestamp != previousTimestamp;
    }

    // 记录编译状态
    public void recordState(String sourceFilePath) {
        File sourceFile = new File(sourceFilePath);
        long currentTimestamp = sourceFile.lastModified();
        sourceFileTimestamps.put(sourceFilePath, currentTimestamp);
        saveState();
    }

    // 保存编译状态
    private void saveState() {
        Path stateFilePath = Paths.get(STATE_FILE);
        try {
            StringBuilder sb = new StringBuilder();
            for (Map.Entry<String, Long> entry : sourceFileTimestamps.entrySet()) {
                sb.append(entry.getKey()).append(":").append(entry.getValue()).append("\n");
            }
            Files.write(stateFilePath, sb.toString().getBytes());
        } catch (IOException e) {
            AnnotationProcessorLogger.logWarning("Error saving compilation state: " + e.getMessage());
        }
    }
}

11.1.2 在注解处理器中使用增量编译

java

java 复制代码

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;
import java.util.Set;

public class DaggerProcessor extends AbstractProcessor {
    private CompilationStateRecorder stateRecorder;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.stateRecorder = new CompilationStateRecorder();
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return Set.of(
                "javax.inject.Inject",
                "dagger.Module",
                "dagger.Provides",
                "dagger.Component"
        );
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement annotation : annotations) {
            Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(annotation);
            for (Element element : annotatedElements) {
                String sourceFilePath = getSourceFilePath(element);
                if (stateRecorder.hasFileChanged(sourceFilePath)) {
                    try {
                        if (element.getAnnotation(Inject.class) != null) {
                            processInjectAnnotation(element);
                        } else if (element.getAnnotation(Module.class) != null) {
                            processModuleAnnotation(element);
                        } else if (element.getAnnotation(Provides.class) != null) {
                            processProvidesAnnotation(element);
                        } else if (element.getAnnotation(Component.class) != null) {
                            processComponentAnnotation(element);
                        }
                        stateRecorder.recordState(sourceFilePath);
                    } catch (Exception e) {
                        // 错误处理...
                    }
                }
            }
        }
        return true;
    }

    // 获取源文件路径
    private String getSourceFilePath(Element element) {
        // 实现获取源文件路径的逻辑
        return "";
    }

    // 其他处理方法...
}

11.2 代码生成优化

在生成代码时，尽量减少不必要的代码生成，避免生成过于复杂的代码结构。例如，对于简单的依赖注入，可以使用更简洁的代码实现。

11.3 内存管理

在注解处理过程中，要注意内存的使用，避免出现内存泄漏。及时释放不再使用的对象，避免创建过多的临时对象。

十二、与 Android 开发的集成

12.1 在 Android 项目中使用 Dagger 2

在 Android 项目中使用 Dagger 2，需要在 build.gradle 文件中添加相关依赖：

groovy

java 复制代码

dependencies {
    implementation 'com.google.dagger:dagger:2.x'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
}

12.2 Android 组件的依赖注入

在 Android 开发中，常见的组件如 Activity、Fragment 等也可以使用 Dagger 2 进行依赖注入。

12.2.1 定义 Android 模块

java

java 复制代码

import dagger.Module;
import dagger.Provides;
import javax.inject.Singleton;

// Android 模块
@Module
public class AndroidModule {
    private final MyApplication application;

    public AndroidModule(MyApplication application) {
        this.application = application;
    }

    @Provides
    @Singleton
    public Context provideContext() {
        return application;
    }
}

12.2.2 定义 Android 组件

java

java 复制代码

import dagger.Component;
import javax.inject.Singleton;

// Android 组件
@Singleton
@Component(modules = {AndroidModule.class})
public interface AndroidComponent {
    void inject(MainActivity activity);
}

12.2.3 在 Activity 中使用依赖注入

java

java 复制代码

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import javax.inject.Inject;
import android.content.Context;

public class MainActivity extends AppCompatActivity {
    @Inject
    Context context;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ((MyApplication) getApplication()).getComponent().inject(this);
        // 使用注入的依赖
    }
}

12.3 Android 生命周期管理

在 Android 开发中，需要考虑组件的生命周期。可以结合 Android 的生命周期回调方法，在合适的时机进行依赖注入和资源释放。

java

java 复制代码

import android.app.Application;
import dagger.android.AndroidInjector;
import dagger.android.DispatchingAndroidInjector;
import dagger.android.HasAndroidInjector;
import javax.inject.Inject;

// 自定义 Application 类
public class MyApplication extends Application implements HasAndroidInjector {
    @Inject
    DispatchingAndroidInjector<Object> androidInjector;

    private AndroidComponent component;

    @Override
    public void onCreate() {
        super.onCreate();
        component = DaggerAndroidComponent.builder()
               .androidModule(new AndroidModule(this))
               .build();
        component.inject(this);
    }

    @Override
    public AndroidInjector<Object> androidInjector() {
        return androidInjector;
    }

    public AndroidComponent getComponent() {
        return component;
    }
}

十三、测试与调试

13.1 单元测试

可以使用 JUnit 和 Mockito 等工具对 Dagger 2 的注解处理器进行单元测试。例如，测试 @Inject 注解的处理逻辑：

java

java 复制代码

import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import javax.lang.model.element.Element;
import javax.lang.model.type.TypeMirror;
import java.util.ArrayList;
import java.util.List;

import static org.mockito.Mockito.*;

public class DaggerProcessorTest {
    @Mock
    private Element mockElement;
    @Mock
    private TypeMirror mockTypeMirror;

    private DaggerProcessor processor;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        processor = new DaggerProcessor();
    }

    @Test
    public void testProcessInjectAnnotation() {
        when(mockElement.getKind()).thenReturn(ElementKind.CONSTRUCTOR);
        List<Element> parameters = new ArrayList<>();
        Element mockParameter = mock(Element.class);
        when(mockParameter.asType()).thenReturn(mockTypeMirror);
        parameters.add(mockParameter);
        ExecutableElement mockConstructor = mock(ExecutableElement.class);
        when(mockConstructor.getParameters()).thenReturn(parameters);
        when(mockElement.getEnclosingElement()).thenReturn(mock(Element.class));
        processor.processInjectAnnotation(mockConstructor);
        // 验证处理逻辑是否正确
    }
}

13.2 调试注解处理器

在调试注解处理器时，可以使用以下方法：

13.2.1 日志记录

在注解处理器中添加详细的日志记录，输出关键步骤和变量的值，帮助定位问题。

13.2.2 使用 IDE 调试

在 IDE 中配置注解处理器的调试环境，设置断点，逐步执行注解处理代码，观察变量的变化。

13.2.3 手动编译和调试

手动编译注解处理器代码，使用 javac 命令并添加调试参数，然后在命令行中观察编译过程和输出信息。

十四、未来发展趋势

14.1 性能优化

未来 Dagger 2 可能会进一步优化编译时注解处理的性能，减少编译时间和内存消耗。例如，采用更高效的依赖解析算法和代码生成策略。

14.2 与新 Java 特性集成

随着 Java 语言的不断发展，Dagger 2 可能会集成新的 Java 特性，如 Java 模块化、Records 等，以提供更好的开发体验。

14.3 与其他框架的集成

Dagger 2 可能会与其他流行的 Android 开发框架（如 Jetpack Compose、Kotlin Coroutines 等）进行更紧密的集成，为开发者提供一站式的解决方案。

14.4 简化使用方式

为了降低学习成本，Dagger 2 可能会简化注解的使用方式，提供更简洁的 API 和更友好的错误提示。

十五、总结

Dagger 2 的编译时注解处理模块是其核心竞争力所在，通过在编译时生成高效的依赖注入代码，避免了运行时反射带来的性能问题。本文从注解处理的基础原理出发，详细分析了 Dagger 2 中 @Inject、@Module、@Provides 和 @Component 等注解的处理流程，包括依赖解析、图构建、代码生成、错误处理等方面。同时，还探讨了性能优化、与 Android 开发的集成、测试与调试等内容。

虽然 Dagger 2 的编译时注解处理模块功能强大，但也存在一定的学习成本和复杂度。开发者需要深入理解注解的使用方法和依赖注入的原理，才能充分发挥 Dagger 2 的优势。随着技术的不断发展，Dagger 2 有望在性能、易用性和集成性等方面取得更大的进步，为 Android 和 Java 开发带来更多的便利。

Android Dagger2 框架编译时注解处理模块深度剖析(二)

一、引言

二、编译时注解处理基础

2.1 注解与注解处理器概述

2.2 Java 注解处理流程

2.3 注解处理器的注册

三、Dagger 2 编译时注解处理模块概述

3.1 Dagger 2 注解处理模块的作用

3.2 Dagger 2 主要注解介绍

3.2.1 @Inject

3.2.2 @Module

3.2.3 @Provides

3.2.4 @Component

四、Dagger 2 注解处理器核心类解析

4.1 DaggerProcessor 类

4.1.1 getSupportedAnnotationTypes 方法

4.1.2 getSupportedSourceVersion 方法

4.1.3 process 方法

4.2 注解解析工具类

4.2.1 parseComponentModules 方法

4.2.2 getAnnotationMirror 方法

4.2.3 getAnnotationValue 方法

五、@Inject 注解处理流程

5.1 扫描 @Inject 注解元素

5.1.1 processConstructorInject 方法

5.1.2 processFieldInject 方法

5.1.3 processMethodInject 方法

5.2 生成注入代码

5.2.1 生成构造函数注入代码

5.2.2 生成字段注入代码

5.2.3 生成方法注入代码

六、@Module 和 @Provides 注解处理流程

6.1 扫描 @Module 注解元素

6.2 处理 @Provides 注解方法

6.3 生成模块和 @Provides 方法代码

6.3.1 生成模块代码

6.3.2 生成 @Provides 方法代码

七、@Component 注解处理流程

7.1 扫描 @Component 注解元素

7.2 生成组件接口实现类代码

八、依赖解析与图构建

8.1 依赖关系的表示

8.1.1 节点类的定义

8.1.2 图类的定义

8.2 构建依赖图

8.3 依赖解析算法

九、代码生成优化

9.1 减少重复代码

9.1.1 模板方法模式

9.2 优化单例对象的创建

9.3 生成高效的注入代码

十、错误处理与日志记录

10.1 注解解析错误处理

10.2 日志记录

10.3 错误处理示例

十一、Dagger 2 编译时注解处理的性能优化

11.1 增量编译支持

11.1.1 记录编译状态

11.1.2 在注解处理器中使用增量编译

11.2 代码生成优化

11.3 内存管理

十二、与 Android 开发的集成

12.1 在 Android 项目中使用 Dagger 2

12.2 Android 组件的依赖注入

12.2.1 定义 Android 模块

12.2.2 定义 Android 组件

12.2.3 在 Activity 中使用依赖注入

12.3 Android 生命周期管理

十三、测试与调试

13.1 单元测试

13.2 调试注解处理器

13.2.1 日志记录

13.2.2 使用 IDE 调试

13.2.3 手动编译和调试

十四、未来发展趋势

14.1 性能优化

14.2 与新 Java 特性集成

14.3 与其他框架的集成

14.4 简化使用方式

十五、总结

3.2.1 `@Inject`

3.2.2 `@Module`

3.2.3 `@Provides`

3.2.4 `@Component`

4.1 `DaggerProcessor` 类

4.1.1 `getSupportedAnnotationTypes` 方法

4.1.2 `getSupportedSourceVersion` 方法

4.1.3 `process` 方法

4.2.1 `parseComponentModules` 方法

4.2.2 `getAnnotationMirror` 方法

4.2.3 `getAnnotationValue` 方法

五、`@Inject` 注解处理流程

5.1 扫描 `@Inject` 注解元素

5.1.1 `processConstructorInject` 方法

5.1.2 `processFieldInject` 方法

5.1.3 `processMethodInject` 方法

六、`@Module` 和 `@Provides` 注解处理流程

6.1 扫描 `@Module` 注解元素

6.2 处理 `@Provides` 注解方法

6.3 生成模块和 `@Provides` 方法代码

6.3.2 生成 `@Provides` 方法代码

七、`@Component` 注解处理流程

7.1 扫描 `@Component` 注解元素