前言
前几篇文章讲述Java反射核心功能与用法，基本的常用方法都已经囊括里面了，本篇针是对前几篇文章进行补充。
AccessibleObject
AccessibleObject类是前几篇文章所述的Field、Method、Constructor的基类。它提供了将反射的对象标记为在使用时取消默认Java语言访问控制检查的能力，它可以在在反射对象中设置accessible标志而获取特权，大部分时间我们称这种方式为“暴力反射”。
它们之间的关系如下：
对于公共成员、默认成员、受保护成员、私有成员，在使用Field、Method、Constructor对象来设置或获取字段、调用方法，又或者创建和初始化类的新实例的时候，会执行访问检查。但是AccessibleObject类在反射对象中设置accessible标志允许具有足够权限，以通常被禁止的方式操作对象。
/**
* The AccessibleObject class is the base class for Field, Method and
* Constructor objects. It provides the ability to flag a reflected
* object as suppressing default Java language access control checks
* when it is used. The access checks--for public, default (package)
* access, protected, and private members--are performed when Fields,
* Methods or Constructors are used to set or get fields, to invoke
* methods, or to create and initialize new instances of classes,
* respectively.
*
* <p>Setting the {@code accessible} flag in a reflected object
* permits sophisticated applications with sufficient privilege, such
* as Java Object Serialization or other persistence mechanisms, to
* manipulate objects in a manner that would normally be prohibited.
* <p>By default, a reflected object is <em>not</em> accessible.
*/
public class AccessibleObject implements AnnotatedElement {
/**
* 用于检查客户端是否具有足够的权限来阻止java语言访问控制检查
* The Permission object that is used to check whether a client
* has sufficient privilege to defeat Java language access
* control checks.
Permission对象，
*/
static final private java.security.Permission ACCESS_PERMISSION = new ReflectPermission("suppressAccessChecks");
/**
* 使用单一安全检查来设置对象数组的可访问标志的一个方便的方法（为了效率）
* Convenience method to set the {@code accessible} flag for an
* array of objects with a single security check (for efficiency).
*/
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);
}
}
/**
设置可访问标志设置
*/
public void setAccessible(boolean flag) throws SecurityException {
SecurityManager sm = System.getSecurityManager();
if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
setAccessible0(this, flag);
}
/*
* Check that you aren't exposing java.lang.Class.<init> or sensitive
fields in 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;
}
/**
* 获取accessible标志
*/
public boolean isAccessible() {
return override;
}
/**
* 构造函数，仅JVM使用
* Constructor: only used by the Java Virtual Machine.
*/
protected AccessibleObject() {}
// Indicates whether language-level access checks are overridden
// by this object. Initializes to "false". This field is used by
// Field, Method, and Constructor.
// 通过这个对象，指示是否覆盖语言级别访问检查权限，初始化为false,该字段用于Field, Method和Constructor
// NOTE: for security purposes, this field must not be visible
// outside this package. 出于安全考虑，此字段不得显示出包外
boolean override;
// Reflection factory used by subclasses for creating field,
// method, and constructor accessors. Note that this is called
// very early in the bootstrapping process. 子类用于创建字段，方法和构造函数的反射工厂
static final ReflectionFactory reflectionFactory = AccessController.doPrivileged(
new sun.reflect.ReflectionFactory.GetReflectionFactoryAction()
);
// .....
}方法如下：
其他的方法，本文不做展开，具体的请参阅文档，我们重点来看setAccessible方法。
setAccessible
- 值为true时代表反射的对象在使用时应该取消Java语言的访问检查。
- 值为false时代表反射的对象应该实施Java语言访问检查。
由于JDK的安全检查耗时较多，所以通过 setAccessible(true) 的方式关闭安全检查来提升反射速度。
Example
如何通过反射在访问类的private属性/方法/构造方法?
@Data
@NoArgsConstructor
@AllArgsConstructor
static class User {
private String name;
private Integer age;
private void print(String msg) {
System.out.println(msg);
System.out.println("hi，我是:" + name + "，年龄:" + age);
}
}// 访问私有的成员变量
public static void main(String[] args) throws Exception {
User user = new User("Duansg", 18);
// 访问私有的成员变量
Field field = User.class.getDeclaredField("name");
field.setAccessible(true);
// Duansg
System.out.println(field.get(user));
}// 改变私有的成员变量值
public static void main(String[] args) throws Exception {
User user = new User("Duansg", 18);
// 访问私有的成员变量
Field field = User.class.getDeclaredField("name");
field.setAccessible(true);
field.set(user, "马云");
// 马云
System.out.println(field.get(user));
}// 访问private方法
public static void main(String[] args) throws Exception {
User user = new User("Duansg", 18);
Method method = User.class.getDeclaredMethod("print", String.class);
method.setAccessible(true);
method.invoke(user, "hi，我是晓断，今年22");
// hi，我是晓断，今年22
// hi，我是:Duansg，年龄:18
}
PropertyDescriptor
PropertyDescriptor类是一个属性的描述器，它表示JavaBean类通过存储器导出一个属性。详细的可了解Javad的内省机制，PropertyDescriptor主要方法：
从上图不难看出，它就是用于处理属性相关的信息，比如读写方法的设置和读取，获取属性的类型等等操作。FeatureDescriptor的顶层类，它的子类有PropertyDescriptor、MethodDescriptor、BeanDescriptor等等。它们的关系如下：
package java.beans;
/**
* A PropertyDescriptor describes one property that a Java Bean
* exports via a pair of accessor methods.
*/
public class PropertyDescriptor extends FeatureDescriptor {
private Reference<? extends Class<?>> propertyTypeRef;
private final MethodRef readMethodRef = new MethodRef();
private final MethodRef writeMethodRef = new MethodRef();
private Reference<? extends Class<?>> propertyEditorClassRef;
private boolean bound;
private boolean constrained;
// The base name of the method name which will be prefixed with the
// read and write method. If name == "foo" then the baseName is "Foo"
private String baseName;
private String writeMethodName;
private String readMethodName;
// ......
}Constructs
/**
* Constructs a PropertyDescriptor for a property that follows
* the standard Java convention by having getFoo and setFoo
* accessor methods. Thus if the argument name is "fred", it will
* assume that the writer method is "setFred" and the reader method
* is "getFred" (or "isFred" for a boolean property). Note that the
* property name should start with a lower case character, which will
* be capitalized in the method names.
* 通过调用getFoo和setFoo存取方法，为符合标准Java约定的属性构造一个PropertyDescriptor。
* 如果参数名为"fred"，则假定writer方法为"setFred"，reader方法为"getFred"
*（对于boolean属性则为"isFred"），注意：属性名应该以小写字母开头，而方法名称中的首写字母将是大写的。
* @param propertyName The programmatic name of the property.
* @param beanClass The Class object for the target bean. For
* example sun.beans.OurButton.class.
* @exception IntrospectionException if an exception occurs during
* introspection.
*/
public PropertyDescriptor(String propertyName, Class<?> beanClass)
throws IntrospectionException {
this(propertyName, beanClass,
Introspector.IS_PREFIX + NameGenerator.capitalize(propertyName),
Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName));
}示例
@Data
@NoArgsConstructor
@AllArgsConstructor
class User {
private String name;
private Integer age;
}
public static void main(String[] args) throws Exception {
PropertyDescriptor descriptor = new PropertyDescriptor("name", User.class);
// class java.lang.String
System.out.println(descriptor.getPropertyType());
// null
System.out.println(descriptor.getPropertyEditorClass());
// public java.lang.String cn.gov.zcy.item.User.getName()
System.out.println(descriptor.getReadMethod());
// public void cn.gov.zcy.item.User.setName(java.lang.String)
System.out.println(descriptor.getWriteMethod());
}getReadMethod
- 获取读取属性值的方法。
@Data
@NoArgsConstructor
@AllArgsConstructor
class User {
private String name;
private Integer age;
}
public static void main(String[] args) throws Exception {
PropertyDescriptor descriptor = new PropertyDescriptor("name", User.class);
// public java.lang.String cn.gov.zcy.item.User.getName()
System.out.println(descriptor.getReadMethod());
}getWriteMethod
- 获取写入属性值的方法。
@Data
@NoArgsConstructor
@AllArgsConstructor
class User {
private String name;
private Integer age;
}
public static void main(String[] args) throws Exception {
Object catObj = User.class.newInstance();
//获取Name属性
PropertyDescriptor descriptor = new PropertyDescriptor("name", User.class);
//得到对应的写方法
Method method = descriptor.getWriteMethod();
//将值赋进这个类中
method.invoke(catObj,"Duansg");
User cat = (User)catObj;
// User(name=Duansg, age=null)
System.out.println(cat);
}
