防lombok实现一个Getter注解，AbstractProcessor实例

最新推荐文章于 2023-11-09 21:46:26 发布
最新推荐文章于 2023-11-09 21:46:26 发布
阅读量380 收藏 1
点赞数 1
分类专栏： java 文章标签： java mybatis spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71777195/article/details/130922108
版权
java 专栏收录该内容
3552 篇文章 115 订阅
订阅专栏

平时都是在用lombok，毕竟用起来简单省事。java还是太繁琐了，最近也想着是不是可以自己简化一下java的相关写法，就想着了解一下lombok. 这里记录一下 自己防lombok实现一个@Getter注解。主要是因为lombok的源码太多。看起来实在是有点费事。

先创建一个工程

用自己习惯的方式，创建一个maven工程。我这里是基于java 17实现的。然后 定义一个Getter注解。

java复制代码package org.example;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
public @interface Getter {
}

接下来是 实现 GetterProcessor 类。

ini复制代码package org.example;

import com.sun.source.tree.ClassTree;
import com.sun.source.tree.Tree;
import com.sun.source.util.SimpleTreeVisitor;
import com.sun.source.util.Trees;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;

import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import  com.sun.tools.javac.tree.JCTree;
import  com.sun.tools.javac.tree.JCTree.JCClassDecl;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import  com.sun.tools.javac.code.Flags;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

@SupportedAnnotationTypes("*")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class GetterProcessor extends AbstractProcessor {

    private ProcessingEnvironment processingEnv;
    private Messager messager;

    private Trees trees;

    private TreeMaker treeMaker;

    private Names names;


    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.messager = processingEnv.getMessager();
        messager.printMessage(Diagnostic.Kind.NOTE,  " -- note  getter init --");
        ProcessingEnvironment unwrappedProcessingEnv = jbUnwrap(ProcessingEnvironment.class, processingEnv);
        this.trees = Trees.instance(unwrappedProcessingEnv);

        Context context = ((JavacProcessingEnvironment) unwrappedProcessingEnv).getContext();
        this.treeMaker = TreeMaker.instance(context);
        this.names = Names.instance(context);
    }

    private static <T> T jbUnwrap(Class<? extends T> iface, T wrapper) {
        T unwrapped = null;
        try {
            final Class<?> apiWrappers = wrapper.getClass().getClassLoader().loadClass("org.jetbrains.jps.javac.APIWrappers");
            final Method unwrapMethod = apiWrappers.getDeclaredMethod("unwrap", Class.class, Object.class);
            unwrapped = iface.cast(unwrapMethod.invoke(null, iface, wrapper));
        }
        catch (Throwable ignored) {}
        return unwrapped != null? unwrapped : wrapper;
    }
    @Override
    public synchronized boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(Getter.class);
        set.forEach(element -> {
            Tree jcTree = trees.getTree(element);
            messager.printMessage(Diagnostic.Kind.NOTE, element.getSimpleName() + " has been processed");
            jcTree.accept(new SimpleTreeVisitor<Void, Void>(){
                @Override
                public Void visitClass(ClassTree node, Void p) {
                    messager.printMessage(Diagnostic.Kind.NOTE, node.getSimpleName() + " visitClass");
                    List<JCTree.JCVariableDecl> list = new ArrayList<>();
                    if(node instanceof  JCClassDecl){
                        JCClassDecl classDecl = (JCClassDecl) node;
                        for (JCTree tree : classDecl.defs) {
                            if (tree.getKind().equals(Tree.Kind.VARIABLE)) {
                                JCTree.JCVariableDecl jcVariableDecl = (JCTree.JCVariableDecl) tree;
                                list.add(jcVariableDecl);
                            }
                        }
                        list.forEach(jcVariableDecl -> {
                            messager.printMessage(Diagnostic.Kind.NOTE, jcVariableDecl.getName() + " variable");
                            classDecl.defs = classDecl.defs.prepend(makeGetterMethodDecl(jcVariableDecl));
                        });
                    }

                    return defaultAction(node, p);
                }
            }, null);

        });

        return true;
    }

    private JCTree.JCMethodDecl makeGetterMethodDecl(JCTree.JCVariableDecl jcVariableDecl) {

        ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();
        statements.append(treeMaker.Return(treeMaker.Select(treeMaker.Ident(names.fromString("this")), jcVariableDecl.getName())));
        JCTree.JCBlock body = treeMaker.Block(0, statements.toList());
        return treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC), getNewMethodName(jcVariableDecl.getName()), jcVariableDecl.vartype,
                com.sun.tools.javac.util.List.nil(), com.sun.tools.javac.util.List.nil(), com.sun.tools.javac.util.List.nil(), body, null);
    }

    private Name getNewMethodName(Name name) {
        String s = name.toString();

        return names.fromString("get" + s.substring(0, 1).toUpperCase() + s.substring(1, name.length()));
    }

}

