Question

是否可以在运行时向对象添加注释（在我的情况下，特别是方法中）？

更多解释：我有两个模块，moduleA和moduleB。 moduleB依赖于moduleA，它不依赖于任何东西。（modA是我的核心数据类型和接口等，modB是db / data层）modB也取决于externalLibrary。在我的例子中，modB将一个类从modA移交给externalLibrary，这需要某些方法进行注释。具体的注释都是externalLib的一部分，正如我所说，modA不依赖于externalLib，我想保持这种方式。

那么，这可能吗，或者您是否有其他方法可以看到这个问题？

Answer 1

可以通过字节码检测库，例如Javassist。

特别是，请查看AnnotationsAttribute类以获取有关如何创建/设置注释的示例，并查看有关如何操作类文件的一般准则的tutorial section on bytecode API。

这不过是简单明了的事情 - 我不推荐这种方法，建议你考虑汤姆的答案，除非你需要为大量的类做这个（或者直到运行时才能使用所说的类）因此编写适配器是不可能的。）

Answer 2

在运行时无法添加注释，听起来你需要引入一个adapter模块B用来从模块A中包装对象，从而暴露出所需的注释方法。

Answer 3

还可以使用Java反射API在运行时向Java类添加Annotation。基本上必须重新创建类java.lang.Class中定义的内部注释映射（或者内部类java.lang.Class.AnnotationData中定义的Java 8）。当然，这种方法非常糟糕，并且可能随时针对较新的Java版本而中断。但是对于快速和脏的测试/原型设计，这种方法有时很有用。

Java 8的概念示例：

public final class RuntimeAnnotations {

    private static final Constructor<?> AnnotationInvocationHandler_constructor;
    private static final Constructor<?> AnnotationData_constructor;
    private static final Method Class_annotationData;
    private static final Field Class_classRedefinedCount;
    private static final Field AnnotationData_annotations;
    private static final Field AnnotationData_declaredAnotations;
    private static final Method Atomic_casAnnotationData;
    private static final Class<?> Atomic_class;

    static{
        // static initialization of necessary reflection Objects
        try {
            Class<?> AnnotationInvocationHandler_class = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
            AnnotationInvocationHandler_constructor = AnnotationInvocationHandler_class.getDeclaredConstructor(new Class[]{Class.class, Map.class});
            AnnotationInvocationHandler_constructor.setAccessible(true);

            Atomic_class = Class.forName("java.lang.Class$Atomic");
            Class<?> AnnotationData_class = Class.forName("java.lang.Class$AnnotationData");

            AnnotationData_constructor = AnnotationData_class.getDeclaredConstructor(new Class[]{Map.class, Map.class, int.class});
            AnnotationData_constructor.setAccessible(true);
            Class_annotationData = Class.class.getDeclaredMethod("annotationData");
            Class_annotationData.setAccessible(true);

            Class_classRedefinedCount= Class.class.getDeclaredField("classRedefinedCount");
            Class_classRedefinedCount.setAccessible(true);

            AnnotationData_annotations = AnnotationData_class.getDeclaredField("annotations");
            AnnotationData_annotations.setAccessible(true);
            AnnotationData_declaredAnotations = AnnotationData_class.getDeclaredField("declaredAnnotations");
            AnnotationData_declaredAnotations.setAccessible(true);

            Atomic_casAnnotationData = Atomic_class.getDeclaredMethod("casAnnotationData", Class.class, AnnotationData_class, AnnotationData_class);
            Atomic_casAnnotationData.setAccessible(true);

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | NoSuchFieldException e) {
            throw new IllegalStateException(e);
        }
    }

    public static <T extends Annotation> void putAnnotation(Class<?> c, Class<T> annotationClass, Map<String, Object> valuesMap){
        putAnnotation(c, annotationClass, annotationForMap(annotationClass, valuesMap));
    }

    public static <T extends Annotation> void putAnnotation(Class<?> c, Class<T> annotationClass, T annotation){
        try {
            while (true) { // retry loop
                int classRedefinedCount = Class_classRedefinedCount.getInt(c);
                Object /*AnnotationData*/ annotationData = Class_annotationData.invoke(c);
                // null or stale annotationData -> optimistically create new instance
                Object newAnnotationData = createAnnotationData(c, annotationData, annotationClass, annotation, classRedefinedCount);
                // try to install it
                if ((boolean) Atomic_casAnnotationData.invoke(Atomic_class, c, annotationData, newAnnotationData)) {
                    // successfully installed new AnnotationData
                    break;
                }
            }
        } catch(IllegalArgumentException | IllegalAccessException | InvocationTargetException | InstantiationException e){
            throw new IllegalStateException(e);
        }

    }

