Java注解处理器学习之编译时处理的注解详析-eolink官网

Java注解处理器学习之编译时处理的注解详析

1. 一些基本概念

在开始之前，我们需要声明一件重要的事情是：我们不是在讨论在运行时通过反射机制运行处理的注解，而是在讨论在编译时处理的注解。

编译时注解跟运行时注解到底区别在什么地方？其实说大也不大，主要是考虑到性能上面的问题。运行时注解主要是完全依赖于反射，反射的效率比原生的慢，所以在内存比较少，CPU比较烂的机器上会有一些卡顿现象出现。而编译时注解完全不会有这个问题，因为它在我们编译过程（java->class）中，通过一些注解标示，去动态生成一些类或者文件，所以跟我们的APK运行完全没有任何关系，自然就不存在性能上的问题。所以一般比较著名的开源项目如果采用注解功能，通常采用编译时注解

注解处理器是 javac 自带的一个工具，用来在编译时期扫描处理注解信息。你可以为某些注解注册自己的注解处理器。这里，我假设你已经了解什么是注解及如何自定义注解。如果你还未了解注解的话，可以查看官方文档。注解处理器在 Java 5 的时候就已经存在了，但直到 Java 6 （发布于2006看十二月）的时候才有可用的API。过了一段时间java的使用者们才意识到注解处理器的强大。所以最近几年它才开始流行。

一个特定注解的处理器以 java 源代码（或者已编译的字节码）作为输入，然后生成一些文件（通常是.java文件）作为输出。那意味着什么呢？你可以生成 java 代码！这些 java 代码在生成的.java文件中。因此你不能改变已经存在的java类，例如添加一个方法。这些生成的 java 文件跟其他手动编写的 java 源代码一样，将会被 javac 编译。

Annotation processing是在编译阶段执行的，它的原理就是读入Java源代码，解析注解，然后生成新的Java代码。新生成的Java代码最后被编译成Java字节码，注解解析器（Annotation Processor）不能改变读入的Java 类，比如不能加入或删除Java方法。

2. AbstractProcessor

让我们来看一下处理器的 API。所有的处理器都继承了AbstractProcessor，如下所示：

package com.example;

import java.util.LinkedHashSet;

import java.util.Set;

import javax.annotation.processing.AbstractProcessor;

import javax.annotation.processing.ProcessingEnvironment;

import javax.annotation.processing.RoundEnvironment;

import javax.annotation.processing.SupportedAnnotationTypes;

import javax.annotation.processing.SupportedSourceVersion;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.TypeElement;

