Java编译时注解学习，并简单实现Lombok

左手的ㄟ右手 2024-04-07 10:09 140阅读 0赞

编译时注解可以用来动态生成代码. 使用 SOURCE 类型注解的代码会在编译时被解析, 生成新的 java 文件, 然后和原来的 java 文件一起编译成字节码. 由于不使用反射功能, 编译时注解不会拖累性能, 因而被许多框架使用, 比如 Butter Knife, Dragger2 等.

**一些基本概念**

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

编译时注解跟运行时注解到底区别在什么地方？其实说大也不大，主要是考虑到性能上面的问题。运行时注解主要是完全依赖于反射，反射的效率比原生的慢，所以在内存比较少，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方法。

### 实现一个简单的lombok ###

实现一个简单的lombok主要分为两个步骤，第一是实现Processor接口处理注解，第二是注册注解处理器。

#### **1.创建我们自定义的注解** ####

@Retention(RetentionPolicy.SOURCE) // 注解只在源码中保留
    @Target(ElementType.TYPE) // 用于修饰类
    public @interface MySetterGetter {
    
    }

#### **2.实现Processor接口** ####

通过实现Processor接口可以自定义注解处理器，这里我们采用更简单的方法通过继承AbstractProcessor类实现自定义注解处理器。实现抽象方法process处理我们想要的功能。

首先pom文件先引入依赖（jdk文件夹的tools.jar工具类），实现注解时会使用到tools工具类里面的一些方法

<dependency>
                <groupId>com.sun</groupId>
                <artifactId>tools</artifactId>
                <version>1.8</version>
                <scope>system</scope>
                <systemPath>D:/tool/jdk1.8.0_111/lib/tools.jar</systemPath>
            </dependency>

实现接口，需要先引入tools.jar工具包。

