前言
- {@code Field}提供有关类或接口的单个字段以及对它们的动态访问的信息。
- 反射字段可以是类（静态）字段或实例字段。
- {@code Field}允许在获取或设置访问操作期间进行扩展转换，但是如果将发生缩小转换，则抛出{@code IllegalArgumentException}。
源码
package java.lang.reflect;
public final
class Field extends AccessibleObject implements Member {
private Class<?> clazz;
private int slot;
// This is guaranteed to be interned by the VM in the 1.4
// reflection implementation
private String name;
private Class<?> type;
private int modifiers;
// Generics and annotations support
private transient String signature;
// generic info repository; lazily initialized
private transient FieldRepository genericInfo;
private byte[] annotations;
// Cached field accessor created without override
private FieldAccessor fieldAccessor;
// Cached field accessor created with override
private FieldAccessor overrideFieldAccessor;
// For sharing of FieldAccessors. This branching structure is
// currently only two levels deep (i.e., one root Field and
// potentially many Field objects pointing to it.)
//
// If this branching structure would ever contain cycles, deadlocks can
// occur in annotation code.
private Field root;
// Generics infrastructure
private String getGenericSignature() {return signature;}
// Accessor for factory
private GenericsFactory getFactory() {
Class<?> c = getDeclaringClass();
// create scope and factory
return CoreReflectionFactory.make(c, ClassScope.make(c));
}
// Accessor for generic info repository
private FieldRepository getGenericInfo() {
// lazily initialize repository if necessary
if (genericInfo == null) {
// create and cache generic info repository
genericInfo = FieldRepository.make(getGenericSignature(),
getFactory());
}
return genericInfo; //return cached repository
}
/**
* Package-private constructor used by ReflectAccess to enable
* instantiation of these objects in Java code from the java.lang
* package via 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;
}
Field copy() {
// This routine enables sharing of FieldAccessor objects
// among Field objects which refer to the same underlying
// method in the VM. (All of this contortion is only necessary
// because of the "accessibility" bit in AccessibleObject,
// which implicitly requires that new java.lang.reflect
// objects be fabricated for each reflective call on Class
// objects.)
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;
// Might as well eagerly propagate this if already present
res.fieldAccessor = fieldAccessor;
res.overrideFieldAccessor = overrideFieldAccessor;
return res;
}
/**
* Returns the {@code Class} object representing the class or interface
* that declares the field represented by this {@code Field} object.
* 返回表示该类或接口的{@code Class}对象，该类或接口声明此{@code Field}对象表示的字段。
*/
public Class<?> getDeclaringClass() {
return clazz;
}
/**
* Returns the name of the field represented by this {@code Field} object.
* 返回此{@code Field}对象表示的字段的名称。
*/
public String getName() {
return name;
}
/**
* 以整数返回此{@code Field}对象表示的字段的Java语言修饰符。
* {@code Modifier}类应用于解码修饰符。
*
* Returns the Java language modifiers for the field represented
* by this {@code Field} object, as an integer. The {@code Modifier} class should
* be used to decode the modifiers.
*
* @see Modifier
*/
public int getModifiers() {
return modifiers;
}
/**
* 如果此字段表示枚举类型的元素，则返回{@code true}；否则，返回false。否则返回{@code false}。
*
* Returns {@code true} if this field represents an element of
* an enumerated type; returns {@code false} otherwise.
*
* @return {@code true} if and only if this field represents an element of
* an enumerated type.
* @since 1.5
*/
public boolean isEnumConstant() {
return (getModifiers() & Modifier.ENUM) != 0;
}
/**
* 如果此字段是合成字段，则返回{@code true}；否则，返回{@code true}。否则返回{@code false}。
*
* Returns {@code true} if this field is a synthetic
* field; returns {@code false} otherwise.
*
* @return true if and only if this field is a synthetic
* field as defined by the Java Language Specification.
* @since 1.5
*/
public boolean isSynthetic() {
return Modifier.isSynthetic(getModifiers());
}
/**
* 返回一个{@code Class}对象，该对象标识此{@code Field}对象表示的字段的声明类型。
*/
public Class<?> getType() {
return type;
}
/**
* 返回一个{@code Type}对象，该对象表示此{@code Field}对象表示的字段的声明的类型。
* 如果{@code Type}是参数化类型，则返回的{@code Type}对象必须准确反映源代码中使用的实际类型参数。
* 如果基础字段的类型是类型变量或参数化类型，则会创建它。
* Otherwise, it is resolved.
*
*/
public Type getGenericType() {
if (getGenericSignature() != null)
return getGenericInfo().getGenericType();
else
return getType();
}
/**
* 将此{@code字段}与指定对象进行比较。
* 如果对象相同，则返回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();
}
public String toString() {
int mod = getModifiers();
return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
+ getType().getTypeName() + " "
+ getDeclaringClass().getTypeName() + "."
+ getName());
}
public String toGenericString() {
int mod = getModifiers();
Type fieldType = getGenericType();
return (((mod == 0) ? "" : (Modifier.toString(Annotationmod) + " "))
+ fieldType.getTypeName() + " "
+ getDeclaringClass().getTypeName() + "."
+ getName());
}
/**
* 返回指定对象上此{@code Field}表示的字段的值。
* 如果值具有原始类型，则该值将自动包装在对象中。
* 基础字段的值如下获得：如果基础字段是静态字段，则忽略{@code obj}参数；它可以为空。
* 否则，基础字段是实例字段。
* 如果指定的{@code obj}参数为null，则该方法将引发{@code NullPointerException}。
* 如果指定的对象不是声明基础字段的类或接口的实例，则该方法将引发{@code IllegalArgumentException}。
* 如果此{@code Field}对象正在执行Java语言访问控制，并且基础字段不可访问，则该方法将引发{@code IllegalAccessException}。
* 如果基础字段是静态的，则声明该字段的类将被初始化（如果尚未初始化）。
* 否则，将从基础实例或静态字段中检索该值。
* 如果该字段具有原始类型，则该值将在返回之前包装在一个对象中，否则将按原样返回。
* 如果该字段以{@code obj}的类型隐藏，则该字段的值将根据前面的规则获得。
*/
@CallerSensitive
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}字段的值。
*/
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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}对象在指定对象参数上表示的字段设置为指定的新值。
* 如果基础字段具有原始类型，则新值将自动展开。
* 操作如下：如果基础字段是静态的，则{@code obj}参数将被忽略；它可以为空。
* 否则，基础字段是实例字段。
* 如果指定的对象参数为null，则该方法将引发{@code NullPointerException}。
* 如果指定的对象参数不是声明基础字段的类或接口的实例，则该方法将引发{@code IllegalArgumentException}。
* 如果此{@code Field}对象正在执行Java语言访问控制，并且基础字段不可访问，则该方法将引发{@code IllegalAccessException}。
* 如果基础字段是最终字段，则该方法将抛出{@code IllegalAccessException}，除非已成功为此{@code Field}对象使用{@code setAccessible（true）}，并且该字段是非静态的。
* 以这种方式设置最终字段仅在反序列化或重构具有空白最终字段的类的实例时才有意义，然后才可以将它们用于程序的其他部分。
* 在任何其他上下文中使用它可能会产生不可预测的影响，包括程序其他部分继续使用该字段的原始值的情况。
* 如果基础字段是原始类型，则尝试展开包装转换以将新值转换为原始类型的值。
* 如果尝试失败，则该方法将引发{@code IllegalArgumentException}。
* 如果在可能的展开之后，新值不能通过标识或扩展转换转换为基础字段的类型，则该方法将引发{@code IllegalArgumentException}。
* 如果基础字段是静态的，则声明该字段的类将被初始化（如果尚未初始化）。
* 该字段设置为可能已展开和扩展的新值。
* 如果该字段以{@code obj}的类型隐藏，则该字段的值将根据前面的规则进行设置。
*/
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
@CallerSensitive
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);
}
// security check is done before calling this method
private FieldAccessor getFieldAccessor(Object obj)
throws IllegalAccessException
{
boolean ov = override;
FieldAccessor a = (ov) ? overrideFieldAccessor : fieldAccessor;
return (a != null) ? a : acquireFieldAccessor(ov);
}
private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
// First check to see if one has been created yet, and take it
// if so
FieldAccessor tmp = null;
if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
if (tmp != null) {
if (overrideFinalCheck)
overrideFieldAccessor = tmp;
else
fieldAccessor = tmp;
} else {
// Otherwise fabricate one and propagate it up to the root
tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
setFieldAccessor(tmp, overrideFinalCheck);
}
return tmp;
}
// Returns FieldAccessor for this Field object, not looking up
// the chain to the root
private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
}
// Sets the FieldAccessor for this Field object and
// (recursively) its root
private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
if (overrideFinalCheck)
overrideFieldAccessor = accessor;
else
fieldAccessor = accessor;
// Propagate up
if (root != null) {
root.setFieldAccessor(accessor, overrideFinalCheck);
}
}
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
Objects.requireNonNull(annotationClass);
return annotationClass.cast(declaredAnnotations().get(annotationClass));
}
@Override
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 transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
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;
}
private native byte[] getTypeAnnotationBytes0();
public AnnotatedType getAnnotatedType() {
return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
this,
getDeclaringClass(),
getGenericType(),
TypeAnnotation.TypeAnnotationTarget.FIELD);
}
}
