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 {@Overridepublic void show() {System.out.println("Circle");}
}@Factory(type = IShape.class, id = "Rectangle")
public class Rectangle implements IShape {@Overridepublic void show() {System.out.println("Rectangle");}
}

在MainActivity中使用

public class MainActivity extends AppCompatActivity {@Overrideprotected 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() {@Overridepublic void onClick(View v) {circle.show();}});}@Overrideprotected 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<>();@Overridepublic Set<String> getSupportedAnnotationTypes() {Set<String> annotations = new LinkedHashSet<>();annotations.add(Factory.class.getCanonicalName());return annotations;}@Overridepublic 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