@SupportedAnnotationTypes(value = {"com.example.zcs.annotation.lombokTest.MySetterGetter"})
    @SupportedSourceVersion(SourceVersion.RELEASE_8)
    public class CustomProcessor extends AbstractProcessor {
        /**
         * AST
         */
        private JavacTrees trees;
        /**
         * 操作修改AST
         */
        private TreeMaker treeMaker;
        /**
         * 符号封装类，处理名称
         */
        private Names names;
        /**
         * 打印信息
         */
        private Messager messager;
    
        @Override
        public synchronized void init(ProcessingEnvironment processingEnv) {
            super.init(processingEnv);
            trees = JavacTrees.instance(processingEnv);
            final Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
            treeMaker = TreeMaker.instance(context);
            names = Names.instance(context);
            messager = processingEnv.getMessager();
        }
    
        @Override
        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
            System.out.println("begin");
            System.out.println("start annotation process .999999999999999999999999");
    
            final Set<? extends Element> dataAnnotations = roundEnv.getElementsAnnotatedWith(com.example.zcs.annotation.lombokTest.MySetterGetter.class);
    
            dataAnnotations.stream().map(element -> trees.getTree(element)).forEach(
                    tree -> tree.accept(new TreeTranslator() {
                        @Override
                        public void visitMethodDef(JCTree.JCMethodDecl jcMethodDecl) {
                            // print method name
                            System.out.println("-------------2");
                            messager.printMessage(Diagnostic.Kind.NOTE, jcMethodDecl.toString());
                            super.visitMethodDef(jcMethodDecl);
                        }
    
                        @Override
                        public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
    
                            System.out.println("-------------1");
                            final Map<Name, JCTree.JCVariableDecl> treeMap =
                                    jcClassDecl.defs.stream().filter(k -> k.getKind().equals(Tree.Kind.VARIABLE))
                                            .map(tree -> (JCTree.JCVariableDecl) tree)
                                            .collect(Collectors.toMap(JCTree.JCVariableDecl::getName, Function.identity()));
    
                            treeMap.forEach((k, var) -> {
                                messager.printMessage(Diagnostic.Kind.NOTE, "var:" + k);
                                System.out.println("-------------3");
                                try {
                                    // add getter
                                    jcClassDecl.defs = jcClassDecl.defs.prepend(getter(var));
                                    // add setter
                                    jcClassDecl.defs = jcClassDecl.defs.prepend(setter(var));
    //                                jcClassDecl.defs.prepend(setter(var));
                                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                                    e.printStackTrace();
                                    messager.printMessage(Diagnostic.Kind.ERROR, e.getMessage());
                                }
                            });
    
                            super.visitClassDef(jcClassDecl);
                        }
                    })
            );
            return true;
        }
    
        /**
         * 自定义setter
         */
        private JCTree setter(JCTree.JCVariableDecl var) throws ClassNotFoundException, IllegalAccessException,
                InstantiationException {
            // 方法级别public
            final JCTree.JCModifiers modifiers = treeMaker.Modifiers(Flags.PUBLIC);
    
            final Name varName = var.getName();
            Name methodName = methodName(varName, "set");
    
            // 方法体
            ListBuffer<JCTree.JCStatement> jcStatements = new ListBuffer<>();
            jcStatements.append(treeMaker.Exec(treeMaker.Assign(
                    treeMaker.Select(treeMaker.Ident(names.fromString("this")), varName),
                    treeMaker.Ident(varName)
            )));
            final JCTree.JCBlock block = treeMaker.Block(0, jcStatements.toList());
    
            // 返回值类型void
            JCTree.JCExpression returnType =
                    treeMaker.Type((Type) (Class.forName("com.sun.tools.javac.code.Type$JCVoidType").newInstance()));
    
            List<JCTree.JCTypeParameter> typeParameters = List.nil();
    
            // 参数
            final JCTree.JCVariableDecl paramVars = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER,
                    List.nil()), var.name, var.vartype, null);
            final List<JCTree.JCVariableDecl> params = List.of(paramVars);
    
            List<JCTree.JCExpression> throwClauses = List.nil();
            // 重新构造一个方法, 最后一个参数是方法注解的默认值，这里没有
            return treeMaker.MethodDef(modifiers, methodName, returnType, typeParameters, params, throwClauses, block,
                    null);
        }
    
        /**
         * 构造驼峰命名
         */
        private Name methodName(Name varName, String prefix) {
            return names.fromString(prefix + varName.toString().substring(0, 1).toUpperCase()
                    + varName.toString().substring(1));
        }
    
        /**
         * 构造getter
         */
        private JCTree getter(JCTree.JCVariableDecl var) {
            // 方法级别
            final JCTree.JCModifiers modifiers = treeMaker.Modifiers(Flags.PUBLIC);
    
            // 方法名称
            final Name methodName = methodName(var.getName(), "get");
    
            // 方法内容
            ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();
            statements.append(treeMaker.Return(treeMaker.Select(treeMaker.Ident(names.fromString("this")), var.getName())));
            final JCTree.JCBlock block = treeMaker.Block(0, statements.toList());
    
            // 返回值类型
            final JCTree.JCExpression returnType = var.vartype;
    
            // 没有参数类型
            List<JCTree.JCTypeParameter> typeParameters = List.nil();
    
            // 没有参数变量
            List<JCTree.JCVariableDecl> params = List.nil();
    
            // 没有异常
            List<JCTree.JCExpression> throwClauses = List.nil();
    
            // 构造getter
            return treeMaker.MethodDef(modifiers, methodName, returnType, typeParameters, params, throwClauses, block,
                    null);
        }
    }

#### **3.注册注解处理器** ####

**方式一:**

我们还需要将我们自定义的注解处理器进行注册。新建res文件夹，目录下新建META-INF文件夹，目录下新建services文件夹，目录下新建javax.annotation.processing.Processor文件，然后将我们自定义注解处理器的全类名写到此文件：

![881c9f1fa468474e855dcabec16e874e.png][]

**方式二:**

