IDEA插件编写一（采用AbstractProcessor编写DEMO）

已于 2023-06-07 10:56:00 修改
阅读量1k 收藏 6
点赞数 1
分类专栏： IDEA插件 文章标签： intellij-idea java ide
于 2022-10-20 15:21:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang5525369/article/details/127427717
版权

目录

1.什么是AbstractProcessor

2.自动生成属性jar包

2.1 注解声明

2.2 注解拦截模块代码

2.3 注解拦截模块资源文件

2.4 注解拦截模块POM文件

 2. 测试DEMO

3.调试程序

1.什么是AbstractProcessor

AbstractProcessor是java提供的可以在编译期对自定义的注解进行拦截，根据需求生成对应的类文件。本次demo主要是给注解类自动生成对应的属性

2.自动生成属性jar包

2.1 注解声明

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AddField {
    String fieldName() default "";
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AddConstructor {
}

2.2 注解拦截模块代码

import com.sun.source.tree.Tree;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.model.JavacElements;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.TreeTranslator;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.List;
import com.wangxb.annotation.AddField;
import com.wangxb.annotation.AddConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import com.sun.tools.javac.api.JavacTrees;

import javax.annotation.processing.*;
import javax.lang.model.element.*;
import com.sun.tools.javac.util.Names;

import javax.lang.model.util.Types;
import javax.tools.Diagnostic;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class AddPropertieProcess  extends AbstractProcessor{

    //创建新的源，类或辅助文件的文件管理器
    Filer filer;
    //元素进行操作的一些实用方法的实现
    JavacElements elements;
    //报告错误，警告和其他通知的信使
    Messager messager;
    //注解处理工具的处理器特定选项
    Map<String,String> options;
    //用于对类型进行操作的实用方法的实现
    Types types;


    private static Map<String, String> tis = new ConcurrentHashMap<>();

    private JavacTrees javacTrees;

    private TreeMaker treeMaker;

    private Names names;

    @Override
    public void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        filer = processingEnv.getFiler();
        elements = (JavacElements) processingEnv.getElementUtils();
        messager = processingEnv.getMessager();
        options = processingEnv.getOptions();
        types = processingEnv.getTypeUtils();

        javacTrees = JavacTrees.instance(processingEnv);
        Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
        treeMaker = TreeMaker.instance(context);
        names = Names.instance(context);

    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> set = new HashSet<>();
        set.add(AddField.class.getCanonicalName());
        return set;

    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        boolean bRet = false;
        Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(AddField.class);
        messager.printMessage(Diagnostic.Kind.WARNING,"测试消息");
        for(Element element : set){
            bRet = addField(element);
            bRet = addConstructor(element);
        }
        return bRet = false;
    }

    //添加属性及方法
    boolean addField(Element element){
        System.out.println("添加属性及方法");
        boolean bRet = false;
        ElementKind elementKind = element.getKind();
        if (elementKind != ElementKind.CLASS){
            return bRet;
        }
        AddField addField = element.getAnnotation(AddField.class);
        String fieldName = addField.fieldName();
        if (StringUtils.isBlank(fieldName)){
            return bRet;
        }

        JCTree jcTree = elements.getTree(element);

        jcTree.accept(new TreeTranslator() {
            @Override
            public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
                treeMaker.pos = jcClassDecl.pos;//注意 偏移必须对准
                JCTree.JCVariableDecl jcVariableDecl = treeMaker.VarDef(treeMaker.Modifiers(Flags.PUBLIC),names.fromString(fieldName),treeMaker.Ident(names.fromString("String")),treeMaker.Literal("abc"));
                jcClassDecl.defs = jcClassDecl.defs.append(jcVariableDecl);

                if (addField.methed() == true){
                    jcClassDecl = addGetMethed(jcClassDecl,jcVariableDecl);
                    jcClassDecl = addSetMethed(jcClassDecl,jcVariableDecl);
                }

                this.result = jcClassDecl;
                super.visitClassDef(jcClassDecl);
            }
        });

        return bRet = true;
    }

    //添加Get方法
    JCTree.JCClassDecl addGetMethed(JCTree.JCClassDecl jcClassDecl,JCTree.JCVariableDecl jcVariableDecl){
        JCTree.JCIdent jcIdent = treeMaker.Ident(names.fromString("this"));
        JCTree.JCExpression jcExpression = treeMaker.Select(jcIdent, jcVariableDecl.getName());
        JCTree.JCReturn jcReturn = treeMaker.Return(jcExpression);
        ArrayList<JCTree.JCStatement> jcStatementList = new ArrayList<JCTree.JCStatement>();
        jcStatementList.add(jcReturn);
        JCTree.JCBlock jcBlock = treeMaker.Block(0, List.from(jcStatementList));

        String methedName = "get" + jcVariableDecl.name.toString();

        JCTree.JCMethodDecl jcMethodDecl = treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),names.fromString(methedName),jcVariableDecl.vartype, List.nil(),List.nil(),List.nil(),jcBlock,null);
        jcClassDecl.defs = jcClassDecl.defs.append(jcMethodDecl);
        return jcClassDecl;
    }

    //添加Set方法
    JCTree.JCClassDecl addSetMethed(JCTree.JCClassDecl jcClassDecl,JCTree.JCVariableDecl jcVariableDecl){
        ArrayList<JCTree.JCStatement> jcStatementList = new ArrayList<JCTree.JCStatement>();

        String methedName = "set" + jcVariableDecl.name.toString();
        JCTree.JCVariableDecl jcParamVariableDecl = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER),jcVariableDecl.name,jcVariableDecl.vartype,null);

        String memberAccess = "this." + jcVariableDecl.getName();
        JCTree.JCExpression jcExpression = memberAccess(memberAccess);

        JCTree.JCStatement jcStatement = memberAssign(jcExpression,jcParamVariableDecl);

        jcStatementList.add(jcStatement);

        JCTree.JCExpression jcParamType = memberAccess("java.lang.String");
        ArrayList<JCTree.JCExpression> paramTypeList = new ArrayList();
        paramTypeList.add(jcParamType);
        paramTypeList.add(jcParamType);


        JCTree.JCExpression printLiteral = varDef("%s");
        JCTree.JCExpression paramValue = varDef(jcParamVariableDecl);

        ArrayList<JCTree.JCExpression> paramValueList = new ArrayList();
        paramValueList.add(printLiteral);
        paramValueList.add(paramValue);

        JCTree.JCStatement printFunction = methodExec("java.lang.System.out.printf",paramTypeList,paramValueList);

        jcStatementList.add(printFunction);


        JCTree.JCBlock jcBlock = treeMaker.Block(0, List.from(jcStatementList));

        System.out.println("代码块:" + jcBlock.toString());

        JCTree.JCMethodDecl jcMethodDecl = treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),names.fromString(methedName),treeMaker.TypeIdent(TypeTag.VOID), List.nil(),List.of(jcParamVariableDecl),List.nil(),jcBlock,null);
        jcClassDecl.defs = jcClassDecl.defs.append(jcMethodDecl);
        return jcClassDecl;
    }

    //变量定义
    JCTree.JCExpression varDef(JCTree.JCVariableDecl jcVariableDecl){
        JCTree.JCIdent paramValue = treeMaker.Ident(jcVariableDecl.getName());
        return paramValue;
    }

    //变量定义
    JCTree.JCExpression varDef(String value){
        JCTree.JCLiteral jcLiteral = treeMaker.Literal("%s");
        return jcLiteral;
    }

    //方法执行
    JCTree.JCStatement methodExec(String methodName,ArrayList<JCTree.JCExpression> paramTypeList,ArrayList<JCTree.JCExpression> paramValueList){
        JCTree.JCExpression jcMethodIdent = memberAccess(methodName);

        JCTree.JCMethodInvocation jcMethodInvocation = treeMaker.Apply(List.from(paramTypeList),jcMethodIdent,List.from(paramValueList));
        JCTree.JCExpressionStatement jcExpressionStatement = treeMaker.Exec(jcMethodInvocation);

        return jcExpressionStatement;
    }

    //添加成员访问
    JCTree.JCExpression memberAccess(String components) {
        String[] componentArray = components.split("\\.");
        JCTree.JCExpression expr = treeMaker.Ident(names.fromString(componentArray[0]));
        for (int i = 1; i < componentArray.length; i++) {
            expr = treeMaker.Select(expr, names.fromString(componentArray[i]));
        }
        return expr;
    }

    //添加赋值变量
    JCTree.JCStatement memberAssign(JCTree.JCExpression jcExpression,JCTree.JCVariableDecl jcVariableDecl){
        JCTree.JCAssign jcAssign = treeMaker.Assign(jcExpression,treeMaker.Ident(jcVariableDecl.getName()));
        JCTree.JCStatement jcStatement = treeMaker.Exec(jcAssign);
        return jcStatement;
    }

    //添加赋值常量
    JCTree.JCStatement memberAssign(JCTree.JCExpression jcExpression,String value){
        JCTree.JCAssign jcAssign = treeMaker.Assign(jcExpression,treeMaker.Literal(value));
        JCTree.JCStatement jcStatement = treeMaker.Exec(jcAssign);
        return jcStatement;
    }

    //创建构造函数
    boolean addConstructor(Element element){
        System.out.println("添加所有的属性设置");
        boolean bRet = false;
        ElementKind elementKind = element.getKind();
        if (elementKind != ElementKind.CLASS){
            return bRet;
        }

        AddConstructor addConstructor = element.getAnnotation(AddConstructor.class);

        if (ObjectUtils.isEmpty(addConstructor)){
            return bRet;
        }

        JCTree jcTree = elements.getTree(element);
        jcTree.accept(new TreeTranslator() {
            @Override
            public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
                ArrayList<JCTree.JCVariableDecl> paramList = getParam(jcClassDecl);

                if (ObjectUtils.isEmpty(paramList)){
                    jcClassDecl = createNoArgsConstructor(jcClassDecl);
                }else{
                    jcClassDecl = createAllArgsConstructor(jcClassDecl,paramList);
                }

                this.result = jcClassDecl;
                super.visitClassDef(jcClassDecl);
            }
        });

        return bRet = true;
    }

    //创建有参构造函数
    JCTree.JCClassDecl createAllArgsConstructor(JCTree.JCClassDecl jcClassDecl,ArrayList<JCTree.JCVariableDecl> paramList) {
        System.out.println("创建有参构造函数");

        treeMaker.pos = jcClassDecl.pos;

        ArrayList<JCTree.JCStatement> jcStatementList = new ArrayList<>();
        ArrayList<JCTree.JCVariableDecl> newParamList = new ArrayList<>();
        for(JCTree.JCVariableDecl jcVariableDecl : paramList) {
            JCTree.JCVariableDecl jcParamVariableDecl = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER),jcVariableDecl.name,jcVariableDecl.vartype,null);

            JCTree.JCIdent jcIdent = treeMaker.Ident(names.fromString("this"));
            JCTree.JCExpression jcExpression = treeMaker.Select(jcIdent, jcVariableDecl.getName());

            JCTree.JCAssign jcAssign = treeMaker.Assign(jcExpression,treeMaker.Ident(jcParamVariableDecl.getName()));
            JCTree.JCStatement jcStatement = treeMaker.Exec(jcAssign);

            newParamList.add(jcParamVariableDecl);
            jcStatementList.add(jcStatement);
        }
        JCTree.JCBlock block = treeMaker.Block(0, List.from(jcStatementList));

        JCTree.JCMethodDecl jcMethodDecl = treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),names.fromString("<init>"),
                treeMaker.TypeIdent(TypeTag.VOID), List.nil(),List.from(newParamList), List.nil(),block,null);
        jcClassDecl.defs = jcClassDecl.defs.append(jcMethodDecl);
        return jcClassDecl;
    }

    //创建无参构造函数
    JCTree.JCClassDecl createNoArgsConstructor(JCTree.JCClassDecl jcClassDecl) {
        System.out.println("创建无参构造函数");
        if (hasNoArgsConstructor(jcClassDecl) == true){
            return jcClassDecl;
        }
        treeMaker.pos = jcClassDecl.pos;//注意 偏移必须对准
        JCTree.JCBlock block = treeMaker.Block(0, List.nil());//空代码块
        JCTree.JCMethodDecl jcMethodDecl = treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),//访问标识
                names.fromString("<init>"),//方法名
                treeMaker.TypeIdent(TypeTag.VOID),//返回值类型
                List.nil(),//泛型列表
                List.nil(),//参数列表
                List.nil(),//抛出的异常
                block,//代码块
                null);
        jcClassDecl.defs = jcClassDecl.defs.append(jcMethodDecl);
        return jcClassDecl;
    }

    //判断是否已经有默认的空参构造器
    private boolean hasNoArgsConstructor(JCTree.JCClassDecl jcClassDecl) {
        for (JCTree jcTree:jcClassDecl.defs){
            if(jcTree.getKind().equals(Tree.Kind.METHOD)){
                JCTree.JCMethodDecl methodDecl= (JCTree.JCMethodDecl) jcTree;
                if(methodDecl.getName().toString().equals("<init>")&&methodDecl.getParameters().isEmpty()){
                    return true;
                }
            }
        }
        return false;
    }

    //获取所有非静态Final变量
    private ArrayList<JCTree.JCVariableDecl> getParam(JCTree.JCClassDecl jcClassDecl) {
        ArrayList<JCTree.JCVariableDecl> paramList = new ArrayList<>();
        for (JCTree tree:jcClassDecl.defs){
            if(tree.getKind().equals(Tree.Kind.VARIABLE)){
                JCTree.JCVariableDecl variableDecl= (JCTree.JCVariableDecl) tree;
                Set<Modifier> flags = variableDecl.mods.getFlags();
                if(!flags.contains(Modifier.FINAL)&&!flags.contains(Modifier.STATIC)){
                    paramList.add(variableDecl);
                }
            }
        }
        return paramList;
    }
}

