通过自定义注解实现工厂模式

本次介绍自定义编译时注解，编译时注解，不会在影响应用的打包，没有性能问题。如果是运行时注解，通过反射调用，就会有性能损耗。

工程结构介绍：

1. annotationstart：注解接口类定义，需要打包到app模块中；
2. annotationcompare：注解扫描工具，不需要打包到app模块中，但是需要应用。
   所以，这两个模块需要分开；并且需要使用java library创建。
   build.gradle参考：

plugins {
    id 'java-library'
}

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
}

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
}

注解定义

（annotationstart内）

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
public @interface ServiceId {
    String value();
}

定义一个服务id，根据服务id，创建不同的服务。

注解扫描类

依赖：

• javapoet：通过javapoet，可以使用java面向对象编程生成java文件，否则只能手动拼接字符串，形成java文件，非常麻烦；
• auto-service：注解自动注册，帮我们自动注册注解，编译器才会开始扫描注解，否则不会生成文件。（如果不使用，可以自己新建javax.annotation.processing.Processor文件，添加注解。具体步骤可以参考原理）。

    implementation project(':annotationstart')
    implementation 'com.squareup:javapoet:1.9.0'
    implementation 'com.google.auto.service:auto-service:1.0-rc6'
    annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'

需要集成注解接口类，auto-service需要集成，并且打包方式也需要集成。

生成代码：

@AutoService(Processor.class)
public class ServiceFactoryProcessor extends AbstractProcessor {
    private Types mTypeUtils;
    private Elements mElementUtils;
    private Filer mFiler;
    private Messager mMessager;

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

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);

        //初始化我们需要的基础工具
        mTypeUtils = processingEnv.getTypeUtils();
        mElementUtils = processingEnv.getElementUtils();
        mFiler = processingEnv.getFiler();
        mMessager = processingEnv.getMessager();
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        HashSet<String> set = new HashSet<>();
        set.add(ServiceId.class.getCanonicalName());
        return set;
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

        Messager messager = processingEnv.getMessager();
        messager.printMessage(Diagnostic.Kind.NOTE, "start");

        // 打印注解
        Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(ServiceId.class);
        for (Element element : elements) {
            String name = element.getSimpleName().toString();
            String value = element.getAnnotation(ServiceId.class).value();
            messager.printMessage(Diagnostic.Kind.NOTE, name + " --> " + value);
            analysisAnnotated(element);
        }
        return true;
    }

    private void analysisAnnotated(Element classElement) {
        TypeElement typeElement = (TypeElement) classElement;
        ClassName appClassName = ClassName.get(mElementUtils.getPackageOf(classElement).asType().toString(), typeElement.getQualifiedName().toString());
        ClassName superClassName = ClassName.get("com.example.annotatetest.test", "IFruit");

        MethodSpec getServiceMethod = MethodSpec.methodBuilder("getService")
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .addParameter(String.class, "serviceId")
                .returns(superClassName)
                .addStatement("if(serviceId ==\"" + classElement.getAnnotation(ServiceId.class).value() + "\")"
                        + "return new $T()", appClassName)
                .addStatement("\nreturn null")
                .build();

        TypeSpec ServiceFactoryType = TypeSpec.classBuilder("ServiceFactory")
                .addModifiers(Modifier.PUBLIC)
                .addMethod(getServiceMethod)
                .build();

        JavaFile javaFile = JavaFile.builder("com.example.annotatetest.test", ServiceFactoryType)
                .build();

        try {
            javaFile.writeTo(mFiler);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用注解

app集成注解接口类和注解扫描类

    implementation project(':annotationstart')
    annotationProcessor project(':annotationcompare')

需要实现工厂的接口基类：

public interface IFruit {
    void produce();
}

实现类：

@ServiceId("Apple")
public class Apple implements IFruit {
    @Override
    public void produce() {
        Log.e("AnnotationDemo", "生成苹果");
    }
}

这样，就会开始扫描注解，生成工厂类。解决新建一个服务，需要修改多个地方的问题。

生成类：

import java.lang.String;

public class ServiceFactory {
  public static IFruit getService(String serviceId) {
    if(serviceId =="Apple")return new Apple();
        return null;
  }
}

过程记录：

1. 注解类不生成：没有注册注解，或者在kotlin中使用注解，由于兼容性问题导致扫描失败。
2. 调用工厂类失败：在kotlin，直接调用工厂类会打包失败，虽然编译器能识别，但是打包的时候会先编译kotlin类，这个时候注解还没扫描。导致打包失败。