1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
// @Since：1.5
// 如果此元素上存在指定类型的注释，则返回true，否则返回false。 该方法主要用于方便访问标记注释。 
default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
    return getAnnotation(annotationClass) != null;
}
// @Since：1.5
// 如果存在指定类型的注释，则返回该元素的注释，否则为空。
<T extends Annotation> T getAnnotation(Class<T> annotationClass);
// @Since：1.5
// 返回出现在此元素上的注释。
Annotation[] getAnnotations();
// @Since：1.8
// 返回与此元素关联的注释。
// 该方法与 getAnnotation(Class) 的区别在于，该方法检测其参数是否为可重复注释类型(JLS 9.6)，如果是，则试图通过“查看”容器注释来查找该类型的一个或多个注释。
// @implSpec：默认实现首先调用 getDeclaredAnnotationsByType(Class) ，传递 annotationClass 作为参数。如果返回的数组长度大于0，则返回该数组。如果返回的数组是零长度的，并且这个 AnnotatedElement 是一个类，参数类型是一个可继承的注释类型，并且这个 AnnotatedElement 的超类是非空的，那么返回的结果就是在超类上以 annotationClass 为参数调用 getAnnotationsByType(class) 的结果。否则，返回一个零长度的数组。
default <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
    /* 关联的定义:直接或间接呈现或既不直接也不间接呈现且元素是Class，注释类型是可继承的，且注释类型与元素的超类关联。
    */
    T[] result = getDeclaredAnnotationsByType(annotationClass);

    if (result.length == 0 && // Neither directly nor indirectly present
        this instanceof Class && // the element is a class
        AnnotationType.getInstance(annotationClass).isInherited()) { // Inheritable
        Class<?> superClass = ((Class<?>) this).getSuperclass();
        if (superClass != null) {
            // Determine if the annotation is associated with the
            // superclass
            result = superClass.getAnnotationsByType(annotationClass);
        }
    }

    return result;
}
// @Since：1.8
// 如果指定类型的注释直接存在，则返回该元素的注释，否则为空。
default <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
    Objects.requireNonNull(annotationClass);
    // Loop over all directly-present annotations looking for a matching one
    for (Annotation annotation : getDeclaredAnnotations()) {
        if (annotationClass.equals(annotation.annotationType())) {
            // More robust to do a dynamic cast at runtime instead
            // of compile-time only.
            return annotationClass.cast(annotation);
        }
    }
    return null;
}
// @Since：1.8
// 如果指定类型的注释直接或间接地存在，则返回该元素的注释。此方法忽略继承的注释。
default <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
    Objects.requireNonNull(annotationClass);
    return AnnotationSupport.
        getDirectlyAndIndirectlyPresent(Arrays.stream(getDeclaredAnnotations()).
                                        collect(Collectors.toMap(Annotation::annotationType,
                                                                 Function.identity(),
                                                                 ((first,second) -> first),
                                                                 LinkedHashMap::new)),
                                        annotationClass);
}
// @Since：1.5
// 返回直接出现在此元素上的注释。此方法忽略继承的注释。
Annotation[] getDeclaredAnnotations();

1
2
3
// 返回此带注释的类型所表示的基础类型。
public Type getType();

1
2
3
// 返回此数组类型的可能带注释的泛型组件类型。
AnnotatedType  getAnnotatedGenericComponentType();

1
2
3
// 返回此参数化类型的可能带注释的实际类型参数。
AnnotatedType[] getAnnotatedActualTypeArguments();

1
2
3
// 返回此类型变量可能带注释的边界。
AnnotatedType[] getAnnotatedBounds();

1
2
3
4
5
// 返回此通配符类型可能带有注释的下界。
AnnotatedType[] getAnnotatedLowerBounds();
// 返回此通配符类型可能带有注释的上界。
AnnotatedType[] getAnnotatedUpperBounds();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE, ElementType.TYPE_USE})
@Inherited
@interface MyAnno {
    String value() default "";
}

class MyAnnoClass<@MyAnno T extends @MyAnno Number, U> {
    @MyAnno T[] tArr;
    T t;
    List<@MyAnno ? extends Number> list;

}

public static void main(String[] args) {
    Field[] annotatedInterfaces = MyAnnoClass.class.getDeclaredFields();
    System.out.printf("|%20s|%50s|%80s|%20s|%20s|%20s|%30s|%20s|%n",
            "Field Name", "annotatedType Name", "annotatedTypeClass Name", "modifier",
            "AnnotatedArrayType", "AnnotatedTypeVariable", "AnnotatedParameterizedType", "AnnotatedWildcardType");
    for (Field field : annotatedInterfaces) {
        AnnotatedType annotatedType = field.getAnnotatedType();
        // AnnotatedArrayType: 1000, AnnotatedTypeVariable: 0100, AnnotatedParameterizedType: 0010, AnnotatedWildcardType: 0001
        int modifier = 0;
        String arrayTypeInfo = "";
        String typeVariableInfo = "";
        String parameterizedTypeInfo = "";
        String wildcardTypeInfo = "";
        if (annotatedType instanceof AnnotatedArrayType) {
            modifier |= 0b1000;
            arrayTypeInfo = ((AnnotatedArrayType) annotatedType).getAnnotatedGenericComponentType().getType().getTypeName();
        }
        if (annotatedType instanceof AnnotatedTypeVariable) {
            modifier |= 0b0100;
            typeVariableInfo = Arrays.toString(Arrays.stream(((AnnotatedTypeVariable) annotatedType).getAnnotatedBounds()).map(annoType -> annoType.getType().getTypeName()).toArray());
        }
        if (annotatedType instanceof AnnotatedParameterizedType) {
            modifier |= 0b0010;
            parameterizedTypeInfo = Arrays.toString(Arrays.stream(((AnnotatedParameterizedType) annotatedType).getAnnotatedActualTypeArguments()).map(annoType -> annoType.getType().getTypeName()).toArray());
            for (AnnotatedType annotatedActualTypeArgument : ((AnnotatedParameterizedType) annotatedType).getAnnotatedActualTypeArguments()) {
                if (annotatedActualTypeArgument instanceof AnnotatedWildcardType) {
                    modifier |= 0b0001;
                    wildcardTypeInfo = Arrays.toString(Arrays.stream(((AnnotatedWildcardType) annotatedActualTypeArgument).getAnnotatedUpperBounds()).map(annoType -> annoType.getType().getTypeName()).toArray());
                }
            }
        }
        System.out.printf("|%20s|%50s|%80s|%20s|%20s|%20s|%30s|%20s|%n",
                field.getName(), annotatedType.getType().getTypeName(), annotatedType.getClass().getName(),
                String.format("%1$04d", Integer.valueOf(Integer.toBinaryString(modifier))),
                arrayTypeInfo, typeVariableInfo, parameterizedTypeInfo, wildcardTypeInfo);
    }
}

1
2
3
4
5
6
|          Field Name|                                annotatedType Name|                                                         annotatedTypeClass Name|            modifier|  AnnotatedArrayType|AnnotatedTypeVariable|    AnnotatedParameterizedType|AnnotatedWildcardType|
|                tArr|                                               T[]|              sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedArrayTypeImpl|                1000|                   T|                    |                              |                    |
|                   t|                                                 T|           sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedTypeVariableImpl|                0100|                    |  [java.lang.Number]|                              |                    |
|                list|        java.util.List<? extends java.lang.Number>|      sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedParameterizedTypeImpl|                0011|                    |                    |  [? extends java.lang.Number]|  [java.lang.Number]|

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 标识类或接口的所有公共成员的集合，包括继承的成员。
public static final int PUBLIC = 0;
// 标识类或接口声明的成员集。不包括继承的成员。
public static final int DECLARED = 1;
// 返回表示声明由该成员表示的成员或构造函数的类或接口的Class对象。
public Class<?> getDeclaringClass();
// 返回由该成员表示的基础成员或构造函数的简单名称。
public String getName();
// 以整数形式返回此成员表示的成员或构造函数的Java语言修饰符。应该使用Modifier类来解码整数中的修饰符。
public int getModifiers();
// @Since：1.5
// 如果该成员是由编译器引入的，则返回 true ;否则返回 false 。
public boolean isSynthetic();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
// java.Lang和java.lang.reflect包之间的引导协议。
static {
    sun.reflect.ReflectionFactory factory =
        AccessController.doPrivileged(
            new ReflectionFactory.GetReflectionFactoryAction());
    factory.setLangReflectAccess(new java.lang.reflect.ReflectAccess());
}
public static final int PUBLIC           = 0x00000001;
public static final int PRIVATE          = 0x00000002;
public static final int PROTECTED        = 0x00000004;
public static final int STATIC           = 0x00000008;
public static final int FINAL            = 0x00000010;
public static final int SYNCHRONIZED     = 0x00000020;
public static final int VOLATILE         = 0x00000040;
public static final int TRANSIENT        = 0x00000080;
public static final int NATIVE           = 0x00000100;
public static final int INTERFACE        = 0x00000200;
public static final int ABSTRACT         = 0x00000400;
public static final int STRICT           = 0x00000800;
// 没有(还)公开在公共API中的位，要么是因为它们对字段和方法有不同的含义，在这个类中没有办法区分这两者，要么是因为它们不是Java编程语言的关键字
static final int BRIDGE    = 0x00000040;
static final int VARARGS   = 0x00000080;
static final int SYNTHETIC = 0x00001000;
static final int ANNOTATION  = 0x00002000;
static final int ENUM      = 0x00004000;
static final int MANDATED  = 0x00008000;
public static boolean isPublic(int mod) { return (mod & PUBLIC) != 0; }
public static boolean isPrivate(int mod) { return (mod & PRIVATE) != 0; }
public static boolean isProtected(int mod) { return (mod & PROTECTED) != 0; }
public static boolean isStatic(int mod) { return (mod & STATIC) != 0; }
public static boolean isFinal(int mod) { return (mod & FINAL) != 0; }
public static boolean isSynchronized(int mod) { return (mod & SYNCHRONIZED) != 0; }
public static boolean isVolatile(int mod) { return (mod & VOLATILE) != 0; }
public static boolean isTransient(int mod) { return (mod & TRANSIENT) != 0; }
public static boolean isNative(int mod) { return (mod & NATIVE) != 0; }
public static boolean isInterface(int mod) { return (mod & INTERFACE) != 0; }
public static boolean isAbstract(int mod) { return (mod & ABSTRACT) != 0; }
public static boolean isStrict(int mod) { return (mod & STRICT) != 0; }
static boolean isSynthetic(int mod) { return (mod & SYNTHETIC) != 0; }
static boolean isMandated(int mod) { return (mod & MANDATED) != 0; }
// 返回一个字符串，描述指定修饰符中的访问修饰符标志。
public static String toString(int mod) {
    StringBuilder sb = new StringBuilder();
    int len;

    if ((mod & PUBLIC) != 0)        sb.append("public ");
    if ((mod & PROTECTED) != 0)     sb.append("protected ");
    if ((mod & PRIVATE) != 0)       sb.append("private ");

    /* Canonical order */
    if ((mod & ABSTRACT) != 0)      sb.append("abstract ");
    if ((mod & STATIC) != 0)        sb.append("static ");
    if ((mod & FINAL) != 0)         sb.append("final ");
    if ((mod & TRANSIENT) != 0)     sb.append("transient ");
    if ((mod & VOLATILE) != 0)      sb.append("volatile ");
    if ((mod & SYNCHRONIZED) != 0)  sb.append("synchronized ");
    if ((mod & NATIVE) != 0)        sb.append("native ");
    if ((mod & STRICT) != 0)        sb.append("strictfp ");
    if ((mod & INTERFACE) != 0)     sb.append("interface ");

    if ((len = sb.length()) > 0)    /* trim trailing space */
        return sb.toString().substring(0, len-1);
    return "";
}
private static final int CLASS_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
        Modifier.STRICT;
private static final int INTERFACE_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.STRICT;
private static final int CONSTRUCTOR_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE;
private static final int METHOD_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
        Modifier.SYNCHRONIZED   | Modifier.NATIVE       | Modifier.STRICT;
private static final int FIELD_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.STATIC         | Modifier.FINAL        | Modifier.TRANSIENT |
        Modifier.VOLATILE;
private static final int PARAMETER_MODIFIERS =
        Modifier.FINAL;
static final int ACCESS_MODIFIERS =
        Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE;

public static int classModifiers() { return CLASS_MODIFIERS; }
public static int interfaceModifiers() { return INTERFACE_MODIFIERS; }
public static int constructorModifiers() { return CONSTRUCTOR_MODIFIERS; }
public static int methodModifiers() { return METHOD_MODIFIERS; }
public static int fieldModifiers() { return FIELD_MODIFIERS; }
public static int parameterModifiers() { return PARAMETER_MODIFIERS; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
public Field newField(Class<?> declaringClass,
                      String name,
                      Class<?> type,
                      int modifiers,
                      int slot,
                      String signature,
                      byte[] annotations) {
    return new Field(declaringClass,
                     name,
                     type,
                     modifiers,
                     slot,
                     signature,
                     annotations);
}
public Method newMethod(Class<?> declaringClass,
                        String name,
                        Class<?>[] parameterTypes,
                        Class<?> returnType,
                        Class<?>[] checkedExceptions,
                        int modifiers,
                        int slot,
                        String signature,
                        byte[] annotations,
                        byte[] parameterAnnotations,
                        byte[] annotationDefault) {
    return new Method(declaringClass,
                      name,
                      parameterTypes,
                      returnType,
                      checkedExceptions,
                      modifiers,
                      slot,
                      signature,
                      annotations,
                      parameterAnnotations,
                      annotationDefault);
}
public <T> Constructor<T> newConstructor(Class<T> declaringClass,
                                         Class<?>[] parameterTypes,
                                         Class<?>[] checkedExceptions,
                                         int modifiers,
                                         int slot,
                                         String signature,
                                         byte[] annotations,
                                         byte[] parameterAnnotations) {
    return new Constructor<>(declaringClass,
                              parameterTypes,
                              checkedExceptions,
                              modifiers,
                              slot,
                              signature,
                              annotations,
                              parameterAnnotations);
}
public MethodAccessor getMethodAccessor(Method m) {
    return m.getMethodAccessor();
}
public void setMethodAccessor(Method m, MethodAccessor accessor) {
    m.setMethodAccessor(accessor);
}
public ConstructorAccessor getConstructorAccessor(Constructor<?> c) {
    return c.getConstructorAccessor();
}
public void setConstructorAccessor(Constructor<?> c,
                                   ConstructorAccessor accessor) {
    c.setConstructorAccessor(accessor);
}
public int getConstructorSlot(Constructor<?> c) {
    return c.getSlot();
}
public String getConstructorSignature(Constructor<?> c) {
    return c.getSignature();
}
public byte[] getConstructorAnnotations(Constructor<?> c) {
    return c.getRawAnnotations();
}
public byte[] getConstructorParameterAnnotations(Constructor<?> c) {
    return c.getRawParameterAnnotations();
}
public byte[] getExecutableTypeAnnotationBytes(Executable ex) {
    return ex.getTypeAnnotationBytes();
}
// 复制例程，需要从模板快速生成新的Field、Method和Constructor对象
public Method      copyMethod(Method arg) {
    return arg.copy();
}
public Field       copyField(Field arg) {
    return arg.copy();
}
public <T> Constructor<T> copyConstructor(Constructor<T> arg) {
    return arg.copy();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
protected AccessibleObject() {}
// 指示该对象是否覆盖语言级访问检查。初始化“false”。该字段由field、Method和Constructor使用。
boolean override;
static final private java.security.Permission ACCESS_PERMISSION = new ReflectPermission("suppressAccessChecks");
static final ReflectionFactory reflectionFactory = AccessController.doPrivileged( new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
volatile Object securityCheckCache;
// 为一个对象数组设置{@code accessible}标志的方便方法，只需进行一次安全检查(为了效率)。
public static void setAccessible(AccessibleObject[] array, boolean flag)
    throws SecurityException {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
    for (int i = 0; i < array.length; i++) {
        setAccessible0(array[i], flag);
    }
}
// 设置该对象的{@code accessible}标志为指定的布尔值。{@code true}的值表示反射对象在使用时应该禁止Java语言访问检查。{@code false}的值表示反射对象应该强制Java语言访问检查。
public void setAccessible(boolean flag) throws SecurityException {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
    setAccessible0(this, flag);
}
// 检查你没有暴露java.lang.Class.<init>或java.lang.Class中的敏感字段。
private static void setAccessible0(AccessibleObject obj, boolean flag) throws SecurityException {
    if (obj instanceof Constructor && flag == true) {
        Constructor<?> c = (Constructor<?>)obj;
        if (c.getDeclaringClass() == Class.class) {
            throw new SecurityException("Cannot make a java.lang.Class" +
                                        " constructor accessible");
        }
    }
    obj.override = flag;
}
// 获取该对象的{@code accessible}标志的值。
public boolean isAccessible() {
    return override;
}
@Override
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
    throw new AssertionError("All subclasses should override this method");
}
@Override
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
    return AnnotatedElement.super.isAnnotationPresent(annotationClass);
}
@Override
public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
    throw new AssertionError("All subclasses should override this method");
}
@Override
public Annotation[] getAnnotations() {
    return getDeclaredAnnotations();
}
@Override
public <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
    // 只有类上的注释被继承，对于所有其他对象，getDeclaredAnnotation与getAnnotation相同。
    return getAnnotation(annotationClass);
}
@Override
public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
    // 只有类上的注释被继承，对于所有其他对象getDeclaredAnnotationsByType与getAnnotationsByType相同。
    return getAnnotationsByType(annotationClass);
}
@Override
public Annotation[] getDeclaredAnnotations()  {
    throw new AssertionError("All subclasses should override this method");
}
void checkAccess(Class<?> caller, Class<?> clazz, Object obj, int modifiers) throws IllegalAccessException {
    if (caller == clazz) {  // quick check
        return;             // ACCESS IS OK
    }
    Object cache = securityCheckCache;  // read volatile
    Class<?> targetClass = clazz;
    if (obj != null
        && Modifier.isProtected(modifiers)
        && ((targetClass = obj.getClass()) != clazz)) {
        // Must match a 2-list of { caller, targetClass }.
        if (cache instanceof Class[]) {
            Class<?>[] cache2 = (Class<?>[]) cache;
            if (cache2[1] == targetClass &&
                cache2[0] == caller) {
                return;     // ACCESS IS OK
            }
            // (Test cache[1] first since range check for [1]
            // subsumes range check for [0].)
        }
    } else if (cache == caller) {
        // Non-protected case (or obj.class == this.clazz).
        return;             // ACCESS IS OK
    }
    // If no return, fall through to the slow path.
    slowCheckMemberAccess(caller, clazz, obj, modifiers, targetClass);
}
// 把这些慢的东西都放一边:
void slowCheckMemberAccess(Class<?> caller, Class<?> clazz, Object obj, int modifiers, Class<?> targetClass) throws IllegalAccessException {
    Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
    // Success: Update the cache.
    Object cache = ((targetClass == clazz)
                    ? caller
                    : new Class<?>[] { caller, targetClass });

    // Note:  The two cache elements are not volatile,
    // but they are effectively final.  The Java memory model
    // guarantees that the initializing stores for the cache
    // elements will occur before the volatile write.
    securityCheckCache = cache;         // write volatile
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
private Class<?>            clazz;
private int                 slot;
// 这可以保证在1.4反射实现中由VM实现
private String              name;
private Class<?>            type;
private int                 modifiers;
// 泛型和注释支持
private transient String    signature;
// 泛型信息存储库;延迟初始化
private transient FieldRepository genericInfo;
private byte[]              annotations;
// 不重写创建的缓存字段访问器
private FieldAccessor fieldAccessor;
// 用重写创建的缓存字段访问器
private FieldAccessor overrideFieldAccessor;
// 用于字段访问器的共享。这个分支结构目前只有两层深(也就是说，一个根Field和可能有很多Field对象指向它)。
// 如果这个分支结构包含循环，那么在注释代码中就可能发生死锁。
private Field               root;
private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
// 泛型基础设施
private String getGenericSignature() {return signature;}
// 返回{@code Class}对象，该对象表示声明由{@code field}对象表示的字段的类或接口。
public Class<?> getDeclaringClass() {
    return clazz;
}
// 访问器的工厂
private GenericsFactory getFactory() {
    Class<?> c = getDeclaringClass();
    // 创建范围和工厂
    return CoreReflectionFactory.make(c, ClassScope.make(c));
}
// 泛型信息存储库的访问器
private FieldRepository getGenericInfo() {
    // 如果需要，延迟初始化存储库
    if (genericInfo == null) {
        // 创建和缓存泛型信息存储库
        genericInfo = FieldRepository.make(getGenericSignature(),
                                           getFactory());
    }
    return genericInfo; //return cached repository
}

// 用于在Java代码中实例化这些对象的ReflectAccess使用的包私有构造函数java.lang包通过sun.reflect.LangReflectAccess。
Field(Class<?> declaringClass, String name, Class<?> type, int modifiers, int slot, String signature, byte[] annotations) {
    this.clazz = declaringClass;
    this.name = name;
    this.type = type;
    this.modifiers = modifiers;
    this.slot = slot;
    this.signature = signature;
    this.annotations = annotations;
}
// Package-private例程(通过ReflectAccess向java.lang.Class公开)返回此字段的副本。副本的“root”字段指向这个字段。
Field copy() {
        // 这个例程允许在引用VM中相同底层方法的Field对象之间共享FieldAccessor对象。(所有这些扭曲都是必要的，因为AccessibleObject中的“可访问性”部分，它隐式地要求为对Class对象的每次反射调用制造新的java.lang.reflect对象。)
    if (this.root != null)
        throw new IllegalArgumentException("Can not copy a non-root Field");

    Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);
    res.root = this;
    // 如果已经存在，不妨踊跃宣传
    res.fieldAccessor = fieldAccessor;
    res.overrideFieldAccessor = overrideFieldAccessor;

    return res;
}

// 返回由{@code field}对象表示的字段名。
public String getName() {
    return name;
}
// 以整数形式返回由{@code field}对象表示的字段的Java语言修饰符。{@code Modifier}类应该用于解码这些修饰符。
public int getModifiers() {
    return modifiers;
}
// 如果该字段表示枚举类型的元素，则返回{@code true};否则返回{@code false}。
public boolean isEnumConstant() {
    return (getModifiers() & Modifier.ENUM) != 0;
}
// 如果这个字段是一个合成字段，返回{@code true};否则返回{@code false}。
public boolean isSynthetic() {
    return Modifier.isSynthetic(getModifiers());
}

// 返回一个{@code Class}对象，该对象标识由{@code field}对象表示的字段声明的类型。
public Class<?> getType() {
    return type;
}
// 返回一个{@code Type}对象，该对象表示由该{@code field}对象表示的字段声明的类型。
// 如果{@code Type}是参数化类型，返回的{@code Type}对象必须准确地反映源代码中使用的实际类型参数。如果基础字段的类型是类型变量或参数化类型，则创建该字段。否则，将被解析。
public Type getGenericType() {
    if (getGenericSignature() != null)
        return getGenericInfo().getGenericType();
    else
        return getType();
}

// 比较指定对象的{@code Field}。如果两个对象相同，则返回true。两个{@code Field}对象是相同的，如果它们是由同一个类声明的，并且具有相同的名称和类型。
public boolean equals(Object obj) {
    if (obj != null && obj instanceof Field) {
        Field other = (Field)obj;
        return (getDeclaringClass() == other.getDeclaringClass())
            && (getName() == other.getName())
            && (getType() == other.getType());
    }
    return false;
}
// 返回这个{@code字段}的哈希码。这是作为底层字段声明的类名及其名称的哈希代码的异或计算的。
public int hashCode() {
    return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
}

// 返回一个描述这个{@code字段}的字符串。格式是字段的访问修饰符(如果有的话)，然后是字段类型，然后是空格，然后是声明字段的类的全限定名称，然后是句点，最后是字段的名称。
// example: public static final int java.lang.Thread.MIN_PRIORITY
public String toString() {
    int mod = getModifiers();
    return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            + getType().getTypeName() + " "
            + getDeclaringClass().getTypeName() + "."
            + getName());
}
// 返回一个描述这个{@code字段}的字符串，包括它的泛型类型。格式是字段的访问修饰符(如果有的话)，然后是泛型字段类型，然后是空格，然后是声明字段的类的全限定名称，然后是句点，最后是字段的名称。
public String toGenericString() {
    int mod = getModifiers();
    Type fieldType = getGenericType();
    return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            + fieldType.getTypeName() + " "
            + getDeclaringClass().getTypeName() + "."
            + getName());
}

//返回此Field对象的FieldAccessor，而不是从链向上查找到root
private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
    return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
}
// 为这个Field对象和(递归地)它的root设置FieldAccessor
private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
    if (overrideFinalCheck)
        overrideFieldAccessor = accessor;
    else
        fieldAccessor = accessor;
    // 传播了
    if (root != null) {
        root.setFieldAccessor(accessor, overrideFinalCheck);
    }
}
// 注意，这里没有使用同步。为给定的字段生成多个FieldAccessor是正确的(尽管效率不高)。然而，避免同步可能会使实现更具可伸缩性。
private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
    // 首先检查是否已经创建了一个，如果已经创建了，就接受它
    FieldAccessor tmp = null;
    if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
    if (tmp != null) {
        if (overrideFinalCheck)
            overrideFieldAccessor = tmp;
        else
            fieldAccessor = tmp;
    } else {
        // 否则，制造一个并传播到root
        tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
        setFieldAccessor(tmp, overrideFinalCheck);
    }

    return tmp;
}
// 在调用此方法之前完成安全检查
private FieldAccessor getFieldAccessor(Object obj) throws IllegalAccessException {
    boolean ov = override;
    FieldAccessor a = (ov) ? overrideFieldAccessor : fieldAccessor;
    return (a != null) ? a : acquireFieldAccessor(ov);
}
// 返回指定对象上由{@code field}表示的字段的值。如果该值具有基元类型，则该值自动包装在对象中。
public Object get(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).get(obj);
}
// 获取静态或实例{@code boolean}字段的值。
public boolean getBoolean(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getBoolean(obj);
}
// 获取静态或实例{@code byte}字段的值。
public byte getByte(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getByte(obj);
}
// 获取类型{@code char}的静态字段或实例字段的值，或通过扩展转换可转换为类型{@code char}的另一个原语类型的值。
public char getChar(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getChar(obj);
}
// 获取类型为{@code short}的静态字段或实例字段的值，或通过扩展转换可转换为类型{@code short}的另一个原语类型的值。
public short getShort(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getShort(obj);
}
// 获取类型{@code int}的静态字段或实例字段的值，或通过扩展转换可转换为类型{@code int}的另一基本类型的值。
public int getInt(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getInt(obj);
}
// 获取类型为{@code long}的静态字段或实例字段的值，或通过扩展转换可转换为类型为{@code long}的另一个原语类型的值。
public long getLong(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getLong(obj);
}
// 获取类型为{@code float}的静态字段或实例字段的值，或通过扩展转换可转换为类型{@code float}的另一个原语类型的值。
public float getFloat(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getFloat(obj);
}
// 获取类型为{@code double}的静态字段或实例字段的值，或通过扩展转换可转换为类型{@code double}的另一基本类型的值。
public double getDouble(Object obj) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    return getFieldAccessor(obj).getDouble(obj);
}
// 将指定对象参数上的{@code field}对象表示的字段设置为指定的新值。如果基础字段具有基元类型，则自动取消包装新值。
public void set(Object obj, Object value) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).set(obj, value);
}
// 将指定对象的字段值设置为{@code boolean}。这个方法等价于{@code set(obj, zObj)}，其中{@code zObj}是一个{@code Boolean}对象，{@code zObj. booleanvalue () == z}。
public void setBoolean(Object obj, boolean z) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setBoolean(obj, z);
}
// 将字段的值设置为指定对象的{@code字节}。这个方法等价于{@code set(obj, bObj)}，其中{@code bObj}是一个{@code Byte}对象，{@code bObj. bytevalue () == b}。
public void setByte(Object obj, byte b) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setByte(obj, b);
}
// 将指定对象的字段值设置为{@code char}。这个方法等价于{@code set(obj, cObj)}，其中{@code cObj}是一个{@code Character}对象，{@code cObj. charvalue () == c}。
public void setChar(Object obj, char c) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setChar(obj, c);
}
// 将指定对象的字段值设置为{@code short}。这个方法等价于{@code set(obj, sObj)}，其中{@code sObj}是一个{@code Short}对象，{@code sObj. shortvalue () == s}。
public void setShort(Object obj, short s) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setShort(obj, s);
}
// 将指定对象的字段值设置为{@code int}。这个方法等价于{@code set(obj, iObj)}，其中{@code iObj}是一个{@code Integer}对象，{@code iObj. intvalue () == i}。
public void setInt(Object obj, int i) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setInt(obj, i);
}
// 将指定对象的字段值设置为{@code long}。这个方法等价于{@code set(obj, lObj)}，其中{@code lObj}是一个{@code Long}对象，{@code lObj. longvalue () == l}。
public void setLong(Object obj, long l) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setLong(obj, l);
}
// 将指定对象的字段值设置为{@code float}。这个方法等价于{@code set(obj, fObj)}，其中{@code fObj}是一个{@code Float}对象，{@code fObj. floatvalue () == f}。
public void setFloat(Object obj, float f) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setFloat(obj, f);
}
// 将指定对象的字段值设置为{@code double}。这个方法等价于{@code set(obj, dObj)}，其中{@code dObj}是一个{@code Double}对象，{@code dObj. doublevalue () == d}。
public void setDouble(Object obj, double d) throws IllegalArgumentException, IllegalAccessException {
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    getFieldAccessor(obj).setDouble(obj, d);
}

private synchronized  Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
    if (declaredAnnotations == null) {
        Field root = this.root;
        if (root != null) {
            declaredAnnotations = root.declaredAnnotations();
        } else {
            declaredAnnotations = AnnotationParser.parseAnnotations(
                annotations,
                sun.misc.SharedSecrets.getJavaLangAccess().getConstantPool(getDeclaringClass()),
                getDeclaringClass());
        }
    }
    return declaredAnnotations;
}
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
    Objects.requireNonNull(annotationClass);
    return annotationClass.cast(declaredAnnotations().get(annotationClass));
}
public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
    Objects.requireNonNull(annotationClass);
    return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
}
public Annotation[] getDeclaredAnnotations()  {
    return AnnotationParser.toArray(declaredAnnotations());
}
private native byte[] getTypeAnnotationBytes0();
public AnnotatedType getAnnotatedType() {
    return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
                                                   sun.misc.SharedSecrets.getJavaLangAccess().
                                                   getConstantPool(getDeclaringClass()),
                                                   this,
                                                   getDeclaringClass(),
                                                   getGenericType(),
                                                   TypeAnnotation.TypeAnnotationTarget.FIELD);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
@Getter
@Setter
class SupperClass {
    @NotNull
    public String supperField;
}
@Getter
@Setter
class FieldClass extends SupperClass{
    private String name;
    private int age;
    public char c;
    public float f;
    private byte b;
    public static String ps;
}

Field[] fields = FieldClass.class.getDeclaredFields();
System.out.printf("|%90s|%90s|%10s|%30s|%30s|%20s|%50s|%20s|%20s|%20s|%20s|%40s|%n",
        "String", "Generic String", "Modifiers", "Generic Type", "Type", "Name", "Declaring Class Name", "is Enum Constant",
        "is Synthetic", "is Accessible", "Annotated Type Name", "Annotations Name");
for (Field field : fields) {
    System.out.printf("|%90s|%90s|%10s|%30s|%30s|%20s|%50s|%20s|%20s|%20s|%20s|%40s|%n",
            field.toString(), field.toGenericString(),
            field.getModifiers(), field.getGenericType(), field.getType(), field.getName(),
            field.getDeclaringClass().getName(), field.isEnumConstant(), field.isSynthetic(),
            field.isAccessible(), field.getAnnotatedType().getType().getTypeName(),
            field.getAnnotations().length > 0 ? Arrays.toString(Arrays.stream(field.getAnnotations()).map(anno -> anno.annotationType().getName()).toArray()) : "");
}
Field field = FieldClass.class.getField("supperField");
System.out.printf("|%90s|%90s|%10s|%30s|%30s|%20s|%50s|%20s|%20s|%20s|%20s|%40s|%n",
        field.toString(), field.toGenericString(),
        field.getModifiers(), field.getGenericType(), field.getType(), field.getName(),
        field.getDeclaringClass().getName(), field.isEnumConstant(), field.isSynthetic(),
        field.isAccessible(), field.getAnnotatedType().getType().getTypeName(),
        field.getAnnotations().length > 0 ? Arrays.toString(Arrays.stream(field.getAnnotations()).map(anno -> anno.annotationType().getName()).toArray()) : "");

1
2
3
4
5
6
7
8
9
|                                                                                    String|                                                                            Generic String| Modifiers|                  Generic Type|                          Type|                Name|                              Declaring Class Name|    is Enum Constant|        is Synthetic|       is Accessible| Annotated Type Name|                        Annotations Name|
|             private java.lang.String com.test.FieldClass.name|             private java.lang.String com.test.FieldClass.name|         2|        class java.lang.String|        class java.lang.String|                name|   com.test.FieldClass|               false|               false|               false|    java.lang.String|                                        |
|                           private int com.test.FieldClass.age|                           private int com.test.FieldClass.age|         2|                           int|                           int|                 age|   com.test.FieldClass|               false|               false|               false|                 int|                                        |
|                             public char com.test.FieldClass.c|                             public char com.test.FieldClass.c|         1|                          char|                          char|                   c|   com.test.FieldClass|               false|               false|               false|                char|                                        |
|                            public float com.test.FieldClass.f|                            public float com.test.FieldClass.f|         1|                         float|                         float|                   f|   com.test.FieldClass|               false|               false|               false|               float|                                        |
|                            private byte com.test.FieldClass.b|                            private byte com.test.FieldClass.b|         2|                          byte|                          byte|                   b|   com.test.FieldClass|               false|               false|               false|                byte|                                        |
|         public static java.lang.String com.test.FieldClass.ps|         public static java.lang.String com.test.FieldClass.ps|         9|        class java.lang.String|        class java.lang.String|                  ps|   com.test.FieldClass|               false|               false|               false|    java.lang.String|                                        |
|      public java.lang.String com.test.SupperClass.supperField|      public java.lang.String com.test.SupperClass.supperField|         1|        class java.lang.String|        class java.lang.String|         supperField|  com.test.SupperClass|               false|               false|               false|    java.lang.String|  [javax.validation.constraints.NotNull]|

1
2
3
4
5
// 返回描述此类型的字符串，包括关于任何类型参数的信息。
default String getTypeName() {
    return toString();
}

1
2
3
// 返回一个表示此数组组件类型的{@code Type}对象。此方法创建数组的组件类型。参数化类型的创建过程的语义请参见{@link java.lang.reflect.ParameterizedType ParameterizedType}的声明，类型变量的创建过程请参见{@link java.lang.reflect.TypeVariable TypeVariable}的声明。
Type getGenericComponentType();

1
2
3
4
5
6
7
// 返回一个{@code Type}对象数组，表示该类型的实际类型参数。
Type[] getActualTypeArguments();
// 返回表示声明此类型的类或接口的{@code Type}对象。
Type getRawType();
// 返回一个{@code Type}对象，表示该类型所属的类型。例如，如果此类型是{@code O<T>.I<S>}，返回{@code O<T>}的表示形式。
Type getOwnerType();

1
2
3
4
5
6
7
8
9
// 返回一个{@code Type}对象数组，表示该类型变量的上限。注意，如果没有显式声明上限，则上限为{@code Object}。
Type[] getBounds();
// 返回代表该类型变量的泛型声明的{@code GenericDeclaration}对象。
D getGenericDeclaration();
// 返回此类型变量的名称，因为它出现在源代码中。
String getName();
// 返回一个AnnotatedType对象数组，该数组表示使用类型来表示该类型变量所表示的类型参数的上限。数组中对象的顺序对应于类型形参声明中边界的顺序。
AnnotatedType[] getAnnotatedBounds();

1
2
3
4
5
// 返回一个{@code Type}对象数组，表示该类型变量的上限。注意，如果没有显式声明上限，则上限为{@code Object}。
Type[] getUpperBounds();
// 返回一个{@code Type}对象数组，表示该类型变量的下界。注意，如果没有显式声明下界，则下界的类型为{@code null}。在这种情况下，返回一个零长度的数组。
Type[] getLowerBounds();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
class CType<K extends Number, V> {
    List<K> list = new ArrayList<>();
    Map<K,V> map = new HashMap<>();
    K k;
    Map<K, List<V>> mapList;
    Map<String, K> mapString;
    K[] kArr;
    List<? extends Collection<K>> extendsF;
    List<? super String> supperF;
    Inner inner = new Inner();
    @Value("123")
    String defaultString;

    class Inner {}
}

public static void main(String[] args) {
    CType<Integer, Long> cType = new CType<>();
    System.out.printf("|%20s|%20s|%50s|%60s|%10s|%110s|%80s|%110s|%30s|%n",
            "Field Name", "Type Name", "GenericType Name",
            "GenericTypeClass Name", "modifier", "parameterizedTypeInfo",
            "wildcardTypeInfo", "typeVariableInfo", "genericArrayTypeInfo");
    for (Field field : cType.getClass().getDeclaredFields()) {
        Class<?> type = field.getType();
        Type genericType = field.getGenericType();

        // ParameterizedType:1000, TypeVariable:0100, GenericArrayType:0010, WildcardType:0001
        StringBuilder parameterizedTypeInfo = new StringBuilder();
        StringBuilder wildcardTypeInfo = new StringBuilder();
        StringBuilder typeVariableInfo = new StringBuilder();
        StringBuilder genericArrayTypeInfo = new StringBuilder();
        int modifier = 0;
        if (genericType instanceof ParameterizedType) {
            modifier |= 0b1000;
            parameterizedTypeInfo.append("getActualTypeArguments: ").append(Arrays.toString(Arrays.stream(((ParameterizedType) genericType).getActualTypeArguments()).map(Type::getTypeName).toArray()))
                    .append(", getRawType: ").append(((ParameterizedType) genericType).getRawType().getTypeName())
                    .append(", getOwnerType: ").append(Objects.nonNull(((ParameterizedType) genericType).getOwnerType()) ? ((ParameterizedType) genericType).getOwnerType().getTypeName() : null);

            for (Type actualTypeArgument : ((ParameterizedType) genericType).getActualTypeArguments()) {
                if (actualTypeArgument instanceof WildcardType) {
                    modifier |= 0b0001;
                    wildcardTypeInfo.append("getLowerBounds: ").append(Arrays.toString(Arrays.stream(((WildcardType) actualTypeArgument).getLowerBounds()).map(Type::getTypeName).toArray()))
                            .append(", getUpperBounds: ").append(Arrays.toString(Arrays.stream(((WildcardType) actualTypeArgument).getUpperBounds()).map(Type::getTypeName).toArray()));
                }
            }
        } else if (genericType instanceof TypeVariable) {
            modifier |= 0b0100;
            typeVariableInfo.append("getBounds: ").append(Arrays.toString(Arrays.stream(((TypeVariable<?>) genericType).getBounds()).map(Type::getTypeName).toArray()))
                    .append(", getGenericDeclaration: ").append(Arrays.toString(Arrays.stream(((TypeVariable<?>) genericType).getGenericDeclaration().getAnnotations()).map(anno -> anno.annotationType().getName()).toArray()))
                    .append(", getName: ").append(((TypeVariable<?>) genericType).getName())
                    .append(", getAnnotatedBounds: ").append(Arrays.toString(Arrays.stream(((TypeVariable<?>) genericType).getAnnotatedBounds()).map(anno -> anno.getType().getTypeName()).toArray()));
        } else if (genericType instanceof GenericArrayType) {
            modifier |= 0b0010;
            genericArrayTypeInfo.append("getGenericComponentType: ").append(((GenericArrayType) genericType).getGenericComponentType());
        }
        System.out.printf("|%20s|%20s|%50s|%60s|%10s|%110s|%80s|%110s|%30s|%n",
                field.getName(), type.getName(), genericType.getTypeName(), genericType.getClass().getName(),
                String.format("%1$04d", Integer.valueOf(Integer.toBinaryString(modifier))), parameterizedTypeInfo.toString(), wildcardTypeInfo.toString(), typeVariableInfo.toString(),
                genericArrayTypeInfo.toString());
    }
    // GenericArrayType接口测试，GenericArrayType接口在lang包中只有三个实现类Class、Method、Construct
    System.out.println("n" + Arrays.toString(Arrays.stream(cType.getClass().getTypeParameters()).map(TypeVariable::getName).toArray()));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
|          Field Name|           Type Name|                                  GenericType Name|                                       GenericTypeClass Name|  modifier|                                                                                         parameterizedTypeInfo|                                                                wildcardTypeInfo|                                                                                              typeVariableInfo|          genericArrayTypeInfo|
|                list|      java.util.List|                                 java.util.List<K>|sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl|      1000|                                   getActualTypeArguments: [K], getRawType: java.util.List, getOwnerType: null|                                                                                |                                                                                                              |                              |
|                 map|       java.util.Map|                               java.util.Map<K, V>|sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl|      1000|                                 getActualTypeArguments: [K, V], getRawType: java.util.Map, getOwnerType: null|                                                                                |                                                                                                              |                              |
|                   k|    java.lang.Number|                                                 K|     sun.reflect.generics.reflectiveObjects.TypeVariableImpl|      0100|                                                                                                              |                                                                                |  getBounds: [java.lang.Number], getGenericDeclaration: [], getName: K, getAnnotatedBounds: [java.lang.Number]|                              |
|             mapList|       java.util.Map|               java.util.Map<K, java.util.List<V>>|sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl|      1000|                 getActualTypeArguments: [K, java.util.List<V>], getRawType: java.util.Map, getOwnerType: null|                                                                                |                                                                                                              |                              |
|           mapString|       java.util.Map|                java.util.Map<java.lang.String, K>|sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl|      1000|                  getActualTypeArguments: [java.lang.String, K], getRawType: java.util.Map, getOwnerType: null|                                                                                |                                                                                                              |                              |
|                kArr| [Ljava.lang.Number;|                                               K[]| sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl|      0010|                                                                                                              |                                                                                |                                                                                                              |    getGenericComponentType: K|
|            extendsF|      java.util.List| java.util.List<? extends java.util.Collection<K>>|sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl|      1001|   getActualTypeArguments: [? extends java.util.Collection<K>], getRawType: java.util.List, getOwnerType: null|                   getLowerBounds: [], getUpperBounds: [java.util.Collection<K>]|                                                                                                              |                              |
|             supperF|      java.util.List|          java.util.List<? super java.lang.String>|sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl|      1001|            getActualTypeArguments: [? super java.lang.String], getRawType: java.util.List, getOwnerType: null|          getLowerBounds: [java.lang.String], getUpperBounds: [java.lang.Object]|                                                                                                              |                              |
|               inner|com.test.CType$Inner|                        com.test.CType<K, V>$Inner|sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl|      1000|              getActualTypeArguments: [], getRawType: com.test.CType$Inner, getOwnerType: com.test.CType<K, V>|                                                                                |                                                                                                              |                              |
|       defaultString|    java.lang.String|                                  java.lang.String|                                             java.lang.Class|      0000|                                                                                                              |                                                                                |                                                                                                              |                              |

[K, V]

1
2
3
// 返回一个{@code TypeVariable}对象的数组，该数组按声明顺序表示由{@code GenericDeclaration}对象所表示的泛型声明所声明的类型变量。如果基础泛型声明没有声明类型变量，则返回长度为0的数组。
public TypeVariable<?>[] getTypeParameters();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
private transient volatile boolean hasRealParameterData;
private transient volatile Parameter[] parameters;

private native Parameter[] getParameters0();
native byte[] getTypeAnnotationBytes0();
// 只将包可见性授予构造函数。
Executable() {}
// 访问器方法以允许代码共享
abstract byte[] getAnnotationBytes();
// 访问器方法以允许代码共享
abstract Executable getRoot();
// 可执行文件是否有泛型信息。
abstract boolean hasGenericInformation();
abstract ConstructorRepository getGenericInfo();
// 判断参数类型是否相同
boolean equalParamTypes(Class<?>[] params1, Class<?>[] params2) {
    /* 避免不必要的克隆 */
    if (params1.length == params2.length) {
        for (int i = 0; i < params1.length; i++) {
            if (params1[i] != params2[i])
                return false;
        }
        return true;
    }
    return false;
}
// 解析参数注解
Annotation[][] parseParameterAnnotations(byte[] parameterAnnotations) {
    return AnnotationParser.parseParameterAnnotations(
        parameterAnnotations,
        sun.misc.SharedSecrets.getJavaLangAccess().
        getConstantPool(getDeclaringClass()),
        getDeclaringClass());
}
// 使用逗号分隔类型
void separateWithCommas(Class<?>[] types, StringBuilder sb) {
    for (int j = 0; j < types.length; j++) {
        sb.append(types[j].getTypeName());
        if (j < (types.length - 1))
            sb.append(",");
    }

}
// 如果非零，打印修饰符
void printModifiersIfNonzero(StringBuilder sb, int mask, boolean isDefault) {
    int mod = getModifiers() & mask;
    if (mod != 0 && !isDefault) {
        sb.append(Modifier.toString(mod)).append(' ');
    } else {
        int access_mod = mod & Modifier.ACCESS_MODIFIERS;
        if (access_mod != 0)
            sb.append(Modifier.toString(access_mod)).append(' ');
        if (isDefault)
            sb.append("default ");
        mod = (mod & ~Modifier.ACCESS_MODIFIERS);
        if (mod != 0)
            sb.append(Modifier.toString(mod)).append(' ');
    }
}
// 生成特定于方法或构造函数的toString头信息。
abstract void specificToStringHeader(StringBuilder sb);
// 生成字符串
String sharedToString(int modifierMask,
                          boolean isDefault,
                          Class<?>[] parameterTypes,
                          Class<?>[] exceptionTypes) {
    try {
        StringBuilder sb = new StringBuilder();
        printModifiersIfNonzero(sb, modifierMask, isDefault);
        specificToStringHeader(sb);
        sb.append('(');
        separateWithCommas(parameterTypes, sb);
        sb.append(')');
        if (exceptionTypes.length > 0) {
            sb.append(" throws ");
            separateWithCommas(exceptionTypes, sb);
        }
        return sb.toString();
    } catch (Exception e) {
        return "<" + e + ">";
    }
}
// 生成泛型字符串
String sharedToGenericString(int modifierMask, boolean isDefault) {
    try {
        StringBuilder sb = new StringBuilder();
        printModifiersIfNonzero(sb, modifierMask, isDefault);
        TypeVariable<?>[] typeparms = getTypeParameters();
        if (typeparms.length > 0) {
            boolean first = true;
            sb.append('<');
            for(TypeVariable<?> typeparm: typeparms) {
                if (!first)
                    sb.append(',');
                // 类对象不能出现在这里;不需要测试和调用Class.getName()。
                sb.append(typeparm.toString());
                first = false;
            }
            sb.append("> ");
        }

        specificToGenericStringHeader(sb);

        sb.append('(');
        Type[] params = getGenericParameterTypes();
        for (int j = 0; j < params.length; j++) {
            String param = params[j].getTypeName();
            if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...
                param = param.replaceFirst("\[\]$", "...");
            sb.append(param);
            if (j < (params.length - 1))
                sb.append(',');
        }
        sb.append(')');
        Type[] exceptions = getGenericExceptionTypes();
        if (exceptions.length > 0) {
            sb.append(" throws ");
            for (int k = 0; k < exceptions.length; k++) {
                sb.append((exceptions[k] instanceof Class)?
                          ((Class)exceptions[k]).getName():
                          exceptions[k].toString());
                if (k < (exceptions.length - 1))
                    sb.append(',');
            }
        }
        return sb.toString();
    } catch (Exception e) {
        return "<" + e + ">";
    }
}
// 返回{@code Class}对象，该对象表示声明由该对象表示的可执行文件的类或接口。
public abstract Class<?> getDeclaringClass();
// 返回由该对象表示的可执行文件的名称。
public abstract String getName();
// 返回由该对象表示的可执行文件的Java语言{@linkplain Modifier modifiers}。
public abstract int getModifiers();
// 返回一个{@code TypeVariable}对象的数组，该数组按声明顺序表示由{@code GenericDeclaration}对象所表示的泛型声明所声明的类型变量。如果基础泛型声明没有声明类型变量，则返回长度为0的数组。
public abstract TypeVariable<?>[] getTypeParameters();
// 返回一个{@code Class}对象的数组，该数组表示由该对象表示的可执行文件的形式形参类型(按声明顺序)。如果底层可执行文件不接受参数，则返回长度为0的数组。
public abstract Class<?>[] getParameterTypes();
// 返回此对象表示的可执行文件的形式参数数量(显式声明或隐式声明，或两者都没有)。
public int getParameterCount() {
    throw new AbstractMethodError();
}
// 返回一个{@code Type}对象的数组，该数组表示由该对象表示的可执行文件的形式参数类型(按声明顺序)。如果底层可执行文件不接受参数，则返回长度为0的数组。
public Type[] getGenericParameterTypes() {
    if (hasGenericInformation())
        return getGenericInfo().getParameterTypes();
    else
        return getParameterTypes();
}
// 行为类似于{@code getGenericParameterTypes}，但返回所有参数的类型信息，包括合成参数。
Type[] getAllGenericParameterTypes() {
    final boolean genericInfo = hasGenericInformation();

    // 简单的情况:我们没有泛型参数信息。在本例中，我们只返回getParameterTypes()的结果
    if (!genericInfo) {
        return getParameterTypes();
    } else {
        final boolean realParamData = hasRealParameterData();
        final Type[] genericParamTypes = getGenericParameterTypes();
        final Type[] nonGenericParamTypes = getParameterTypes();
        final Type[] out = new Type[nonGenericParamTypes.length];
        final Parameter[] params = getParameters();
        int fromidx = 0;
        // 如果我们有真正的参数数据，那么我们可以使用合成和授权标志。
        if (realParamData) {
            for (int i = 0; i < out.length; i++) {
                final Parameter param = params[i];
                if (param.isSynthetic() || param.isImplicit()) {
                    // 如果遇到一个合成参数或强制参数，则使用非泛型参数信息。
                    out[i] = nonGenericParamTypes[i];
                } else {
                    // 否则，使用泛型参数info。
                    out[i] = genericParamTypes[fromidx];
                    fromidx++;
                }
            }
        } else {
            // 否则，使用非泛型参数数据。没有方法参数反射数据，我们就没有办法找出哪些参数是合成的/强制的，因此，就没有办法匹配索引。
            return genericParamTypes.length == nonGenericParamTypes.length ?
                genericParamTypes : nonGenericParamTypes;
        }
        return out;
    }
}
// 返回一个{@code Parameter}对象数组，该数组表示该对象所表示的底层可执行文件的所有参数。如果可执行文件没有参数，则返回长度为0的数组。
public Parameter[] getParameters() {
    // TODO: 这可能最终需要使用类似于Field、Method等中的安全机制来保护。
	// 需要复制缓存的数组，以防止用户乱用它。由于形参是不可变的，我们可以进行浅复制。
    return privateGetParameters().clone();
}
// 综合所有的参数
private Parameter[] synthesizeAllParams() {
    final int realparams = getParameterCount();
    final Parameter[] out = new Parameter[realparams];
    for (int i = 0; i < realparams; i++)
        // TODO: 有没有一种方法可以综合推导出修饰语?一般情况下可能不会，因为我们无法了解它们，但可能会有特定的情况。
        out[i] = new Parameter("arg" + i, 0, this, i);
    return out;
}
// 参数验证
private void verifyParameters(final Parameter[] parameters) {
    final int mask = Modifier.FINAL | Modifier.SYNTHETIC | Modifier.MANDATED;

    if (getParameterTypes().length != parameters.length)
        throw new MalformedParametersException("Wrong number of parameters in MethodParameters attribute");

    for (Parameter parameter : parameters) {
        final String name = parameter.getRealName();
        final int mods = parameter.getModifiers();

        if (name != null) {
            if (name.isEmpty() || name.indexOf('.') != -1 ||
                name.indexOf(';') != -1 || name.indexOf('[') != -1 ||
                name.indexOf('/') != -1) {
                throw new MalformedParametersException("Invalid parameter name "" + name + """);
            }
        }

        if (mods != (mods & mask)) {
            throw new MalformedParametersException("Invalid parameter modifiers");
        }
    }
}
// 私有（私自？）获得参数
private Parameter[] privateGetParameters() {
    // 使用tmp来避免对volatile的多次写入。
    Parameter[] tmp = parameters;
    if (tmp == null) {
        // 否则，请到JVM获取它们
        try {
            tmp = getParameters0();
        } catch(IllegalArgumentException e) {
            // 重新抛出ClassFormatErrors
            throw new MalformedParametersException("Invalid constant pool index");
        }

        // 如果我们什么都没有得到，那么就合成参数
        if (tmp == null) {
            hasRealParameterData = false;
            tmp = synthesizeAllParams();
        } else {
            hasRealParameterData = true;
            verifyParameters(tmp);
        }
        parameters = tmp;
    }
    return tmp;
}
// 是否有真实参数数据
boolean hasRealParameterData() {
    // 如果这个函数在参数初始化之前被调用，强制它存在。
    if (parameters == null) {
        privateGetParameters();
    }
    return hasRealParameterData;
}
// reflectaccess所需的
byte[] getTypeAnnotationBytes() {
    return getTypeAnnotationBytes0();
}
// 返回一个{@code Class}对象数组，该数组表示由该对象表示的底层可执行文件声明引发的异常类型。如果可执行文件在其{@code throws}子句中没有声明异常，则返回长度为0的数组。
public abstract Class<?>[] getExceptionTypes();
// 返回一个{@code Type}对象数组，该数组表示此可执行对象声明要抛出的异常。如果底层可执行文件在其{@code throws}子句中没有声明异常，则返回长度为0的数组。
public Type[] getGenericExceptionTypes() {
    Type[] result;
    if (hasGenericInformation() &&
        ((result = getGenericInfo().getExceptionTypes()).length > 0))
        return result;
    else
        return getExceptionTypes();
}
// 返回一个描述此{@code Executable}的字符串，包括任何类型参数。
public abstract String toGenericString();
// 如果这个可执行文件声明接受可变数量的参数，则返回{@code true};否则返回{@code false}。
public boolean isVarArgs()  {
    return (getModifiers() & Modifier.VARARGS) != 0;
}
// 如果这个可执行文件是一个合成构造，返回{@code true};否则返回{@code false}。
public boolean isSynthetic() {
    return Modifier.isSynthetic(getModifiers());
}
// 返回一个由{@code Annotation}组成的数组，该数组表示由该对象表示的{@code Executable}的形式参数上的注释(按声明顺序)。合成参数和指定参数(参见下面的解释)，例如内部类构造函数的外部“this”参数将在返回的数组中表示。如果可执行文件没有参数(意味着没有正式的、合成的和强制的参数)，将返回一个零长度的数组。如果{@code Executable}有一个或多个参数，则为每个不带注释的参数返回长度为0的嵌套数组。返回数组中包含的注释对象是可序列化的。这个方法的调用者可以自由地修改返回的数组;它对返回给其他调用方的数组没有影响。
public abstract Annotation[][] getParameterAnnotations();
// 参数说明
Annotation[][] sharedGetParameterAnnotations(Class<?>[] parameterTypes,
                                                 byte[] parameterAnnotations) {
    int numParameters = parameterTypes.length;
    if (parameterAnnotations == null)
        return new Annotation[numParameters][0];

    Annotation[][] result = parseParameterAnnotations(parameterAnnotations);

    if (result.length != numParameters)
        handleParameterNumberMismatch(result.length, numParameters);
    return result;
}
// 参数号不匹配处理
abstract void handleParameterNumberMismatch(int resultLength, int numParameters);

private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
    Objects.requireNonNull(annotationClass);
    return annotationClass.cast(declaredAnnotations().get(annotationClass));
}
public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
    Objects.requireNonNull(annotationClass);
    return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
}
public Annotation[] getDeclaredAnnotations()  {
    return AnnotationParser.toArray(declaredAnnotations());
}
private synchronized  Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
    if (declaredAnnotations == null) {
        Executable root = getRoot();
        if (root != null) {
            declaredAnnotations = root.declaredAnnotations();
        } else {
            declaredAnnotations = AnnotationParser.parseAnnotations(
                getAnnotationBytes(),
                sun.misc.SharedSecrets.getJavaLangAccess().
                getConstantPool(getDeclaringClass()),
                getDeclaringClass());
        }
    }
    return declaredAnnotations;
}
// 返回一个{@code AnnotatedType}对象，该对象表示使用一个类型来指定该可执行文件所表示的方法/构造函数的返回类型。
public abstract AnnotatedType getAnnotatedReturnType();
// 可执行文件的子类的助手。
// 返回一个AnnotatedType对象，该对象表示使用一个类型来指定该可执行文件所表示的方法/构造函数的返回类型。
AnnotatedType getAnnotatedReturnType0(Type returnType) {
    return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
        sun.misc.SharedSecrets.getJavaLangAccess().
                getConstantPool(getDeclaringClass()),
        this,
        getDeclaringClass(),
        returnType,
        TypeAnnotation.TypeAnnotationTarget.METHOD_RETURN);
}
// 返回一个{@code AnnotatedType}对象，该对象表示使用一个类型来指定这个可执行对象所表示的方法/构造函数的接收类型。方法/构造函数的接收器类型只有在方法/构造函数有接收器参数时才可用(JLS 8.4.1)。
public AnnotatedType getAnnotatedReceiverType() {
    if (Modifier.isStatic(this.getModifiers()))
        return null;
    return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
            sun.misc.SharedSecrets.getJavaLangAccess().
                    getConstantPool(getDeclaringClass()),
            this,
            getDeclaringClass(),
            getDeclaringClass(),
            TypeAnnotation.TypeAnnotationTarget.METHOD_RECEIVER);
}
// 返回一个{@code AnnotatedType}对象数组，该数组表示使用类型来指定该可执行文件所表示的方法/构造函数的形式参数类型。数组中对象的顺序对应于方法/构造函数声明中形式形参类型的顺序。
public AnnotatedType[] getAnnotatedParameterTypes() {
    return TypeAnnotationParser.buildAnnotatedTypes(getTypeAnnotationBytes0(),
            sun.misc.SharedSecrets.getJavaLangAccess().
                    getConstantPool(getDeclaringClass()),
            this,
            getDeclaringClass(),
            getAllGenericParameterTypes(),
            TypeAnnotation.TypeAnnotationTarget.METHOD_FORMAL_PARAMETER);
}
// 返回一个{@code AnnotatedType}对象数组，该数组表示使用类型来指定由该可执行文件表示的方法/构造函数声明的异常。数组中对象的顺序对应于方法/构造函数声明中异常类型的顺序。
public AnnotatedType[] getAnnotatedExceptionTypes() {
    return TypeAnnotationParser.buildAnnotatedTypes(getTypeAnnotationBytes0(),
            sun.misc.SharedSecrets.getJavaLangAccess().
                    getConstantPool(getDeclaringClass()),
            this,
            getDeclaringClass(),
            getGenericExceptionTypes(),
            TypeAnnotation.TypeAnnotationTarget.THROWS);
}