java 为 Lombok 创建自定义注释
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/41243018/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Create custom annotation for Lombok
提问by Mesbah Gueffaf
I have used Lombokin my code to automatically generate Getterand Settercode , Now i want to add other personal Annotationsand use it.
我Lombok在我的代码中使用了自动生成Getter和Setter编码，现在我想添加其他个人Annotations并使用它。
for example i want to add @Existwich verify existing Key in list :
例如，我想添加至@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;
}
}
after creating the Annotation i will have just to do something like :
创建注释后，我只需要执行以下操作：
@Getter @Setter
public class User {
private String name;
@Exist
private List<Integer> keys;
}
回答by Fedor Losev
General Considerations
一般注意事项
If you are already using Lombok, you can add custom Lombok transformation annotation and handler.
如果您已经在使用 Lombok，则可以添加自定义 Lombok 转换注释和处理程序。
- Define Exists annotation with
@Target(FIELD)and@Retention(SOURCE) Create a handler
@ProviderFor(JavacAnnotationHandler.class) public class HandleExists extends JavacAnnotationHandler<Exists>{ ...`to process your annotation. Handler class package must start with the
lombok.prefix. If you need to support Eclipse, etc. in addition to javac, you'll need to write more handlers extending appropriate framework classes.In the handler override/implement the
handle()method to generate the required code through AST manipulation.
- 使用
@Target(FIELD)和定义 Exists 注释@Retention(SOURCE) 创建处理程序
@ProviderFor(JavacAnnotationHandler.class) public class HandleExists extends JavacAnnotationHandler<Exists>{ ...`处理您的注释。处理程序类包必须以
lombok.前缀开头。如果除了 javac 还需要支持 Eclipse 等，则需要编写更多的处理程序来扩展适当的框架类。在处理程序中覆盖/实现
handle()通过 AST 操作生成所需代码的方法。
You can take as a sample the @Getterimplementation:
您可以将@Getter实现作为示例：
Annotation: Getter.java
注释： Getter.java
Handler: HandleGetter.java
处理程序： HandleGetter.java
You can also look into sourcesof other annotations and handlersto see how to generate particular code.
您还可以查看其他注释和处理程序的来源，以了解如何生成特定代码。
You'll need to add dependencies on lombok, JDK tools.jar.
您需要添加对 lombok、JDK tools.jar 的依赖项。
Some resources:
一些资源：
The lombok-pgproject with a source for a bunch of custom lombok annotations, in particular FluentSetter.java, HandleFluentSetter.java/ FluentSetterHandler.java
An overview of a custom transformation
Simple annotation examplewith explanations.
在龙目岛，皮克与一帮自龙目注释的源项目，特别是FluentSetter.java，HandleFluentSetter.java/ FluentSetterHandler.java
自定义转换概述
带有解释的简单注释示例。
Note, there are some points to consider here
请注意，这里有一些要点需要考虑
- This is a bunch of non-trivial code to write and maintain. If you plan to use annotation 5-6 times it is just not worth it.
- You may need to change your annotation processor implementation with lombok upgrades.
- The hole in compiler that lombok relies on also may be closed (then the whole Lombok project will change dramatically or cease to exist; in this case you'll have a more serious problem anyway if you use Lombok extensively, even if just for @Getter).
- 这是一堆需要编写和维护的重要代码。如果您打算使用注释 5-6 次，那是不值得的。
- 您可能需要使用 lombok 升级更改注释处理器实现。
- lombok 依赖的编译器中的漏洞也可能会被关闭（然后整个 Lombok 项目将发生巨大变化或不复存在；在这种情况下，如果您广泛使用 Lombok，即使只是为了@Getter，您仍然会遇到更严重的问题）。
A more complex alternative without Lombok is to use standard annotation processingfor code generationbut, AFAIK, you can't change original classes and must generate/use classes that extend them (unless you'll exploit the same back-dooras Lombok or resort to a code manipulation like CGLib or ASM).
没有 Lombok 的更复杂的替代方法是使用标准注释处理进行代码生成，但是，AFAIK，您不能更改原始类，并且必须生成/使用扩展它们的类（除非您将利用与Lombok 或度假村相同的后门到像 CGLib 或 ASM 这样的代码操作）。
Lombok Example
龙目岛示例
Below is some working code to create custom Lombok annotation that I've called @Contains.
下面是一些用于创建自定义 Lombok 注释的工作代码，我称之为@Contains。
It is javac implementation only, no Eclipse, etc. I guess it will be not hard to create a similar handler for Eclipse or other IDE.
它只是 javac 实现，没有 Eclipse 等。我想为 Eclipse 或其他 IDE 创建一个类似的处理程序并不难。
It will generate fieldNameContains() member method which is delegated to the fieldName.contains().
它将生成fieldNameContains() 成员方法，该方法委托给fieldName.contains()。
Note, the code is just quick and dirty (but working) sample. For production grade annotation, you will need to handle many boundary conditions, check correct types, handle Lombok configuration and so on, as it can be observed in lombok or lombok-pg library sources.
请注意，代码只是快速而肮脏（但有效）的示例。对于生产级注释，您将需要处理许多边界条件、检查正确的类型、处理 Lombok 配置等，因为它可以在 lombok 或 lombok-pg 库源中观察到。
Sample usage
示例用法
SomeEnity.java
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
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) {
}
}
}
Annotation Implementaiton
注解实现
Contains.java
包含.java
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.SOURCE)
public @interface Contains {
Class<?>[] types() default {};
Class<?>[] excludes() default {};
}
HandleContains.java
句柄包含.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;
}
}
