登录
当前位置： 首页 > 面试题库 >

为龙目岛创建自定义注释

齐承运
2023-03-14
问题内容：

我用Lombok我的代码自动生成Getter和Setter代码。我想添加其他个人Annotations并使用它。

例如，我想添加一个@Exist方法来验证列表中键的存在：

@Getter    @Setter
public class User {

    private String name;
    private List<Integer> keys;

    public boolean existKeys(Integer key) {
        boolean exist = keys.contains(key);
        return exist;
    }
}

创建注释后，我将只需要执行以下操作：

@Getter    @Setter
public class User {

    private String name;
    @Exist
    private List<Integer> keys;
}

问题答案：

一般注意事项

如果您已经在使用Lombok，则可以添加自定义Lombok转换批注和处理程序。

  1. 使用@Target(FIELD)和定义存在注释@Retention(SOURCE)

  2. 创建一个处理程序

    @ProviderFor(JavacAnnotationHandler.class)

    public class HandleExists extends JavacAnnotationHandler { …`

处理您的注释。处理程序类包必须以lombok.前缀开头。如果除了javac之外还需要支持Eclipse等，则需要编写更多的处理程序来扩展适当的框架类。

  1. 在处理程序中，重写/实现是handle()通过AST操纵生成所需代码的方法。

您可以将@Getter实现作为示例：

注释：
Getter.java

处理程序：
HandleGetter.java

您还可以查看其他注释和处理程序的源，以了解如何生成特定代码。

您需要添加对Lombok（JDK tools.jar）的依赖。

一些资源：

  • 在龙目岛，皮克与一帮自龙目注释的源项目，特别是FluentSetter.java，HandleFluentSetter.java / FluentSetterHandler.java

  • 自定义转换概述

  • 具有说明的简单注释示例。

注意，这里有几点要考虑

  • 这是一堆要编写和维护的重要代码。如果您打算使用注释5至6次，那是不值得的。
  • 您可能需要通过lombok升级来更改注释处理器的实现。
  • lombok所依赖的编译器中的漏洞也可能被关闭（然后整个Lombok项目将发生巨大变化或不复存在；在这种情况下，如果您广泛使用Lombok，即使是@Getter，也将遇到更严重的问题）。

没有Lombok的更复杂的替代方案是使用标准注释处理进行代码生成，但是AFAIK，您不能更改原始类，而必须生成/使用扩展它们的类（除非您将使用与 Lombok
相同的后门或手段到CGLib或ASM之类的代码操作）。

龙目岛的例子

以下是一些用于创建自定义Lombok批注的工作代码，我将其称为 @Contains 。

它只是Javac实现，没有Eclipse等。我想为Eclipse或其他IDE创建类似的处理程序并不难。

它将生成 fieldName Contains（）成员方法，该成员方法委派给 fieldName .contains（）。

请注意，该代码只是快速而肮脏（但可以正常工作）的示例。对于生产级注释，您将需要处理许多边界条件，检查正确的类型，处理Lombok配置等，因为可以在lombok或lombok-
pg库源代码中看到它。

样本用法

SomeEnity.java

@Getter
@Setter
public class SomeEntity {

    @NonNull
    @Contains
    private Collection<String> fieldOne = new ArrayList<>();

    @NonNull
    @Contains
    private Collection<String> fieldTwo = new ArrayList<>();

}

SomeEntityTest.java

public class SomeEntityTest {

    @Test
    public void test() {
        SomeEntity entity = new SomeEntity();

        Collection<String> test1 = Arrays.asList(new String[] { "1", "2" });
        entity.setFieldOne(test1);
        assertSame(test1, entity.getFieldOne());

        Collection<String> test2 = new HashSet<String>(Arrays.asList(new String[] { "3", "4" }));
        entity.setFieldTwo(test2);
        assertSame(test2, entity.getFieldTwo());

        assertTrue(entity.fieldOneContains("1"));
        assertTrue(entity.fieldOneContains("2"));
        assertFalse(entity.fieldOneContains("3"));
        assertFalse(entity.fieldOneContains("4"));

        assertFalse(entity.fieldTwoContains("1"));
        assertFalse(entity.fieldTwoContains("2"));
        assertTrue(entity.fieldTwoContains("3"));
        assertTrue(entity.fieldTwoContains("4"));

        try {
            entity.setFieldOne(null);
            fail("exception expected");
        } catch (Exception ex) {
        }

        try {
            entity.setFieldTwo(null);
            fail("exception expected");
        } catch (Exception ex) {
        }

    }
}

注释实现

包含.java

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.SOURCE)
public @interface Contains {
    Class<?>[] types() default {};
    Class<?>[] excludes() default {};
}

HandleContains.java

@ProviderFor(JavacAnnotationHandler.class) 
@HandlerPriority(65536) 
@ResolutionResetNeeded 
public class HandleContains extends JavacAnnotationHandler<Contains> {

    @Override 
    public void handle(AnnotationValues<Contains> annotation, JCAnnotation ast, JavacNode annotationNode) {

        try {
            JavacNode node = annotationNode.up();
            if (node.getKind() != Kind.FIELD) {
                annotationNode.addError("@Contains is allowed only on fields");
                return;
            }
            Name delegateName = annotationNode.toName(node.getName());
            JavacResolution reso = new JavacResolution(annotationNode.getContext());
            JCTree member = node.get();
            if (member.type == null) {
                reso.resolveClassMember(node);
            }
            Type delegateType = member.type;
            if (delegateType instanceof ClassType) {
                ClassType ct = (ClassType) delegateType;
                //TODO validate that this field is a collection type
                // if(!Collection)
                //   annotationNode.addError("@Contains can only be used on collections");
                final String methodName = "contains";
                MethodSig methodSig = getMethodBinding(methodName, ct, annotationNode.getTypesUtil());
                if (methodSig == null) throw new Exception("no method " + methodName + " in " + ct.tsym.name);
                JCMethodDecl methodDecl = createDelegateMethod(methodSig, annotationNode, delegateName);
                injectMethod(node.up(), methodDecl);
            } else {
                annotationNode.addError("@Contains can only use concrete class types");
                return;
            }
        } catch (Exception ex) {
            //ex.printStackTrace();
            annotationNode.addError("@Contains unexpected error: " + ex.getMessage());
        }

    }

    public JCMethodDecl createDelegateMethod(MethodSig sig, JavacNode annotation, Name delegateName) throws TypeNotConvertibleException {

        JavacTreeMaker maker = annotation.getTreeMaker();

        com.sun.tools.javac.util.List<JCAnnotation> annotations;
        if (sig.isDeprecated) {
            annotations = com.sun.tools.javac.util.List.of(maker.Annotation(genJavaLangTypeRef(annotation, "Deprecated"), com.sun.tools.javac.util.List.<JCExpression>nil()));
        } else {
            annotations = com.sun.tools.javac.util.List.nil();
        }

        JCModifiers mods = maker.Modifiers(PUBLIC, annotations);
        JCExpression returnType = JavacResolution.typeToJCTree((Type) sig.type.getReturnType(), annotation.getAst(), true);
        boolean useReturn = sig.type.getReturnType().getKind() != TypeKind.VOID;
        ListBuffer<JCVariableDecl> params = sig.type.getParameterTypes().isEmpty() ? null : new ListBuffer<JCVariableDecl>();
        ListBuffer<JCExpression> args = sig.type.getParameterTypes().isEmpty() ? null : new ListBuffer<JCExpression>();
        ListBuffer<JCExpression> thrown = sig.type.getThrownTypes().isEmpty() ? null : new ListBuffer<JCExpression>();
        ListBuffer<JCTypeParameter> typeParams = sig.type.getTypeVariables().isEmpty() ? null : new ListBuffer<JCTypeParameter>();
        ListBuffer<JCExpression> typeArgs = sig.type.getTypeVariables().isEmpty() ? null : new ListBuffer<JCExpression>();
        Types types = Types.instance(annotation.getContext());

        for (TypeMirror param : sig.type.getTypeVariables()) {
            Name name = ((TypeVar) param).tsym.name;

            ListBuffer<JCExpression> bounds = new ListBuffer<JCExpression>();
            for (Type type : types.getBounds((TypeVar) param)) {
                bounds.append(JavacResolution.typeToJCTree(type, annotation.getAst(), true));
            }

            typeParams.append(maker.TypeParameter(name, bounds.toList()));
            typeArgs.append(maker.Ident(name));
        }

        for (TypeMirror ex : sig.type.getThrownTypes()) {
            thrown.append(JavacResolution.typeToJCTree((Type) ex, annotation.getAst(), true));
        }

        int idx = 0;
        String[] paramNames = sig.getParameterNames();
        boolean varargs = sig.elem.isVarArgs();
        for (TypeMirror param : sig.type.getParameterTypes()) {
            long flags = JavacHandlerUtil.addFinalIfNeeded(Flags.PARAMETER, annotation.getContext());
            JCModifiers paramMods = maker.Modifiers(flags);
            Name name = annotation.toName(paramNames[idx++]);
            if (varargs && idx == paramNames.length) {
                paramMods.flags |= VARARGS;
            }
            params.append(maker.VarDef(paramMods, name, JavacResolution.typeToJCTree((Type) param, annotation.getAst(), true), null));
            args.append(maker.Ident(name));
        }

        JCExpression accessor = maker.Select(maker.Ident(annotation.toName("this")), delegateName);

        JCExpression delegateCall = maker.Apply(toList(typeArgs), maker.Select(accessor, sig.name), toList(args));
        JCStatement body = useReturn ? maker.Return(delegateCall) : maker.Exec(delegateCall);
        JCBlock bodyBlock = maker.Block(0, com.sun.tools.javac.util.List.of(body));
        StringBuilder generatedMethodName = new StringBuilder(delegateName);
        generatedMethodName.append(sig.name.toString());
        generatedMethodName.setCharAt(delegateName.length(), Character.toUpperCase(generatedMethodName.charAt(delegateName.length())));
        return recursiveSetGeneratedBy(maker.MethodDef(mods, annotation.toName(generatedMethodName.toString()), returnType, toList(typeParams), toList(params), toList(thrown), bodyBlock, null), annotation.get(), annotation.getContext());
    }

    public static <T> com.sun.tools.javac.util.List<T> toList(ListBuffer<T> collection) {
        return collection == null ? com.sun.tools.javac.util.List.<T>nil() : collection.toList();
    }

    public static class MethodSig {
        final Name name;
        final ExecutableType type;
        final boolean isDeprecated;
        final ExecutableElement elem;

        MethodSig(Name name, ExecutableType type, boolean isDeprecated, ExecutableElement elem) {
            this.name = name;
            this.type = type;
            this.isDeprecated = isDeprecated;
            this.elem = elem;
        }

        String[] getParameterNames() {
            List<? extends VariableElement> paramList = elem.getParameters();
            String[] paramNames = new String[paramList.size()];
            for (int i = 0; i < paramNames.length; i++) {
                paramNames[i] = paramList.get(i).getSimpleName().toString();
            }
            return paramNames;
        }

        @Override public String toString() {
            return (isDeprecated ? "@Deprecated " : "") + name + " " + type;
        }
    }

    public MethodSig getMethodBinding(String name, ClassType ct, JavacTypes types) {
        MethodSig result = null;
        TypeSymbol tsym = ct.asElement();
        if (tsym == null) throw new IllegalArgumentException("no class");

        for (Symbol member : tsym.getEnclosedElements()) {
            if (member.getKind() != ElementKind.METHOD || !name.equals(member.name.toString())) {
                continue;
            }
            if (member.isStatic()) continue;
            if (member.isConstructor()) continue;
            ExecutableElement exElem = (ExecutableElement) member;
            if (!exElem.getModifiers().contains(Modifier.PUBLIC)) continue;
            ExecutableType methodType = (ExecutableType) types.asMemberOf(ct, member);
            boolean isDeprecated = (member.flags() & DEPRECATED) != 0;
            result = new MethodSig(member.name, methodType, isDeprecated, exElem);
        }
        if (result == null) {
            if (ct.supertype_field instanceof ClassType) {
                result = getMethodBinding(name, (ClassType) ct.supertype_field, types);
            }
            if (result == null) {
                if (ct.interfaces_field != null) {
                    for (Type iface : ct.interfaces_field) {
                        if (iface instanceof ClassType) {
                            result = getMethodBinding(name, (ClassType) iface, types);
                            if (result != null) {
                                break;
                            }
                        }
                    }
                }
            }
        }
        return result;
    }
}


 类似资料：
  • 龙目岛数据注释“构造函数未定义”

    我在Maven的Spring启动项目中使用Lombok。我的IDE是vscode 我尝试使用Lombok注释器创建这样的类： 它工作正常。但是，当我尝试切换到注释时，我遇到了一个错误： 我以为@Data注释应该为我构建构造函数。这是怎么回事？

  • 为Lombok创建自定义注释

    我在代码中使用Lombok自动生成getter和setter代码。我想添加其他个人注释并使用它。 例如，我想添加一个方法来验证列表中是否存在一个键： 创建注释后，我将执行以下操作：

  • 创建自定义注释

    问题内容： 注释如何与Java一起使用？以及如何创建这样的自定义注释： 基本上，我需要保留的POJO在持久化时像这样进行序列化： 这样，实际的生成/持久对象是这样的： 任何想法如何实现这一点？ 问题答案： 如果创建自定义注释，则必须使用此处的 API 示例进行处理。您可以参考如何声明注释。 这是Java中的示例注释声明的样子。 并被称为。 表示您想在运行时保留注释，并且可以在运行时访问它。 表示您

  • 龙目岛Gradle

    我在gradle项目中使用lombok，希望创建一个jar文件，但每次我执行jar任务（无论是在控制台还是eclipse ide中触发）时，我都会发现错误，我的lombok导入在我使用lombok注释的类中找不到。输出示例： 搜索了一段时间后，我发现有一个适用于gradle和lombok的插件，但在使用较新的gradle版本编译时并不真正需要。我的gradle版本是3.4.1和lombok 1.6

  • Log4j2 漏洞和龙目岛注释@log4j2

    我们使用spring boot 2.1.5和starter parent作为pom依赖项。 Spring启动使用默认的日志回馈进行日志记录，我们尚未显式切换到Log4j2或更改任何配置。下面是我们的项目依赖关系树。 我们的项目中有很多lombok@log4j2注释。但是，我们在依赖关系树中发现我们没有任何log4j2-core jar依赖项（发现它容易受到最近log4j问题的影响）。 lombok

  • 龙目岛定制Setter和Getter

    Lombok@Data annotation将在带注释的类上无声地添加字段的setter和getter。 如何在龙目岛添加基于条件的setter？ lombok中有没有这样的支持 我已经在龙目岛文件中搜索了，我没有看到关于我的问题的解释。

相关阅读

龙目岛注解@Getter的布尔字段创建一个自定义的Jackson注释Maven Groovy和Java +龙目岛Django创建自定义UserCreationForm如何从龙目岛建筑商中排除财产？

相关文章

Vue3 创建项目创建Maven项目GitLab创建项目C++类的定义和对象的创建创建Spring Boot项目

相关问答

龙目岛和STS问题-方法未定义龙目岛超级建筑继承Gradle不能用龙目岛建造可选在龙目岛龙目岛和马文

相关工具

自定义UITabBar自定义NavigationBar自定义AlertView自定义的TabBar自定义开关UISwitch

相关文档

Pandas Cookbook 带注释源码CSS 创作指南Makeblock 创客平台Laravel 项目开发规范Guava 学习记录项目
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.