上面这种注册的方式有点麻烦，谷歌帮我们写了一个注解处理器来生成这个文件,通过引入依赖的方法。

<dependency>
                <groupId>com.google.auto.service</groupId>
                <artifactId>auto-service</artifactId>
                <version>1.0-rc4</version>
                <optional>true</optional>
            </dependency>
    
            <dependency>
                <groupId>com.google.auto</groupId>
                <artifactId>auto-common</artifactId>
                <version>0.10</version>
                <optional>true</optional>
            </dependency>

然后添加注解（这种使用注解进行注册的方式我没有使用过，有兴趣的同学可以使用）

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

#### **4.在pom文件里还要做一个编译插件的配置,不然会编译失败。** ####

<build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.5.1</version>
                    <configuration>
                        <compilerArgument>
                            -proc:none
                        </compilerArgument>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>

没有这个配置编译时会报错:提示服务配置文件不正确, 或构造处理程序对象j

![8fdafd4c2fc74baf855c7a2f5b78d212.jpeg][]  
  
几个配置参数的意思:

## \-proc:\{none,only\}、-procpath、-processor ##

这三个命令是用来自定义“Annotation Processor”的，即你可以自定义注释，比如@Hello，@First 等，解析这些注释就需要"Annotation Processor"。

*  \-processor <CustomProcessor> ：自定义注释处理器的类
 *  \-procpath：注释处理器的查找目录。
 *  \-proc:only：只运行注释处理器，而不编译源文件。
 *  \-proc:none：不使用注释处理器，只编译源文件。

#### **5.代码写完，可以进行编译了，打成jar包引入到别的项目就可以使用了。** ####

![7efe774b55744996bb4f2bd2a298c7a1.png][]

使用mvn clean package 命令打了jar包。

将jar包重命名，并放到一个临时目录，方便引入

![24b17c7b63364eb0b7b02bba6e356386.png][]

####  **6.在别的项目中引入jar包，并对注解进行使用。** ####

首先在pom文件引入jar包，注意jar包目录要改成自己的

<dependency>
                <groupId>com.zcs</groupId>
                <artifactId>lombok</artifactId>
                <version>1.8</version>
                <scope>system</scope>
                <systemPath>C:/Users/zhangchangsi/Desktop/lombok/zcs-lombok.jar</systemPath>
            </dependency>

使用我们的注解声明在类上面。

![8e89db8590ad48d8abd0f19f7570ec44.png][]

@MySetterGetter
    public class UserInfo {
        private String name;
        private int age;
        private boolean flag;
    
        public static void main(String[] args) {
            UserInfo userInfo = new UserInfo();
            userInfo.setName("zcs");
            System.out.println(userInfo.getName());
            System.out.println(userInfo);
        }
    
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", flag=" + flag +
                    '}';
        }
    }

运行main方法可以正常运行:

![c1135fbfcdfb45869f9f474df8882e10.png][]

编译后的java类也能正常生成set/get方法

![34bd9bad1602414187420256c04146a4.png][]

到此就说明我们自己定义的编译时注解已经可以实现自动生成get/set方法了。

[881c9f1fa468474e855dcabec16e874e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/65264c930fb0420098c1e8f4f5c1eed8.png
[8fdafd4c2fc74baf855c7a2f5b78d212.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/d988814b78344b0dbaf50fa6f0f56bd2.jpeg
[7efe774b55744996bb4f2bd2a298c7a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/d519ba1913224778bf2068f1b9cfb773.png
[24b17c7b63364eb0b7b02bba6e356386.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/f58fa13dd28d4864a215d9041d306ef0.png
[8e89db8590ad48d8abd0f19f7570ec44.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/0d8490d3c49c486385d0fdcdaf1de53a.png
[c1135fbfcdfb45869f9f474df8882e10.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/bb0615a16cfe43328cd2e2f97e1e2e34.png
[34bd9bad1602414187420256c04146a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/9bb819a1229c48669dfb3b0ccdbca2b0.png