Android—APT实践

APT可以根据注解，在编译时生成代码。

1.    创建两个java library

 

2.    依赖

factory-compiler的依赖

dependencies {
    implementation 'com.google.auto.service:auto-service:1.0-rc4'
    implementation project(':annotation')
    implementation 'com.squareup:javapoet:1.10.0'
    annotationProcessor 'com.google.auto.service:auto-service:1.0-rc4'
}

 app的

implementation project(':annotation')
annotationProcessor project(':factory-compiler')

3.    创建注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Factory {

    Class type();

    String id();

}

4.    注解使用

在app中创建接口，还有对应实现类

public interface IShape {
    void show();
}

@Factory(type = IShape.class, id = "Circle")
public class Circle implements IShape {
    @Override
    public void show() {
        System.out.println("Circle");
    }
}

@Factory(type = IShape.class, id = "Rectangle")
public class Rectangle implements IShape {
    @Override
    public void show() {
        System.out.println("Rectangle");
    }
}

在MainActivity中使用

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        IShapeFactory iShapeFactory = new IShapeFactory();
        IShape circle = iShapeFactory.create("Circle");
        TextView tv = findViewById(R.id.tv);
        tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                circle.show();
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
    }
}

此时我们还没有IShapeFactory这个类，需要用APT在编译生成。

5.    实现APT

首先我们创建两个实体类

public class FactoryAnnotatedClass {
    private TypeElement typeElement;
    private String canonicalName;
    private String simpleTypeName;
    private final String id;

    public FactoryAnnotatedClass(TypeElement classElement) {
        this.typeElement = classElement;
        Factory annotation = classElement.getAnnotation(Factory.class);
        id = annotation.id();
        try {  // 该类已经被编译
            Class<?> clazz = annotation.type();
            canonicalName = clazz.getCanonicalName();
            simpleTypeName = clazz.getSimpleName();
        } catch (MirroredTypeException mte) {// 该类未被编译
            DeclaredType classTypeMirror = (DeclaredType) mte.getTypeMirror();
            TypeElement classTypeElement = (TypeElement) classTypeMirror.asElement();
            canonicalName = classTypeElement.getQualifiedName().toString();
            simpleTypeName = classTypeElement.getSimpleName().toString();
        }

    }

	……get方法
}

public class FactoryGroup {
    private static final String SUFFIX = "Factory";
    public final String qualifiedClassName;
    private final Map<String, FactoryAnnotatedClass> itemsMap = new LinkedHashMap<>();

    public FactoryGroup(String qualifiedClassName) {
        this.qualifiedClassName = qualifiedClassName;
    }

    public void add(FactoryAnnotatedClass toInsert) {
        itemsMap.put(toInsert.getId(), toInsert);
    }

    public void generateCode(Elements elementUtils, Filer filer) {
        TypeElement superClassName = elementUtils.getTypeElement(qualifiedClassName);
        String factoryClassName = superClassName.getSimpleName() + SUFFIX;
        PackageElement pkg = elementUtils.getPackageOf(superClassName);
        String packageName = pkg.isUnnamed() ? null : pkg.getQualifiedName().toString();
        MethodSpec.Builder method = MethodSpec.methodBuilder("create")
                .addModifiers(Modifier.PUBLIC)
                .addParameter(String.class, "id")
                .returns(TypeName.get(superClassName.asType()));
        method.beginControlFlow("if (id == null)")
                .addStatement("throw new IllegalArgumentException($S)", "id is null!")
                .endControlFlow();

        for (FactoryAnnotatedClass item : itemsMap.values()) {
            method.beginControlFlow("if ($S.equals(id))", item.getId())
                    .addStatement("return new $L()", item.getTypeElement().getQualifiedName().toString())
                    .endControlFlow();
            System.out.println("QualifiedName      "+item.getTypeElement().getQualifiedName().toString());
        }

        method.addStatement("throw new IllegalArgumentException($S + id)", "Unknown id = ");

        TypeSpec typeSpec = TypeSpec
                .classBuilder(factoryClassName)
                .addModifiers(Modifier.PUBLIC)
                .addMethod(method.build())
                .build();

        try {
            if (packageName != null) {
                JavaFile.builder(packageName, typeSpec).build().writeTo(filer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

最主要的就是generateCode方法，里面利用了JavaPoet生成代码。

接下来创建一个类继承AbstractProcessor，主要实现下面两个方法。

@AutoService(Processor.class)
public class FactoryProcessor extends AbstractProcessor{

    private final Map<String, FactoryGroup> factoryClasses = new LinkedHashMap<>();

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> annotations = new LinkedHashSet<>();
        annotations.add(Factory.class.getCanonicalName());
        return annotations;
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        for (TypeElement element:set){
            //  通过RoundEnvironment获取到所有被@Factory注解的对象
            Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(element);
            for (Element annotatedElement : elements) {
                TypeElement typeElement = (TypeElement) annotatedElement;
                FactoryAnnotatedClass annotatedClass = new FactoryAnnotatedClass(typeElement);
                FactoryGroup factoryGroup = factoryClasses.get(annotatedClass.getCanonicalName());
                if (factoryGroup == null) {
                    String qualifiedGroupName = annotatedClass.getCanonicalName();
                    factoryGroup = new FactoryGroup(qualifiedGroupName);
                    factoryClasses.put(qualifiedGroupName, factoryGroup);
                }
                factoryGroup.add(annotatedClass);
            }
            for (FactoryGroup factoryGroup : factoryClasses.values()) {
                factoryGroup.generateCode(processingEnv.getElementUtils(), processingEnv.getFiler());
            }
            return true;

        }
        return false;
    }
}

process方法会被多次调用，方法参数中的set是我们注解类所对应的TypeElement对象，仅当set不为空时，我们才去操作。

 然后调用RoundEnvironment的getElementsAnnotatedWith方法获取到使用了改注解的类的TypeElement对象（既Circle、Rectangle）。

然后我们把这两个TypeElement对象封装成FactoryAnnotatedClass对象，存放到factoryGroup中，简单说factoryGroup就是用来存放使用了同一个注解类的对象，为了方便我们创建多个注解一起使用所以又创建了一个map对象（既factoryClasses）来存放factoryGroup，然后我们调用generateCode方法生成对应java文件。

 在generateCode方法中，我们通过获取Circle、Rectangle类注解的id，来生成代码，rebuild之后即可看到对应文件。

 

优点：

1、当我们需要再创建一个实现类时，只需要给实现类标上注解就可以，不想要去添加工厂类的代码。如果是自己编写的工厂类则需要再加一段代码。

2、APT>反射，解析注解可以不需要用反射的方式，APT在调式期间就可以解析。

JavaPoet使用文档： https://github.com/aheckl/javapoet