前言
APT的学习要花点时间去掌握和实践的，短时间内只能掌握知识点，更多的是在实战中去实践。其实，APT就是一种工具而已，只要用多了，自然就会熟练了，不过要想实践之前，还是必须把基础知识学好才能实战进入开发。文章会从基础用例讲解知识点，然后再通过实战进行实践
APT简介
APT(Annotation Processing Tool)是一种处理注解的工具，它会对源代码中的注解进行额外的处理，比如在编译时生成一些重复性操作的Java代码，或者不需要程序员去关心的Java代码等。 在使用APT的过程中会涉及到下面两个第三方库的使用
- AutoService：这个库的主要作用是注册注解，并对其生成META-INF的配置信息
- JavaPoet：这个库的主要作用是帮助我们通过类调用的形式来生成Java代码
APT主要过程包括初始化过程和注解处理过程
- 初始化过程：获取APT提供的工具类，为后面的注解处理提供帮助
- 注解处理过程：获取注解的元素，对元素进行额外处理，可用JavaPoet生成Java代码
APT流程
1、定义注解
该注解是可以在我们的项目中使用到的，且规定为注解元素的类型为Type，和在编译时生效
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ModuleWrapper {
}
2、定义Processor
Processor会在编译期对注解进行解析，取出对应的元素进行处理。至于AutoService则是固定的写法，加个注解即可
@AutoService(Processor.class)
public class ModuleProcessor extends AbstractProcessor {
private Filer filerUtils; // 文件写入
private Elements elementUtils; // 操作Element工具类
private Messager messagerUtils; // Log 日志
private Map<String, String> options; // 额外配置参数
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
super.init(processingEnvironment);
filerUtils = processingEnvironment.getFiler();
elementUtils = processingEnvironment.getElementUtils();
messagerUtils = processingEnvironment.getMessager();
options = processingEnvironment.getOptions();
}
@Override
public Set<String> getSupportedAnnotationTypes() {
Set<String> types = new LinkedHashSet<>();
types.add(ModuleWrapper.class.getCanonicalName());
return types;
}
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
initModuleMap(roundEnvironment);
return false;
}
private void initModuleMap(RoundEnvironment roundEnv) {
//获取对应的注解元素
Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(ModuleWrapper.class);
for (Element element : set) {
//如果是个类
if (element.getKind() == ElementKind.CLASS) {
//获取类名
String clzName = element.getSimpleName().toString();
//对元素进行处理，可用javapoet生成Java代码
......
} else {
messagerUtils.printMessage(Diagnostic.Kind.NOTE, "only support class");
}
}
}
}
3、AbstractProcessor实现方法介绍
- init()：初始化过程，可通过初始化方法获取各种工具类
- process()：注解处理过程，可通过获取注解元素后，对注解元素进行额外处理
- getSupportedAnnotationTypes()：获取需要解析的注解类型
APT知识点
1、初始化介绍
APT初始化阶段为init方法的调用，我们可以使用ProcessingEnvironment获取一些实用类以及获取选项参数等
2、Element介绍
Element是操作元素最主要的类，可通过getElementsAnnotatedWith获取Element的元素，经过getKind()判断元素的类型后，可强制转换成对应的类型，在对应的类型中有着不同的方法可以调用
3、TypeMirror介绍
TypeMirror是一个接口，表示Java编程语言中的类型。这些类型包括基本类型、引用类型、数组类型、类型变量和null类型等等
这里需要注意的是，如果我们通过注解去获取Class类型的值，如果获取的Class未被编译，则会抛出MirroredTypeException异常，此时我们需要通过try-catch语句在catch里去获取我们所需要的类元素
try {
annotation.value();//如果value为Class类型则会报异常
} catch (MirroredTypeException mte) {
DeclaredType classTypeMirror = (DeclaredType) mte.getTypeMirror();
TypeElement classTypeElement = (TypeElement) classTypeMirror.asElement();//通过异常去获取类元素
}
4、Filer介绍
Filer接口支持通过注解处理器创建新文件。可以创建三种文件类型：源文件、类文件和辅助资源文件
5、Messager介绍
Messager接口提供注解处理器用来报告错误消息、警告和其他通知的方式
6、Options介绍
通过getOptions()方法获取选项参数，在gradle文件中配置选项参数值
android {
defaultConfig {
javaCompileOptions {
annotationProcessorOptions {
arguments = [ version : '1.0.0' ]
}
}
}
}
通过ProcessingEnvironment去获取对应的参数
processingEnvironment.getOptions().get("version");
7、获取注解元素
通过RoundEnvironment接口去获取注解元素，通过JavaPoet生成Java代码
APT实战
下面通过APT的实战，进行对项目的模块化划分
1、项目结构
- 创建Module，名为annotation，放置我们的注解类
- 创建Module，名为compiler，放置我们的注解处理类
- 主工程则直接依赖annotation和compiler 注意事项：创建Module的时候，需要选择java Lib，而不是Android Lib
2、Gradle配置
annotation的Module必须声明Java编译版本
apply plugin: 'java-library'
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
}
sourceCompatibility = "1.7"
targetCompatibility = "1.7"
compiler的Module必须声明Java编译版本，且依赖于annotation和导入我们所需的库
apply plugin: 'java-library'
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation project(':annotation')
implementation 'com.google.auto.service:auto-service:1.0-rc2'
implementation 'com.squareup:javapoet:1.7.0'
}
sourceCompatibility = "1.7"
targetCompatibility = "1.7"
主工程必须通过依赖annotaion和compiler，由于我们只是在编译期生效，可用annotationProcessor
implementation project(':annotation')
annotationProcessor project(':compiler')
注意事项：定义编译的jdk版本为1.7
3、定义注解
ModuleWrapper注解，表示需要加载的模块
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ModuleWrapper {
}
IModule接口，表示当前类是一个模块类
public interface IModule {
String getModuleName();
}
4、定义Processor
@AutoService(Processor.class)
public class ModuleProcessor extends AbstractProcessor {
private Map<String, ModuleInfo> moduleMaps = new HashMap<>();
private Filer filerUtils; // 文件写入
private Elements elementUtils; // 操作Element 的工具类
private Messager messagerUtils; // Log 日志
private Map<String, String> options;
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
super.init(processingEnvironment);
filerUtils = processingEnvironment.getFiler();
elementUtils = processingEnvironment.getElementUtils();
messagerUtils = processingEnvironment.getMessager();
options = processingEnvironment.getOptions();
}
@Override
public Set<String> getSupportedAnnotationTypes() {
Set<String> types = new LinkedHashSet<>();
types.add(ModuleWrapper.class.getCanonicalName());
return types;
}
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
try {
initModuleMap(roundEnvironment);
createModuleMap();
createModuleConstant();
} catch (IOException e) {
e.printStackTrace();
}
return false;
}
/**
* 通过注解元素获取组件实体
*
* @param roundEnv
*/
private void initModuleMap(RoundEnvironment roundEnv) {
Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(ModuleWrapper.class);
for (Element element : set) {
if (element.getKind() == ElementKind.CLASS) {
String clzName = element.getSimpleName().toString();
if (moduleMaps.get(clzName) == null) {
ModuleInfo info = new ModuleInfo(elementUtils, (TypeElement) element);
moduleMaps.put(clzName, info);
}
} else {
messagerUtils.printMessage(Diagnostic.Kind.NOTE, "only support class");
}
}
}
/**
* 创建组件管理者
*
* @throws IOException
*/
private void createModuleMap() throws IOException {
FieldSpec fieldSpec = FieldSpec
.builder(ParameterizedTypeName.get(HashMap.class, String.class, IModule.class)
, "moduleMap", Modifier.PRIVATE)
.initializer("new HashMap<>()")
.build();
CodeBlock.Builder codeBlock = CodeBlock.builder();
for (String key : moduleMaps.keySet()) {
ModuleInfo info = moduleMaps.get(key);
codeBlock.addStatement("moduleMap.put($S ,new $T())", info.getFullClassName(),
ClassName.get(info.packageName, info.className));
}
MethodSpec initMethod = MethodSpec.methodBuilder("init")
.addModifiers(Modifier.PUBLIC)
.addCode(codeBlock.build())
.returns(TypeName.VOID)
.build();
MethodSpec getMethod = MethodSpec.methodBuilder("get")
.addModifiers(Modifier.PUBLIC)
.addParameter(String.class, "cls")
.addStatement("return moduleMap.get(cls)")
.returns(IModule.class)
.build();
ArrayList<MethodSpec> methods = new ArrayList<>();
methods.add(initMethod);
methods.add(getMethod);
TypeSpec moduleFactory = TypeSpec.classBuilder("ModuleFactory")
.addModifiers(Modifier.PUBLIC)
.addMethods(methods)
.addField(fieldSpec)
.build();
JavaFile javaFile = JavaFile.builder("com.hensen.compiler.processor", moduleFactory)
.build();
javaFile.writeTo(filerUtils);
}
/**
* 创建组件常量
*
* @throws IOException
*/
private void createModuleConstant() throws IOException {
TypeSpec.Builder moduleConstant = TypeSpec.classBuilder("ModuleConstant")
.addModifiers(Modifier.PUBLIC);
for (String key : moduleMaps.keySet()) {
ModuleInfo info = moduleMaps.get(key);
FieldSpec fieldSpec = FieldSpec.builder(String.class, info.className)
.addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
.initializer("$S", info.getFullClassName())
.build();
moduleConstant.addField(fieldSpec);
}
JavaFile javaFile = JavaFile.builder("com.hensen.compiler.processor", moduleConstant.build())
.build();
javaFile.writeTo(filerUtils);
}
}
5、组件实体
组件实体保存着组件的信息
public class ModuleInfo {
public String packageName;
public String className;
public ModuleInfo(Elements elementUtils, TypeElement typeElement) {
packageName = getPackageName(elementUtils, typeElement);
className = getClassName(typeElement, packageName);
}
public String getClassName(TypeElement type, String packageName) {
int packageLen = packageName.length() + 1;
return type.getQualifiedName().toString().substring(packageLen)
.replace('.', '$');
}
public String getPackageName(Elements elementUtils, TypeElement classElement) {
PackageElement packageElement = elementUtils.getPackageOf(classElement);
return packageElement.getQualifiedName().toString();
}
public String getFullClassName() {
return packageName + "." + className;
}
public String getClassName(){
return className;
}
}
6、注解使用
分别创建出礼物模块和聊天模块，聊天模块增加发消息的方法
@ModuleWrapper
public class ChatModule implements IModule{
@Override
public String getModuleName() {
return "ChatModule";
}
public void sendMessage() {
Log.i("TAG", "Hi");
}
}
@ModuleWrapper
public class GiftModule implements IModule{
@Override
public String getModuleName() {
return "GiftModule";
}
}
7、生成代码
在生成代码之前需要gradle build，查看生成代码。当然对于模块来说，不仅有get()、还有add()、remove()等其他扩展功能，具体的就留给大家去操作
public class ModuleFactory {
private HashMap<String, IModule> moduleMap = new HashMap<>();
public void init() {
moduleMap.put("com.hensen.geneapt.GiftModule" ,new GiftModule());
moduleMap.put("com.hensen.geneapt.ChatModule" ,new ChatModule());
}
public IModule get(String cls) {
return moduleMap.get(cls);
}
}
public class ModuleConstant {
public static final String GiftModule = "com.hensen.geneapt.GiftModule";
public static final String ChatModule = "com.hensen.geneapt.ChatModule";
}
8、组件使用
初始化组件的加载，通过工厂获取对应的模块进行操作
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ModuleFactory moduleFactory = new ModuleFactory();
moduleFactory.init();
ChatModule chatModule = (ChatModule) moduleFactory.get(ModuleConstant.ChatModule);
chatModule.sendMessage();
}
}
文末送福利啦！！
同时我经过多年的收藏目前也算收集到了一套完整的学习资料以及高清详细的Android架构进阶学习导图及笔记免费分享给大家，希望对想成为架构师的朋友有一定的参考和帮助。 **下面是部分资料截图，诚意满满：特别适合有开发经验的Android程序员们学习。
