web-dev-qa-db-ja.com

Java実行時の注釈の追加

実行時にオブジェクト（特に私の場合はメソッド）に注釈を追加することは可能ですか？

もう少し説明すると、2つのモジュールmoduleAとmoduleBがあります。 moduleBは、何にも依存しないmoduleAに依存します。 （modAは私のコアデータ型とインターフェイスであり、modBはdb/dataレイヤーです）modBもexternalLibraryに依存しています。私の場合、modBはクラスをmodAからexternalLibraryに引き渡します。これには特定のメソッドに注釈を付ける必要があります。特定の注釈はすべてexternalLibの一部であり、先ほど述べたように、modAはexternalLibに依存せず、そのように保ちたいと思います。

それで、これは可能ですか、またはこの問題を見る他の方法のための提案がありますか？

javaannotationsruntime
67
Clayton

実行時に注釈を追加することはできません。モジュールBが必要な注釈付きメソッドを公開するモジュールAからオブジェクトをラップするために使用する adapter を導入する必要があるようです。

21
Tom

Javassist などのバイトコード計測ライブラリを介して可能です。

特に、注釈の作成/設定方法の例については AnnotationsAttribute クラスを、クラスファイルの操作方法に関する一般的なガイドラインについては バイトコードAPIのチュートリアルセクション をご覧ください。

しかし、これは単純で単純なものではありません-膨大な数のクラスでこれを行う必要がない限り、このアプローチをお勧めせず、代わりにトムの答えを検討することをお勧めしますアダプタは不可能です）。

39
ChssPly76

JavaリフレクションAPIを使用して、実行時にJavaクラスに注釈を追加することもできます。基本的に、クラスで定義された内部注釈マップを再作成する必要がありますJava.lang.Class（またはJava 8が内部クラスで定義されている場合Java.lang.Class.AnnotationData）。当然、このアプローチは非常にハッキングされ、新しい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 を取得した場合（デバッグ中など）、注釈は失われます。
  • 完全にはテストされていません。悪い副作用があるかどうかわからない-ご自身の責任で使用してください...
22
Balder

Proxy を使用して、実行時に注釈を作成できます。その後、他の回答で提案されているように、リフレクションを介してそれらをJavaオブジェクトに追加できます（ただし、リフレクションを介して既存の型をいじることができるので、おそらくそれを処理する代替方法を見つけることをお勧めします危険でデバッグが困難です）。

しかし、それは非常に簡単ではありません...私は、適切な Javanna というライブラリを書きました。

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" );
    }} );

マップのいずれかのエントリが、アノテーションで宣言されたフィールドおよびタイプと一致しない場合、例外がスローされます。デフォルト値を持たない値が欠落している場合、例外がスローされます。

これにより、正常に作成されたすべての注釈インスタンスは、コンパイル時の注釈インスタンスと同じくらい安全に使用できると想定できます。

ボーナスとして、このライブラリは注釈クラスを解析し、注釈の値をマップとして返​​すこともできます。

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

これは、ミニフレームワークを作成するのに便利です。

4
Renato