2.3 注解拦截模块资源文件

在resource目录下添加META/services/javax.annotation.processing.Processor文件
文件内容为AddPropertieProcess的引用包名

2.4 注解拦截模块POM文件

<?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">
    <parent>
        <artifactId>TestDemo</artifactId>
        <groupId>com.wangxb</groupId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <artifactId>TestProcess</artifactId>
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.squareup</groupId>
            <artifactId>javapoet</artifactId>
            <version>1.13.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun</groupId>
            <artifactId>tools</artifactId>
            <version>1.8.0</version>
            <scope>system</scope>
            <systemPath>${env.JAVA_HOME}/lib/tools.jar</systemPath>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <excludes>
                    <exclude>META-INF/**/*</exclude>
                </excludes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>none</mainClass>     <!-- 取消查找本项目下的Main方法：为了解决Unable to find main class的问题 -->
                    <classifier>execute</classifier>    <!-- 为了解决依赖模块找不到此模块中的类或属性 -->
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!--
                        指定Java compiler编译时，使用的source与target版本。
                        注: 不同的source、target版本,编译后产生的Class版本号可能不同
                     -->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
                <executions>
                    <execution>
                        <id>process-META</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>copy-resources</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>target/classes</outputDirectory>
                            <resources>
                                <resource>
                                    <directory>${basedir}/src/main/resources/</directory>
                                    <includes>
                                        <include>**/*</include>
                                    </includes>
                                </resource>
                            </resources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

 2. 测试DEMO

创建测试DEMO,引入生成的注解拦截jar包

@Service
@AddConstructor
@AddField(fieldName = "d")
public class AService {
    public String k;
    public long l;
}

编译后将自动生成abc的属性

3.调试程序

在测试模块目录执行 mvnDebug clean install，调试端口号为8000


 在注解拦截模块选择

 选择对应的端口，调试即可

wang5525369
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
IDEA中编写并运行shell脚本的实现
08-18
IDEA中编写并运行shell脚本的实现需要安装bashsupport插件，配置插件，安装git软件，配置IDEA环境，创建Bash Script文件，设置脚本文件的换行符和文件编码，运行脚本等步骤。同时，也需要注意控制台的编码设置和脚本...
idea与vscodeAI插件CODEGEEX插件安装包
最新发布
05-12
总的来说，CODEGEEX插件是面向IDEA和VSCode的智能开发工具，通过AI技术帮助开发者更高效地编写和管理代码。无论是个人开发者还是团队，都可以考虑使用这类插件来提升开发流程的智能化水平。安装和使用这些插件是现代...
AbstractProcessor应用--自动生成 openfeign 的Fallback
qq_35530330的博客
11-27 1282
先看一下目录接口：首先我们我们要引入tools.jar，此包在我们安装 java 目录的，如下：
编译时注解：AbstractProcessor javapoe自动生成代码
行走在路上
03-31 2840
RetentionPolicy.SOURCE：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃； 源码注解(RetentionPolicy.SOURCE)的生命周期只存在Java源文件这一阶段，是3种生命周期中最短的注解。
Java-详解javac AbstractProcessor
yueerba126的博客
07-06 958
AbstractProcessor 就是注解处理器 ，在java文件编译成class文件之前，对java文件进行操作，生成代码。（可以参考lombok）这些对象必须在init方法里初始化@SupportedAnnotationTypes(“cc.HelloWorld”) ，“cc.HelloWorld” 是HelloWorld注解的类全名。@SupportedSourceVersion(SourceVersion.RELEASE_7) ，annotation支持版本,向前兼容到JDK7。
Java注解编译期处理AbstractProcessor详解
热门推荐
LoveSummer
05-30 3万+
我们接触的注解主要分为以下两类运行时注解：通过反射在运行时动态处理注解的逻辑编译时注解：通过注解处理器在编译期动态处理相关逻辑平时我们接触的框架大部分都是运行时注解，比如：@Autowire @Resoure @Bean 等等。那么我们平时有接触过哪些编译期注解呢，@Lombok等等像这些编译时注解的作用都是自动生成代码，一是为了提高编码的效率，二是避免在运行期大量使用反射，通过在编译期利用反射生成辅助类和方法以供运行时使用。那这些编译器注解都是如何运行的呢?又是怎么自动生成代码的呢？
AbstractProcessor注解处理器
有码走遍天下，无码寸步难行
07-03 1万+
1. 注解一般我们定义一个注解的代码如下:@Retention(RetentionPolicy.CLASS) @Target({ElementType.FIELD, ElementType.TYPE}) public @interface Json { String value(); }在注解上面的注解叫做元注解，元注解共有四种: - @Retention: 保留的范围，默认值为CLASS.
Android中使用AbstractProcessor在编译时生成代码
假装你是大灰狼的专栏
12-24 1134
1. 概述 在现阶段的Android开发中，注解越来越流行起来，比如ButterKnife，Retrofit，Dragger，EventBus等等都选择使用注解来配置。按照处理时期，注解又分为两种类型，一种是运行时注解，另一种是编译时注解，运行时注解由于性能问题被一些人所诟病。编译时注解的核心依赖APT(Annotation Processing Tools)实现，原理是在某些代码元素上（如类型、...
idea插件详细源码demo.zip
01-21
"idea插件详细源码demo.zip" 这个标题表明这是一个与IntelliJ IDEA相关的项目，具体来说是一个插件的源码示例。"详细"和"demo"暗示了这个项目提供了全面的指导，适合初学者或者需要深入理解插件开发的开发者。"zip...
Squaretest，idea插件
08-24
Squaretest是一款专为IntelliJ IDEA设计的插件，它为开发者提供了强大的单元测试支持，旨在简化测试工作流程，提高代码质量。此插件有两个版本，分别为squaretest-1.7.2和squaretest-1.8.2，分别对应不同版本的IDEA...
AbstractProcessor小例子
12-25
利用annotationProcessor插件在编译期创建Java文件，减少维护成本，提高工作效率
idea插件MybatisX-1.6.1
02-23
插件内置了一个强大的SQL编辑器，支持自定义别名、智能提示、语法高亮和格式化等功能，使得在IDEA中编写和调试SQL变得更加轻松。同时，可以实时预览查询结果，方便进行数据验证和调试。 3. 动态SQL生成： 对于...
idea插件开发-自定义语言
05-29
在IntelliJ IDEA中开发插件是一项非常实用的技能，可以极大地提高开发效率。本教程将专注于自定义语言的插件开发，特别是如何利用properties文件和customLanguage API来实现这一目标。以下是一些核心知识点： 1. **...
idea 插件visulgc 监控jvm
09-13
idea 插件visulgc 监控jvm
arthas在idea中的插件
08-24
在IntelliJ IDEA这个流行的Java集成开发环境中，Arthas可以通过插件的形式集成，极大地提升了开发者的问题排查效率。本文将详细介绍如何在IntelliJ IDEA中安装和使用Arthas插件。 首先，安装Arthas IDEA插件。打开...
java使用AbstractProcessor、编译时注解和JCTree实现编译时织入代码（类似lombok）并实现Debug自己的Processor和编译后的代码
dap769815768的博客
06-03 1万+
Java架构师交流群：793825326 java版本：jdk1.8 IDE：idea2019 先说怎么用，现在我们想写一个注解HelloWorld，让所有使用了这个注解的类，在编译的时候都打印“Hello World！”，注意，是在编译的时候，不是运行的时候。那么该怎么做呢，这就要用到AbstractProcessor这个东西了。 1.先创建一个maven项目abstractproces...
Java注解（三）：自定义Java编译时注解处理器
lucyLee的博客
01-23 6868
1. 絮絮叨叨 要么是注解跟我有仇，要么是公司配发的笔记本跟我有仇，要么是因为心急吃不了热豆腐 痛定思痛：从头开始，新建一个Java项目，实现一个超级简单的注解@Hello 在 process()方法中简单打印 getSupportedSourceVersion()方法返回的结果 在此，记录一下如何定义一个简单的Java编译时注解处理器 1.1 AbstractProcessor 自定义Java编译时注解处理器，一般都是通过继承AbstractProcessor实现的 AbstractProcesso
Android 自定义注解 AbstractProcessor实现类似ButterKnife
jiushi1995的博客
04-01 862
Android 如何使用AbstractProcessorButterKnife例子原理步骤1. 创建两个JAVA依赖库库**viewlink** 为所有注解的代码**viewlinkid-processor**为处理这些注解的自定义AbstractProcessor的代码1. 为什么是JAVA依赖库而不是Android的依赖库？2. 为什么要分成两个库而不是在一个库？2. 定义注解3. 处理注解 -- 核心4. 使用扩展参考 如今很多的第三方库都使用了注解的方式，像ButterKnife，room等。
利用AbstractProcessor在编译时期自动生成代码
liuhongtaowxp1的博客
04-27 882
首先看一下这个常量类，数据库有多少张表，就要申明多少个常量字段。看到这样的常量类，真的是无力吐槽。那有没有更加简单的方式在编译期间自动产生此常量类，代码中直接使用了。 SO，使用AbstractProcessor可以实现。 在编译的时候，自动产生了BoPurchaseMainTableConstants，项目里直接使用就可以了，自动产生了BoPurchaseMainTableConstants的时候，需要查询数据库，拼接字段。。。，就可以把所有的字段都是产生一个常量字段了，这个类不需..
编写一个idea 的chitpgt插件
05-19
可以考虑开发一个ChitGPT插件，用于帮助用户更方便地与ChitGPT交互。以下是一些可能的功能： 1. 自动触发：插件可以在用户输入文字时自动触发，无需手动点击按钮。 2. 快捷回复：插件可以提供一些常用的回复选项，用户可以通过点击这些选项来快速生成回复。 3. 自定义回复：用户可以通过插件自定义一些回复模板，以便更快地回复常见问题。 4. 历史记录：插件可以记录用户与ChitGPT的聊天历史，方便用户查看以前的对话记录。 5. 智能推荐：插件可以根据用户的输入内容和历史记录，智能推荐一些可能感兴趣的话题或问题，以便用户更深入地了解某个领域或主题。 这些功能可以帮助用户更方便地与ChitGPT进行交互，提高聊天效率和体验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值