Question

我想将常量用于注释值。

interface Client {

    @Retention(RUNTIME)
    @Target(METHOD)
    @interface SomeAnnotation { String[] values(); }

    interface Info {
        String A = "a";
        String B = "b";
        String[] AB = new String[] { A, B };
    }

    @SomeAnnotation(values = { Info.A, Info.B })
    void works();

    @SomeAnnotation(values = Info.AB)
    void doesNotWork();
}

常量Info.A和Info.B可用于注释，但不能用于数组Info.AB，因为它必须是此位置的数组初始值设定项。注释值仅限于可以内联到类的字节代码中的值。这对于数组常量是不可能的，因为必须在加载Info时构造它。这个问题有解决方法吗？

Answer 1

不，没有解决方法。

Answer 2

为什么不将注释值设为枚举值，这是您想要的实际数据值的关键？

e.g。

enum InfoKeys
{
 A("a"),
 B("b"),
 AB(new String[] { "a", "b" }),

 InfoKeys(Object data) { this.data = data; }
 private Object data;
}

@SomeAnnotation (values = InfoKeys.AB)

这可以改进类型安全，但你明白了。

Answer 3

虽然没有办法将数组直接作为注释参数值传递，但是一种有效获取类似行为的方法（取决于您计划如何使用您的注释，这可能不适用于每个用例）。

以下是一个例子 - 让我们说我们有一个班级InternetServer，它有一个hostname属性。我们希望使用常规Java验证来确保没有对象具有＆＃34;保留＆＃34;主机名。我们可以（有点精心）将一组保留的主机名传递给处理主机名验证的注释。

告诫 - 使用Java验证，使用＆＃34;有效载荷＆＃34;会更加习惯。传递这种数据。我希望这个例子更通用，所以我使用了自定义接口类。

// InternetServer.java -- an example class that passes an array as an annotation value
import lombok.Getter;
import lombok.Setter;
import javax.validation.constraints.Pattern;

public class InternetServer {

    // These are reserved names, we don't want anyone naming their InternetServer one of these
    private static final String[] RESERVED_NAMES = {
        "www", "wwws", "http", "https",
    };

    public class ReservedHostnames implements ReservedWords {
        // We return a constant here but could do a DB lookup, some calculation, or whatever
        // and decide what to return at run-time when the annotation is processed.
        // Beware: if this method bombs, you're going to get nasty exceptions that will
        // kill any threads that try to load any code with annotations that reference this.
        @Override public String[] getReservedWords() { return RESERVED_NAMES; }
    }

    @Pattern(regexp = "[A-Za-z0-9]{3,}", message = "error.hostname.invalid")
    @NotReservedWord(reserved=ReservedHostnames.class, message="error.hostname.reserved")
    @Getter @Setter private String hostname;
}

// NotReservedWord.java -- the annotation class
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target({FIELD, ANNOTATION_TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy=ReservedWordValidator.class)
@Documented
public @interface NotReservedWord {

    Class<? extends ReservedWords> reserved ();

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    String message() default "{err.reservedWord}";

}

// ReservedWords.java -- the interface referenced in the annotation class
public interface ReservedWords {
    public String[] getReservedWords ();
}

// ReservedWordValidator.java -- implements the validation logic
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ReservedWordValidator implements ConstraintValidator<NotReservedWord, Object> {

    private Class<? extends ReservedWords> reserved;

    @Override
    public void initialize(NotReservedWord constraintAnnotation) {
        reserved = constraintAnnotation.reserved();
    }

    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        if (value == null) return true;
        final String[] words = getReservedWords();
        for (String word : words) {
            if (value.equals(word)) return false;
        }
        return true;
    }

    private Map<Class, String[]> cache = new ConcurrentHashMap<>();

    private String[] getReservedWords() {
        String[] words = cache.get(reserved);
        if (words == null) {
            try {
                words = reserved.newInstance().getReservedWords();
            } catch (Exception e) {
                throw new IllegalStateException("Error instantiating ReservedWords class ("+reserved.getName()+"): "+e, e);
            }
            cache.put(reserved, words);
        }
        return words;
    }
}

Answer 4

这是因为可以在运行时（content-type）更改数组的元素，而注释值在编译后是恒定的。

考虑到这一点，当人们尝试更改Info.AB[0] = "c";的元素并期望注释的值发生变化（不会）时，不可避免地会感到困惑。而且，如果允许注释值在运行时更改，则它将不同于编译时使用的注释值。想象一下混乱吧！

（这里的 confusion 表示存在一个错误，某些人可能会发现并花费数小时进行调试。）

Answer 5

正如以前的文章中已经提到的那样，注释值是编译时常量，无法使用数组值作为参数。

我以不同的方式解决了这个问题。

如果您拥有处理逻辑，请利用它。

例如，为注释添加一个附加参数：

@Retention(RUNTIME)
@Target(METHOD)
@interface SomeAnnotation { 
    String[] values();
    boolean defaultInit() default false;
}

使用此参数：

@SomeAnnotation(defaultInit = true)
void willWork();

这将是AnnotationProcessor的标记，它可以执行任何操作-使用数组初始化它，使用String[]或使用Enums像Enum.values()并映射他们String[]。

希望这将指导处于类似方向的人。

Answer 6

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Handler {

    enum MessageType { MESSAGE, OBJECT };

    String value() default "";

    MessageType type() default MessageType.MESSAGE;

}

如何在注释中使用数组常量

6 个答案: