Java Reflection - Constructor.getAnnotatedParameterTypes() Examples

package com.logicbig.example.constructor;

import java.io.Serializable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.AnnotatedParameterizedType;
import java.lang.reflect.AnnotatedType;
import java.lang.reflect.AnnotatedTypeVariable;
import java.lang.reflect.Constructor;
import java.util.Arrays;
import java.util.List;

public class GetAnnotatedParameterTypesExample {

    public static class Test<T extends @ServerObject Serializable> {
        Test(List<@Immutable T> inputList) {}
    }

    @Target({ElementType.TYPE_USE})
    @Retention(RetentionPolicy.RUNTIME)
    private @interface Immutable {}

    @Target({ElementType.TYPE_USE})
    @Retention(RetentionPolicy.RUNTIME)
    private @interface ServerObject {}


    public static void main(String... args) throws NoSuchMethodException {
        Constructor<Test> c = Test.class.getDeclaredConstructor(List.class);
        AnnotatedType[] a = c.getAnnotatedParameterTypes();
        for (AnnotatedType t : a) {
            printAnnotatedType(t, 1);
        }
    }

    private static void printAnnotatedType(AnnotatedType annotatedType, int level) {
        print(level, "Type = " + annotatedType.getType().getTypeName());
        print(level, "Annotations: " + Arrays.toString(annotatedType.getAnnotations()));
        print(level, "Declared Annotations: " + Arrays.toString(annotatedType.getDeclaredAnnotations()));
        AnnotatedType annotatedOwnerType = annotatedType.getAnnotatedOwnerType();//Java 9
        print(level, "Annotated owner type: " + annotatedOwnerType);
        print(level, "AnnotatedType class: " + annotatedType.getClass().getName());
        print(level, "AnnotatedType class implementing interfaces: " +
                Arrays.toString(annotatedType.getClass().getInterfaces()));
        if (annotatedType instanceof AnnotatedParameterizedType) {
            printAnnotatedParameterizedType((AnnotatedParameterizedType) annotatedType, level);
        }
        if (annotatedType instanceof AnnotatedTypeVariable) {
            printAnnotatedTypeVariable((AnnotatedTypeVariable) annotatedType, level);
        }
    }

    private static void printAnnotatedTypeVariable(AnnotatedTypeVariable annotatedType, int level) {
        AnnotatedType[] aType = annotatedType.getAnnotatedBounds();
        print(level, "AnnotatedTypeVariable#getAnnotatedBounds(): " + Arrays
                .toString(aType));
        for (AnnotatedType type : aType) {
            print(level, "AnnotatedTypeVariable#bound : " + type);
            printAnnotatedType(type, level + 1);
        }
    }

    private static void printAnnotatedParameterizedType(AnnotatedParameterizedType annotatedType,
                                                        int level) {
        AnnotatedType[] aTypes = annotatedType.getAnnotatedActualTypeArguments();
        print(level, "AnnotatedParameterizedType#getAnnotatedActualTypeArguments() : " +
                Arrays.toString(aTypes));
        for (AnnotatedType aType : aTypes) {
            print(level, "AnnotatedParameterizedType#annotatedActualTypeArgument: " + aType);
            printAnnotatedType(aType, level + 1);
        }
    }

    private static void print(int level, String string) {
        System.out.printf("%" + (level * 4 - 3) + "s\u00A6- %s%n", "", string);
    }

} 

package com.logicbig.example.constructor;

import java.io.Serializable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.AnnotatedParameterizedType;
import java.lang.reflect.AnnotatedType;
import java.lang.reflect.AnnotatedWildcardType;
import java.lang.reflect.Constructor;
import java.util.Arrays;
import java.util.Map;

public class GetAnnotatedParameterTypesExample2 {
    public static class Test<T extends @ServerObject Serializable> {
        Test(@Immutable Map<? super @Immutable Key, ? extends @ServerObject RequestInfo> map) {}
    }

    private static class RequestInfo {}

    private static class Key {}

    @Target({ElementType.TYPE_USE})
    @Retention(RetentionPolicy.RUNTIME)
    private @interface Immutable {}

    @Target({ElementType.TYPE_USE})
    @Retention(RetentionPolicy.RUNTIME)
    private @interface ServerObject {}

    public static void main(String... args) throws NoSuchMethodException {
        Constructor<Test> c = Test.class.getDeclaredConstructor(Map.class);
        AnnotatedType[] a = c.getAnnotatedParameterTypes();
        for (AnnotatedType annotatedType : a) {
            printAnnotatedType(annotatedType, 1);
        }
    }

    private static void printAnnotatedType(AnnotatedType annotatedType, int level) {
        print(level, "Type = " + annotatedType.getType().getTypeName());
        print(level, "Annotations: " + Arrays.toString(annotatedType.getAnnotations()));
        print(level, "Declared Annotations: " + Arrays.toString(annotatedType.getDeclaredAnnotations()));
        AnnotatedType annotatedOwnerType = annotatedType.getAnnotatedOwnerType();//Java 9
        print(level, "Annotated owner type: " + annotatedOwnerType);
        print(level, "AnnotatedType class: " + annotatedType.getClass().getName());
        print(level, "AnnotatedType class implementing interfaces: " +
                Arrays.toString(annotatedType.getClass().getInterfaces()));
        if (annotatedType instanceof AnnotatedParameterizedType) {
            printAnnotatedParameterizedType((AnnotatedParameterizedType) annotatedType, level);
        }

        if (annotatedType instanceof AnnotatedWildcardType) {
            printAnnotatedWildcardType((AnnotatedWildcardType) annotatedType, level);
        }
    }

    private static void printAnnotatedParameterizedType(AnnotatedParameterizedType annotatedType,
                                                        int level) {
        AnnotatedType[] aTypes = annotatedType.getAnnotatedActualTypeArguments();
        print(level, "AnnotatedParameterizedType#getAnnotatedActualTypeArguments() : " +
                Arrays.toString(aTypes));
        for (AnnotatedType aType : aTypes) {
            print(level, "AnnotatedParameterizedType#annotatedActualTypeArgument: " + aType);
            printAnnotatedType(aType, level + 1);
        }
    }

    private static void printAnnotatedWildcardType(AnnotatedWildcardType annotatedWildcardType,
                                                   int level) {
        AnnotatedType[] lBounds = annotatedWildcardType.getAnnotatedLowerBounds();
        print(level, "AnnotatedWildcardType#getAnnotatedLowerBounds(): " + Arrays.toString(lBounds));
        for (AnnotatedType lBound : lBounds) {
            print(level, "AnnotatedWildcardType#getAnnotatedLowerBound: " + lBound);
            printAnnotatedType(lBound, level + 1);
        }

        AnnotatedType[] uBounds = annotatedWildcardType.getAnnotatedUpperBounds();
        print(level, "AnnotatedWildcardType#getAnnotatedUpperBounds(): " + Arrays.toString(uBounds));
        for (AnnotatedType uBound : uBounds) {
            print(level, "AnnotatedWildcardType#getAnnotatedUpperBound: " + uBound);
            printAnnotatedType(uBound, level + 1);
        }
    }

    private static void print(int level, String string) {
        System.out.printf("%" + (level * 4 - 3) + "s\u00A6- %s%n", "", string);
    }
}