java - 多种类型注解的注解

Question

我希望能够使用两种类型的注释列表来注释一个类，这两种注释在功能上相关，但在参数上完全不同。不过这个列表的顺序很重要。我已经尝试过寻找这个，但无法找到任何对此的引用(我不知道该怎么调用它)。

编辑:

我最终希望能够做什么:

//place holder for example (Abstract)
public @interface A {
}

@Target(PARAMETER)
public @interface B extends A {
    //Gets stuff
    Class type();
    int key();
}

@Target(PARAMETER)
public @interface FlaggedListOfA extends A {
    //List of A
    A[] set();
}

//Goal is to have annotation that does this
@Target(METHOD)
public @interface ImportantFunc {
    A[] dataForA() default {};
    String[] names();
    int property() default 0;
    //etc.
}

//End goal:
public class SomeImportantClass {

    @ImportantFunc(dataForA = {@B(...), @B(...}, ...)
    public void doStuff() {

    }

    //So I can have an end goal of this (Order matters, may contain repeats,
    //and has unknown length!)
    @ImportantFunc(dataForA = {@B(...), @FlaggedListOfA(@B(...), @B(...))}, ...)
    public void doStuffB() {

    }

    @ImportantFunc(dataForA = {@FlaggedListOfA(@B(...)), @FlaggedListOfA(@B(...), @B(...))}, ...)
    public void doStuffC() {

    }

    @ImportantFunc(dataForA = {@FlaggedListOfA(@B(...), @FlaggedListOfA(@B(...), @B(...))), @B(...)}, ...)
    public void doStuffD() {

    }
}

反射以获取包中所有 ImportFunc 的使用(例如:100 次使用)，并使用此数据来选择要使用的函数。该注释有助于反射，因为一旦它从 @ImportantFunc 获取数据，它就会将其转换为库的输入，该库实际选择要执行的函数(这是内部函数，无法修改)。这也可以通过更长、更烦人的方式来实现，但我希望使用注释来简化定义所有这些函数的过程。

编辑:

解决这个问题的另一种方法是找到一种将两个注释分组在一起的方法。

能够做到这一点并不完全理想，但肯定会让这变得更加可行:

public @interface Example {
    AnyTypeOfAnnotation[] set();
}

Answer 1

实现此目的的一种笨拙方法是实际上使 A 成为 B 和 C 的并集。这意味着它具有 B 和 C 的所有字段，但您只能将其用作其中一个 B 或 C。

这是一个有效的示例。

import java.lang.annotation.*;

enum NoType {;}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface A {
    Class<?> data()  default NoType.class; // field from B
    int      dataA() default 0;            // field from C
    String   dataB() default "";           // field from C
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface D {
    A[] value() default {};
}

class Foo {}
class Bar {}

class Example {
    @D({
        @A(data = Bar.class),
        @A(dataA = 5, dataB = "Bla"),
        @A(data = Foo.class)
    })
    public static void main(String[] args) throws Exception {
        for (A a : Example.class.getMethod("main", String[].class)
                        .getAnnotation(D.class).value()) {
            if (a.data() != NoType.class) {
                System.out.printf("B(%s)%n", a.data());
            } else {
                System.out.printf("C(dataA = %d, dataB = \"%s\")%n",
                    a.dataA(), a.dataB());
            }
        }
    }
}

output of that program是:

B(class Bar)
C(dataA = 5, dataB = "Bla")
B(class Foo)

当然，这不是一个非常漂亮的解决方案，但它确实有效。