到这里，主要代码就结束了。

当然这个时候在idea里 就开始报错了。提示：

arduino复制代码Package 'com.sun.tools.javac.tree' is declared in module 'jdk.compiler', which does not export it to the unnamed module

点一下 报错里的提示 ： Add '--add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED' to module compile options. 这是因为java 11后 ，做了模块控制。把其它的几个报错，也点一下。

编译

这个时候 我们直接 通过 mvn install 去编译。会发现 还是会报错

复制代码程序包 com.sun.tools.javac.tree 不可见

我们需要在pom.xml里配置一下插件

xml复制代码<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.0</version>
            <configuration>
                <compilerArgs>
                    <arg>--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
                    <arg>--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
                    <arg>--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED</arg>
                    <arg>--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>

                </compilerArgs>
            </configuration>
        </plugin>
    </plugins>
</build>

这里也是 把 几个 包导出到 ALL-UNNAMED。 这样就可以编译通过了。

让自定义的 GetterProcessor 生效

想让自定义的 GetterProcessor 生效。需要在resource目录下增加 META-INF目录，再在META-INF下增加services目录。在 META-INF/services 目录下新建 javax.annotation.processing.Processor文件。在里面写上这一行。

复制代码org.example.GetterProcessor

这样就知道 需要使用 org.example.GetterProcessor 来处理代码了。

我们再次使用 mvn install 来编译自定义的 GetterProcessor 。

下面是完整的项目文件结构

css复制代码│  pom.xml
├─src
│  ├─main
│  │  ├─java
│  │  │  └─org
│  │  │      └─example
│  │  │              Getter.java
│  │  │              GetterProcessor.java
│  │  └─resources
│  │      └─META-INF
│  │          └─service
│  │                  javax.annotation.processing.Processor

创建测试项目

创建一个测试项目 MyLombokTest 。 引入前面编译好的包

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>MyLombokTest</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>MyLombok</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>
</project>

创建一个测试类 Main

typescript复制代码package org.example;

@Getter
public class Main {
    private String name;

    public Main(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        Main m = new Main("xiao ming");
        System.out.println(m.getName());
    }
}

然后我们在idea里 ctrl+ f9 编译工程。就报错了。

less复制代码E:\code\datecenter\MyLombokTest\src\main\java\org\example\Main.java:13:29
java: 找不到符号
  符号:   方法 getName()
  位置: 类型为org.example.Main的变量 m

这是因为没配置 processor . 到 settings 里配置一下 annotation processors. 加上 org.example.GetterProcessor

再次 编译项目 ， 如果发现下面这几行 我们在前面代码里打印的LOG，就说明 GetterProcessor 生效了。

接下来 就可以运行 Main类。输出

复制代码xiao ming

也可以通过 java -cp .\target\MyLombokTest-1.0.jar org.example.Main 来运行 这个测试类。

总结

在编译时通过注解 修改代码，这样的操作平时我们很少会去实现。更多是使用。在写这个demo时，很多API不熟悉。也是通过网上的资料加上lombok的代码，边看边试着做。还是比较费时间。而且这个工具包没有办法调试，写起来就很麻烦。只能一次次编译，找错误，反复尝试

肥肥技术宅
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义Lombok注解
weixin_30896825的博客
08-22 1845
Java 是一门"繁琐"的语言，使用Lombok可以显著地减少样板代码。比如使用@Getter注解可以为你的私有属性创建 get 方法。 源代码 @Getter private int age = 10; 生成后代码 private int age = 10; public int getAge() { return age; } Lombok 自身已经拥有许...
java使用AbstractProcessor、编译时注解和JCTree实现编译时织入代码（类似lombok）并实现Debug自己的Processor和编译后的代码
dap769815768的博客
06-03 1万+
Java架构师交流群：793825326 java版本：jdk1.8 IDE：idea2019 先说怎么用，现在我们想写一个注解HelloWorld，让所有使用了这个注解的类，在编译的时候都打印“Hello World！”，注意，是在编译的时候，不是运行的时候。那么该怎么做呢，这就要用到AbstractProcessor这个东西了。 1.先创建一个maven项目abstractproces...
javac 编译拓展，像 lombok 一样通过注解生成 自定义方法
我是个农民的博客
04-10 794
javac 编译拓展，像 lombok 一样通过注解生成 自定义方法 <<深入理解java虚拟机>> 第十章介绍了javac的相关知识，提到可以通过拓展 javax.annotation.processing.Processor 在编译阶段可以自定义一些操作。还提到lombok也是通过这种方式进行代码生成。所以尝试自己来写一个玩玩，根据注解生成一个方法。 参照书上的做法 : 新建一个项目,结构如下 具体内容: CreatePrint注解： package com.rxf113;
【学习总结】自定义lombok注解
qq_42563471的博客
11-16 1192
​ 官网对他的功能的描述：ProjectLombok是一个java库，可以自动插入编辑器和构建工具，为您的java增添色彩。永远不要再编写另一个getter或equals方法，只要有一个注释，您的类就有一个功能齐全的构建器，自动化您的日志变量，等等。​ 根据官网的解释我们可以把lombok定位为一个构建工具插件。​ Java语言的”编译期“其实是一段”不确定“的操作过程，因为他可能是指一个前端编译器（其实叫”编译器的前端“更准确一些）把 *.java文件转变成 *.class文件；
注解编译处理器实战(Lombok实现原理)
qq_38758009的博客
05-12 342
Lombok实现原理，如何使用APT实现编译期对于代码的增强
AbstractProcessor使用小结
梦想不只是梦与想的博客
11-11 3263
1、没有注册信息，也就没有目标类生成 使用 google auto-service 添加依赖，一定别忘了加 annotationProcessor，auto-service 的原理是找到被@AutoService标记的自己写的Processor，然后生成注册信息，如果没依赖 annotationProcessor 就没有注册信息，也就没有目标类生成 build.gradle dependencies { implementation 'com.google.auto.service:au
eclipse注解lombok.jar
11-12
通过在类上使用@Slf4j注解，Lombok会为该类生成一个Logger实例，方便进行日志记录。 在Windows环境下安装Lombok插件，你需要遵循以下步骤： 1. 下载Lombok插件的最新版本jar文件，通常可以从Lombok官方网站获取。 ...
Java自定义注解实例
11-03
1. **创建**: 自定义注解通过定义一个接口实现，接口的名字即为注解的名字。例如： ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface MyAnnotation { String ...
lombok-sandbox:Lombok学习实例
05-26
Lombok 是一个 Java 库，它通过注解处理器在编译时自动插入代码，从而简化 Java 类的编写，避免了大量的getter、setter、构造函数以及equals()、hashCode() 和toString() 等冗余方法。在"Lombok学习实例"中，我们...
spring boot3+jpa+lombok+mapstruct实现的restful api例子
05-08
在本项目中，"spring boot3+jpa+lombok+mapstruct实现的restful api例子"是一个集成多种技术的示例，旨在展示如何高效地构建RESTful API服务。下面将详细介绍这些关键技术及其相互间的配合。 1. **Spring Boot 3**:...
lombok-jar包.zip
09-03
1. `@Data`：这是一个综合性的注解，它可以为类生成所有字段的getter和setter，同时还会添加equals()、hashCode()以及toString()方法。这大大简化了创建POJO（Plain Old Java Object）类的工作。 2. `@NonNull`：...
AbstractProcessor: 利用注解动态生成代码
ZhangJian的博客
03-26 1万+
注解动态生成代码
Idea 调试自定义 AbstractProcessor 程序
qq_35530330的博客
12-10 1276
我们常使用的Lombok可以自动生成gettr和setter方法，使用起来非常方便；有时候我们也要去实现自己的注解处理器，实现一些在编译阶段需要执行的逻辑，例如我之前写的自动生成openfeign的Fallback降级方法；但是自定义注解处理器断点调试并不友好，网上找了很多教程基本上都不太实用；
Lombok注解之@Getter
老猫喜欢今日爬山的博客
06-29 2280
生成属性的get方法。注意：与setter不同的是，@Getter注解会生成final修饰的属性。
AbstractProcessor注解处理器
有码走遍天下，无码寸步难行
07-03 1万+
1. 注解一般我们定义一个注解的代码如下:@Retention(RetentionPolicy.CLASS) @Target({ElementType.FIELD, ElementType.TYPE}) public @interface Json { String value(); }在注解上面的注解叫做元注解，元注解共有四种: - @Retention: 保留的范围，默认值为CLASS.
自定义注解继承AbstractProcessor，编译时不执行process方法？
喂_balabala
06-28 2029
问题描述： 继承AbstractProcessor并重写init、process、getSupportedAnnotationTypes方法，编译时init和getSupportedAnnotationTypes都执行了，就是不执行process方法 我项目的原因： 把注解用在kotlin文件上了，只能在java文件中使用（困扰了几天，一直没往这方面想！！针对kotlin文件可能要换种写法，暂未研究，知道的同学可以留言） 并且自动生成的代码路径因项目不同可能不同，比如我的是在 app/build/gener
Java注解编译期处理AbstractProcessor详解
热门推荐
LoveSummer
05-30 3万+
我们接触的注解主要分为以下两类运行时注解：通过反射在运行时动态处理注解的逻辑编译时注解：通过注解处理器在编译期动态处理相关逻辑平时我们接触的框架大部分都是运行时注解，比如：@Autowire @Resoure @Bean 等等。那么我们平时有接触过哪些编译期注解呢，@Lombok等等像这些编译时注解的作用都是自动生成代码，一是为了提高编码的效率，二是避免在运行期大量使用反射，通过在编译期利用反射生成辅助类和方法以供运行时使用。那这些编译器注解都是如何运行的呢?又是怎么自动生成代码的呢？
编译时注解 AbstractProcessor （Activity路由Demo）
许佳佳的博客
03-22 2670
概述 前一篇文章已经整理过注解的一些概念，也是附上了运行时注解的Demo，如果对注解概念不是很熟的读者建议先看下前一篇文章：android 注解入门（Acitivity路由demo） 此篇文章主要讲一下编译时注解的使用，同时也是以”Activity路由“的Demo为例子。 本篇的Demo主要是演示了使用编译时注解来创建文件的功能。 主要模块 anotationrouter：创建注解 pro...
2023.11.9 IDEA 配置 Lombok
最新发布
weixin_63888301的博客
11-09 4151
什么是 Lombok 如何使用 Lombok Lombok 的 @Data 注解 Lombok 注释说明
lombok的构造方法注入注解
05-25
Lombok提供了两种常用的构造方法注入注解：@AllArgsConstructor和@NoArgsConstructor。 @AllArgsConstructor注解会自动生成一个包含所有参数的构造方法，可以用于注入Bean的依赖项。例如： ``` @AllArgsConstructor public class Person { private String name; private int age; private String address; } ``` 在这个例子中，Lombok将生成一个包含所有参数的构造方法。 @NoArgsConstructor注解会自动生成一个无参构造方法，可以用于创建Bean实例。例如： ``` @NoArgsConstructor public class Person { private String name; private int age; private String address; } ``` 在这个例子中，Lombok将生成一个无参构造方法。 当然，如果你需要同时使用这两种注解，也可以使用@Data注解，它包含了@Getter、@Setter、@ToString、@EqualsAndHashCode和@AllArgsConstructor这些注解。例如： ``` @Data public class Person { private String name; private int age; private String address; } ``` 在这个例子中，Lombok将为这个类生成所有的getter和setter方法，以及toString和equals/hashCode方法，还有包含所有参数的构造方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值