public class MyProcessor extends AbstractProcessor {

@Override

public boolean process(Set extends TypeElement> annoations,

RoundEnvironment env) {

return false;

}

@Override

public Set getSupportedAnnotationTypes() {

Set annotataions = new LinkedHashSet();

annotataions.add("com.example.MyAnnotation");

return annotataions;

}

@Override

public SourceVersion getSupportedSourceVersion() {

return SourceVersion.latestSupported();

}

@Override

public synchronized void init(ProcessingEnvironment processingEnv) {

super.init(processingEnv);

}

init(ProcessingEnvironment processingEnv) ：所有的注解处理器类都必须有一个无参构造函数。然而，有一个特殊的方法init()，它会被注解处理工具调用，以ProcessingEnvironment作为参数。ProcessingEnvironment 提供了一些实用的工具类Elements, Types和Filer。我们在后面将会使用到它们。

getSupportedAnnotationTypes()：在这个方法里面你必须指定哪些注解应该被注解处理器注册。注意，它的返回值是一个String集合，包含了你的注解处理器想要处理的注解类型的全称。换句话说，你在这里定义你的注解处理器要处理哪些注解。

getSupportedSourceVersion() ：用来指定你使用的 java 版本。通常你应该返回SourceVersion.latestSupported() 。不过，如果你有足够的理由坚持用 java 6 的话，你也可以返回SourceVersion.RELEASE_6。我建议使用SourceVersion.latestSupported() 。在 Java 7 中，你也可以使用注解的方式来替代重写getSupportedAnnotationTypes() 和 getSupportedSourceVersion() ，如下所示：

@SupportedSourceVersion(value=SourceVersion.RELEASE_7)

@SupportedAnnotationTypes({

// Set of full qullified annotation type names

"com.example.MyAnnotation",

"com.example.AnotherAnnotation"

})

public class MyProcessor extends AbstractProcessor {

@Override

public boolean process(Set extends TypeElement> annoations,

RoundEnvironment env) {

return false;

}

@Override

public synchronized void init(ProcessingEnvironment processingEnv) {

super.init(processingEnv);

}

由于兼容性问题，特别是对于 android ，我建议重写getSupportedAnnotationTypes() 和 getSupportedSourceVersion() ，而不是使用 @SupportedAnnotationTypes 和 @SupportedSourceVersion。

接下来你必须知道的事情是：注解处理器运行在它自己的 JVM 中。是的，你没看错。javac 启动了一个完整的 java 虚拟机来运行注解处理器。这意味着什么？你可以使用任何你在普通 java 程序中使用的东西。使用 guava! 你可以使用依赖注入工具，比如dagger或者任何其他你想使用的类库。但不要忘记，即使只是一个小小的处理器，你也应该注意使用高效的算法及设计模式，就像你在开发其他 java 程序中所做的一样。

3. 注册你的处理器

你可能会问 “怎样注册我的注解处理器到 javac ？”。你必须提供一个.jar文件。就像其他 .jar 文件一样，你将你已经编译好的注解处理器打包到此文件中。并且，在你的 .jar 文件中，你必须打包一个特殊的文件javax.annotation.processing.Processor到META-INF/services目录下。因此你的 .jar 文件目录结构看起来就你这样：

MyProcess.jar

-com

-example

-MyProcess.class

-META-INF

-services

-javax.annotation.processing.Processor

javax.annotation.processing.Processor 文件的内容是一个列表，每一行是一个注解处理器的全称。例如：

com.example.MyProcess

com.example.AnotherProcess

4. 例子：工厂模式

我们要解决的问题是：我们要实现一个 pizza 店，这个 pizza 店提供给顾客两种 pizza （Margherita 和 Calzone），还有甜点 Tiramisu（提拉米苏）。

public interface Meal {

public float getPrice();

}

public class MargheritaPizza implements Meal{

@Override

public float getPrice() {

return 6.0f;

}

public class CalzonePizza implements Meal{

@Override

public float getPrice() {

return 8.5f;

}

public class Tiramisu implements Meal{

@Override

public float getPrice() {

return 4.5f;

}

public class PizzaStore {

public Meal order(String mealName) {

if (null == mealName) {

throw new IllegalArgumentException("name of meal is null!");

}

if ("Margherita".equals(mealName)) {

return new MargheritaPizza();

}

if ("Calzone".equals(mealName)) {

return new CalzonePizza();

}

if ("Tiramisu".equals(mealName)) {

return new Tiramisu();

}

throw new IllegalArgumentException("Unknown meal '" + mealName + "'");

}

private static String readConsole() {

Scanner scanner = new Scanner(System.in);

String http://meal = scanner.nextLine();

scanner.close();

return meal;

}

public static void main(String[] args) {

System.out.println("welcome to pizza store");

PizzaStore pizzaStore = new PizzaStore();

Meal meal = pizzaStore.order(readConsole());

System.out.println("Bill:$" + meal.getPrice());

}

正如你所见，在order()方法中，我们有许多 if 条件判断语句。并且，如果我们添加一种新的 pizza 的话，我们就得添加一个新的 if 条件判断。但是等一下，使用注解处理器和工厂模式，我们可以让一个注解处理器生成这些 if 语句。如此一来，我们想要的代码就像这样子：

public class PizzaStore {

private MealFactory factory = new MealFactory();

public Meal order(String mealName) {

return factory.create(mealName);

}

private static String readConsole() {

Scanner scanner = new Scanner(System.in);

String meal = scanner.nextLine();

scanner.close();

return meal;

}

public static void main(String[] args) {

System.out.println("welcome to pizza store");

PizzaStore pizzaStore = new PizzaStore();

Meal meal = pizzaStore.order(readConsole());

System.out.println("Bill:$" + meal.getPrice());

}

public class MealFactory {

public Meal create(String id) {

if (id == null) {

throw new IllegalArgumentException("id is null!");

}

if ("Calzone".equals(id)) {

return new CalzonePizza();

}

if ("Tiramisu".equals(id)) {

return new Tiramisu();

}

if ("Margherita".equals(id)) {

return new MargheritaPizza();

}

throw new IllegalArgumentException("Unknown id = " + id);

}

5. @Factory Annotation

能猜到么，我们打算使用注解处理器生成MealFactory类。更一般的说，我们想要提供一个注解和一个处理器用来生成工厂类。

让我们看一下@Factory注解：

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.CLASS)

public @interface Factory {

/**

* The name of the factory

Class> type();

/**

* The identifier for determining which item should be instantiated

String id();

}

思想是这样的：我们注解那些食物类，使用type()表示这个类属于哪个工厂，使用id()表示这个类的具体类型。让我们将@Factory注解应用到这些类上吧：

@Factory(type=MargheritaPizza.class, id="Margherita")

public class MargheritaPizza implements Meal{

@Override

public float getPrice() {

return 6.0f;

}

@Factory(type=CalzonePizza.class, id="Calzone")

public class CalzonePizza implements Meal{

@Override

public float getPrice() {

return 8.5f;

}

@Factory(type=Tiramisu.class, id="Tiramisu")

public class Tiramisu implements Meal{

@Override

public float getPrice() {

return 4.5f;

}

你可能会问，我们是不是可以只将@Factory注解应用到Meal接口上？答案是不行，因为注解是不能被继承的。即在class X上有注解，class Y extends X，那么class Y是不会继承class X上的注解的。在我们编写处理器之前，需要明确几点规则：

只有类能够被@Factory注解，因为接口和虚类是不能通过new操作符实例化的。

被@Factory注解的类必须提供一个默认的无参构造函数。否则，我们不能实例化一个对象。

被@Factory注解的类必须直接继承或者间接继承type指定的类型。（或者实现它，如果type指定的是一个接口）

被@Factorhttp://y注解的类中，具有相同的type类型的话，这些类就会被组织起来生成一个工厂类。工厂类以Factory作为后缀，例如：type=Meal.class将会生成MealFactory类。

id的值只能是字符串，且在它的type组中必须是唯一的。

注解处理器：

public class FactoryProcessor extends AbstractProcessor {

private Types typeUtils;

private Elements elementUtils;

private Filer filer;

private Messager messager;

private Map factoryClasses =

new LinkedHashMap();

@Override

public synchronized void init(ProcessingEnvironment processingEnv) {

super.init(processingEnv);

typeUtils = processingEnv.getTypeUtils();

elementUtils = processingEnv.getElementUtils();

filer = processingEnv.getFiler();

messager = processingEnv.getMessager();

}

@Override

public boolean process(Set extends TypeElement> arg0,

RoundEnvironment arg1) {

...

return false;

}

@Override

public Set getSupportedAnnotationTypes() {

Set annotataions = new LinkedHashSet();

annotataions.add(Factory.class.getCanonicalName());

return annotataions;

}

@Override

public SourceVersion getSupportedSourceVersion() {

return SourceVersion.latestbIVWwySeaSupported();

}

在getSupportedAnnotationTypes()方法中，我们指定@Factory注解将被这个处理器处理。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对我们的支持。

Flask接口签名sign原理与实例代码浅析

268 2023-02-05

Java注解处理器学习之编译时处理的注解详析

多平台统一管理软件接口，如何实现多平台统一管理软件接口

Flask接口签名sign原理与实例代码浅析

java中的接口是类吗

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！