    @SuppressWarnings("unchecked")
    private static <T extends Annotation> Object /*AnnotationData*/ createAnnotationData(Class<?> c, Object /*AnnotationData*/ annotationData, Class<T> annotationClass, T annotation, int classRedefinedCount) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Map<Class<? extends Annotation>, Annotation> annotations = (Map<Class<? extends Annotation>, Annotation>) AnnotationData_annotations.get(annotationData);
        Map<Class<? extends Annotation>, Annotation> declaredAnnotations= (Map<Class<? extends Annotation>, Annotation>) AnnotationData_declaredAnotations.get(annotationData);

        Map<Class<? extends Annotation>, Annotation> newDeclaredAnnotations = new LinkedHashMap<>(annotations);
        newDeclaredAnnotations.put(annotationClass, annotation);
        Map<Class<? extends Annotation>, Annotation> newAnnotations ;
        if (declaredAnnotations == annotations) {
            newAnnotations = newDeclaredAnnotations;
        } else{
            newAnnotations = new LinkedHashMap<>(annotations);
            newAnnotations.put(annotationClass, annotation);
        }
        return AnnotationData_constructor.newInstance(newAnnotations, newDeclaredAnnotations, classRedefinedCount);
    }

    @SuppressWarnings("unchecked")
    public static <T extends Annotation> T annotationForMap(final Class<T> annotationClass, final Map<String, Object> valuesMap){
        return (T)AccessController.doPrivileged(new PrivilegedAction<Annotation>(){
            public Annotation run(){
                InvocationHandler handler;
                try {
                    handler = (InvocationHandler) AnnotationInvocationHandler_constructor.newInstance(annotationClass,new HashMap<>(valuesMap));
                } catch (InstantiationException | IllegalAccessException
                        | IllegalArgumentException | InvocationTargetException e) {
                    throw new IllegalStateException(e);
                }
                return (Annotation)Proxy.newProxyInstance(annotationClass.getClassLoader(), new Class[] { annotationClass }, handler);
            }
        });
    }
}

用法示例：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface TestAnnotation {
    String value();
}

public static class TestClass{}

public static void main(String[] args) {
    TestAnnotation annotation = TestClass.class.getAnnotation(TestAnnotation.class);
    System.out.println("TestClass annotation before:" + annotation);

    Map<String, Object> valuesMap = new HashMap<>();
    valuesMap.put("value", "some String");
    RuntimeAnnotations.putAnnotation(TestClass.class, TestAnnotation.class, valuesMap);

    annotation = TestClass.class.getAnnotation(TestAnnotation.class);
    System.out.println("TestClass annotation after:" + annotation);
}

输出：

TestClass annotation before:null
TestClass annotation after:@RuntimeAnnotations$TestAnnotation(value=some String)

这种方法的局限性：

Java的新版本可能随时破坏代码。
以上示例仅适用于Java 8 - 使其适用于较旧的Java版本需要在运行时检查Java版本并相应地更改实现。
如果带注释的类获得redefined（例如在调试期间），则注释将丢失。
未经过彻底测试;不确定是否有任何不良副作用 - 使用风险自负 ......

Answer 4

可以通过Proxy在运行时创建注释。然后，您可以通过其他答案中建议的反射将它们添加到Java对象中（但您可能最好找到另一种方法来处理它，因为通过反射搞乱现有类型可能很危险并且难以调试）。 / p>

但这并不容易......我写了一个名为“Javanna的库，我希望能够使用干净的API轻松完成这项工作。

它位于JCenter和Maven Central。

使用它：

@Retention( RetentionPolicy.RUNTIME )
@interface Simple {
    String value();
}

Simple simple = Javanna.createAnnotation( Simple.class, 
    new HashMap<String, Object>() {{
        put( "value", "the-simple-one" );
    }} );

如果地图的任何条目与注释声明的字段和类型不匹配，则抛出异常。如果缺少任何没有默认值的值，则抛出异常。

这使得可以假设成功创建的每个注释实例都可以安全地用作编译时注释实例。

作为奖励，这个lib还可以解析注释类并将注释的值作为Map返回：

Map<String, Object> values = Javanna.getAnnotationValues( annotation );

这对于创建迷你框架很方便。

在运行时添加Java注释

4 个答案: