我对java的理解（二）——反射是小偷的万能钥匙

　　在我们生活中，车上或者路上有时候会遇到一种很讨厌的人——“小偷”，趁我们不注意或者疏忽的时候拿走属于我们的东西。更有甚者，趁我们不在家的时候，手持一把万能钥匙，打开我们的房门，悠闲的查看房间的布置，翻找着他们需要的东西，惬意的时候也许会躺在客厅的沙发上，喝着冰箱里的饮料，俨然一副真正主人的样子。在JAVA中就有这样一个存在——“反射”，这是JDK提供的一把万能钥匙，任何人都可以使用它来获取本不应该属于自己的东西。

　　在刚学习JAVA的时候，我们就知道，JAVA提供了private，protected，public，default四种修饰符，这四种修饰符象征着我们的使用权限。就好像我们的房子，房子是我们自己的，但是可以被子孙们继承，因此，房子可以被修饰为protected。房子里有的东西是我私人的，只属于我自己，谁都不能用，这可以被修饰为private。当然有的东西，亲戚朋友来了，都可以用，可以吃，那么可以被定义为default。看门外没有垃圾桶，个人本着爱护环境的初衷，放了一个垃圾桶在外面，谁都可以用，垃圾桶自己就可以被修饰为public。但是“小偷”就是没有这种限制，管你东西是不是私人的，他仗着手上的万能钥匙就是可以把这种访问权限糟蹋掉。尤其这把钥匙还是JDK出品的，很无奈！

　　那下面就看看JDK提供的这把万能钥匙到底能干些什么吧。

　　1、创建House类，代码如下：

package person.lb.reflect;

/**
* 房子
* @author noboudns
*
*/
public class House {

//拥有者
private String owner = "nobounds";
//房间数
private int roomNum = 3;
//垃圾桶
public String dustbin = "垃圾桶";

public String getDustbin() {
return dustbin;
}

private void turnOnTV() {
System.out.println("打开电视……");
}

}

　　2、创建KeyDemo 类，代码如下：

package person.lb.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class KeyDemo {

public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException, SecurityException, NoSuchFieldException {
Class<?> clazz = Class.forName("person.lb.reflect.House");
String className = clazz.getName();
System.out.println("户主是：" + className);

Field[] fields = clazz.getDeclaredFields();
System.out.println("看看家里都有什么东西:");
for(Field field : fields ) {
System.out.println("类型：" + field.getType() + "，名称：" + field.getName() + "，使用权限:" + Modifier.toString(field.getModifiers()));
}

System.out.println("再看看家里有什么好玩的:");
Method[] methods = clazz.getDeclaredMethods();
for(Method method : methods) {
System.out.println("名字：" + method.getName()
+ "，需要的东西：" + method.getParameterTypes().toString()
+ "，得到什么：" + method.getReturnType().toString());
System.out.println("用用看效果怎么样，嘿嘿！");
//设置为可访问的
method.setAccessible(true);
method.invoke(clazz.newInstance());
}
System.out.println("心情不错，把房子据为己有吧！");
House house = (House) clazz.newInstance();
Field field = clazz.getDeclaredField("ownerName");
field.setAccessible(true);
field.set(house, "thief");
System.out.println("现在房子的主人是：" + house.getOwnerName() );
}
}

结果为：

户主是：person.lb.reflect.House
看看家里都有什么东西:
类型：class java.lang.String，名称：ownerName，使用权限:private
类型：int，名称：roomNum，使用权限:private
类型：class java.lang.String，名称：dustbin，使用权限:public
再看看家里有什么好玩的:
名字：getOwnerName，需要的东西：[Ljava.lang.Class;@3d4b7453，得到什么：class java.lang.String
用用看效果怎么样，嘿嘿！
名字：getDustbin，需要的东西：[Ljava.lang.Class;@1cc2ea3f，得到什么：class java.lang.String
用用看效果怎么样，嘿嘿！
名字：turnOnTV，需要的东西：[Ljava.lang.Class;@40a0dcd9，得到什么：void
用用看效果怎么样，嘿嘿！
打开电视……
心情不错，把房子据为己有吧！
现在房子的主人是：thief

　　当然了，JDK中不止提供了这么多功能，如果有兴趣可以自己私下去查找相关资料，本文就不多说什么了。

　　之前因为点儿事随笔写到了这里就发出去了，博友对内容有质疑，因此在这里稍微补充一下。

　　我把反射冠名为“反射是小偷的万能钥匙”，虽然听着不好听，但是像这种有特殊能力的人或事物必然有它存在的道理以及特殊性，就像盗墓贼为了私利被称为“贼”，如果被国家收编，那么也能成为一个出色的考古学家。如果专门盗取别人私密数据以及搞破坏的出色黑客弃暗投明，那么很大概率上也能成为一个优秀的安全专家。小偷擅长偷盗，但是做起反偷盗的事情来也是一把好手。在JAVA中反射就被用在很多的框架以及产品中，例如Struts1/2，hibernate，Spring，Tomcat等使用反射不仅很大程度上提高了程序的灵活性，并对框架在加载以及管理Class的时候提供了很大的便利性，以及提供在程序运行时动态更改程序的行为的能力，进而提供丰富的功能，这也更方面了我们开发者。Spring的核心功能IOC和AOP的实现也都应用了JAVA提供的反射功能。那么下面就贴上两段Spring依靠注解注入依赖的源码见识一下。

　　org.springframework.util.ReflectionUtils类（反射工具类）：

……
　　//如果类中的属性不是public修饰或者是final修饰并且属性是不可访问的，那么设置字段为可访问
　　public static void makeAccessible(Field field) {
if ((!Modifier.isPublic(field.getModifiers()) ||
!Modifier.isPublic(field.getDeclaringClass().getModifiers()) ||
Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
field.setAccessible(true);
}
}

/**
* Make the given method accessible, explicitly setting it accessible if
* necessary. The {@code setAccessible(true)} method is only called
* when actually necessary, to avoid unnecessary conflicts with a JVM
* SecurityManager (if active).
* @param method the method to make accessible
* @see java.lang.reflect.Method#setAccessible
*/
public static void makeAccessible(Method method) {
if ((!Modifier.isPublic(method.getModifiers()) ||
!Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible()) {
method.setAccessible(true);
}
}

/**
* Make the given constructor accessible, explicitly setting it accessible
* if necessary. The {@code setAccessible(true)} method is only called
* when actually necessary, to avoid unnecessary conflicts with a JVM
* SecurityManager (if active).
* @param ctor the constructor to make accessible
* @see java.lang.reflect.Constructor#setAccessible
*/
public static void makeAccessible(Constructor<?> ctor) {
if ((!Modifier.isPublic(ctor.getModifiers()) ||
!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) && !ctor.isAccessible()) {
ctor.setAccessible(true);
}
}
……

　　org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor类（@Autowired注解处理类）：

……
private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {

private final boolean required;

private volatile boolean cached = false;

private volatile Object cachedFieldValue;

public AutowiredFieldElement(Field field, boolean required) {
super(field, null);
this.required = required;
}

@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
try {
Object value;
if (this.cached) {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
TypeConverter typeConverter = beanFactory.getTypeConverter();
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
synchronized (this) {
if (!this.cached) {
if (value != null || this.required) {
this.cachedFieldValue = desc;
registerDependentBeans(beanName, autowiredBeanNames);
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName)) {
if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
this.cachedFieldValue = new RuntimeBeanReference(autowiredBeanName);
}
}
}
}
else {
this.cachedFieldValue = null;
}
this.cached = true;
}
}
}
if (value != null) {
//设置字段访问权限为可访问
ReflectionUtils.makeAccessible(field);
//对字段进行赋值
field.set(bean, value);
}
}
catch (Throwable ex) {
throw new BeanCreationException("Could not autowire field: " + field, ex);
}
}
}
……