【20200606】理解Java反射的正确姿势

反射简介

反射是Java的高级特性之一，但是在实际的开发中，使用Java反射的案例却非常的少，但是反射确实在底层框架中被频繁的使用。
比如：JDBC中的加载数据库驱动程序，Spring框架中加载bean对象，动以及态代理，这些都使用到反射，因为我们要想理解一些框架的底层原理，反射是我们必须要掌握的。
理解反射我们先从他的概念入手，那么什么是反射呢？
反射就是在运行状态能够动态的获取该类的属性和方法，并且能够任意的使用该类的属性和方法，这种动态获取类信息以及动态的调用对象的方法的功能就是反射。
实现上面操作的前提是能够获取到该类的字节码对象，也就是.class文件，在反射中获取class文件的方式有三种：

1. 类名.class 如：Person.class
2. 对象.getClass 如：person.getClass

3. Class.forName(全类名)获取 如：Class.forName(“ldc.org. demo.person”)

   Class对象

   对于反射的执行过程的原理，我这里画了一张图，以供大家参考理解。 我们看过JVM的相关书籍都会详细的了解到，Java文件首先要通过编译器编译，编译成Class文件，然后通过类加载器(ClassLoader)将class文件加载到JVM中。
   在JVM中Class文件都与一个Class对象对应，在因为Class对象中包含着该类的类信息，只要获取到Class对象便可以操作该类对象的属性与方法。
   在这里深入理解反射之前先来深入的理解Class对象，它包含了类的相关信息。
   Java中我们在运行时识别对象和类的信息，也叫做RTTI，方式主要有来两种：

4. 传统的RTTI（Run-Time Type Information）

5. 反射机制

那么什么是RTTI呢？RTTI称为运行时类型识别，传统的RTTI是在编译时就已经知道所有类型；而反射机制则是在程序运行时才确定的类型信息。
想要运行时使用类型信息，就必须要获取Class对象的引用，获取Class对象的方式上面已经提及。
这里有点区别的就是使用(.class)方式获取Class对象，并不会初始化Class对象，而使用(forName(“全类名”))的方式会自动初始化Class对象。
当一个.class文件要被加载到JVM中的时候，会进行如下的准备工作，首先会检查这个类是否被加载，若是没有被加载就会根据全类名找到class文件，接着加载Class文件，并创建类的静态成员引用。
但是在程序中并非是一开始就完全加载该类的class文件，而是在程序用的地方再加载，即为懒加载模式。
当加载完Class文件后，接着就会验证Class文件中的字节码，并静态域分配存储空间。这个过程也叫做链接。
最后一步就是进行初始化，即为了使用类而提前做的准备工作如下图所示：

反射

反射对应到Java中的类库就是在java.lang.reflect下， 在该包下包含着Field、Method和Constructor类。
Field是表示一个类的属性信息，Method表示类的方法信息，Constructor表示的是类的构造方法的信息。
在反射中常用的方法，我这里做了一个列举，当然更加详细的可以查官方的API文档进行学习。

另外对于反射的使用这里附上一段小demo，具体的实际应用，会在后面继续说到，并且也会附上代码的实现：
` public class User{ private String name; private Integer age;

public User() {
}
public User(String name, Integer age) {
    this.name = name;
    this.age = age;
}
 private void privateMethod(){
    System.err.println("privateMethod");
}
public void publicMethod(String param){
    System.err.println("publicMethod"+param);
}
@Override
public String toString() {
    return "User{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}
复制代码

复制代码<br />} 复制代码<br />在User的实体类中，有两个属性age和name，并且除了有两个测试方法privateMethod和publicMethod用于测试私有方法和公共方法的获取。接着执行如下代码：<br />Class clazz=User.class;`
//获取有参构造
Constructor constructor = clazz.getConstructor(String.class, Integer.class);
//获取该类对象并设置属性的值
Object obj = constructor.newInstance(“黎杜”, 18);

String fullClassName = clazz.getName();
String className = clazz.getSimpleName();
Field[] fields = clazz.getFields();
String fieldName=””;
for(Field field : fields){
// 获取属性名
fieldName=field.getName();
System.out.println(fieldName)
}
Field[] fieldsAll = clazz.getDeclaredFields();
fieldName=””;
for(Field field : fieldsAll){
// 获取属性名
fieldName=field.getName();
System.out.println(fieldName)
}
Field age = clazz.getField(“age”);
Object value = age.get(obj);
System.err.println(“公共指定属性： “+value);
Field name = clazz.getDeclaredField(“name”);
//设置为true才能获取私有属性
name.setAccessible(true);
Object value2= name.get(obj);
System.err.println(“私有指定属性值： “+value2);
Method[] methods = clazz.getMethods();
String methodsName=””;
for(Method method : methods){
methodsName=method.getName();
}
Method[] methodsAll = clazz.getDeclaredMethods();
methodsName=””;
for(Method method : methodsAll){
methodsName=method.getName();
}
Method privateMethod= clazz.getDeclaredMethod(“privateMethod”);//获取无参私有方法
privateMethod.setAccessible(true);
privateMethod.invoke(obj);//调用方法
复制代码
Method publicMethod= clazz.getMethod("publicMethod",String.class);//获取有参数方法 publicMethod.invoke(obj,"黎杜");//调用有参方法 复制代码
看完上面的demo以后，有些人会说，老哥这只是一个很简单的demo，确实是，这里为了照顾一下一些新手，先熟悉一下反射的一些方法的用法，好戏还在后头。
反射在jdk 1.5的时候允许对Class对象能够支持泛型，也称为泛化Class，具体的使用如下：
Class<User> user= User.class;
//泛化class可以直接得到具体的对象，而不再是Object
Useruser= user.newInstance();
复制代码
泛化实现了在获取实例的时候直接就可以获取到具体的对象，因为在编译器的时候就会做类型检查。当然也可以使用通配符的方式，例如：Class<?>

反射实际应用

经过上面的反射的原理介绍，下面就要开始反射的实际场景的应用，所有的技术，你知道的该技术的应用场景永远是最值钱。这个是越多越好，知道的场景越多思路就越多。
反射的实际场景的应用，这里主要列举这几个方面：

1. 动态代理
2. JDBC 的数据库的连接
3. Spring 框架的使用

动态代理实际就是使用反射的技术来实现，在程序运行时创建一个代理类，用来代理给定的接口，实现动态处理对其所代理的方法的调用。
实现动态代理主要有以下几个步骤：

1. 实现InvocationHandler接口，重写invoke方法，实现被代理对象的方法调用的逻辑。
2. Proxy.getProxyClass获取代理类
3. 执行方法，代理成功

动态代理的实现代码如下所示，首先创建自己类DynamicProxyHandler实现 InvocationHandler ：
`public class DynamicProxyHandler implements InvocationHandler { private Object targetObj;

public DynamicProxyHandler() {
    super();
}
public DynamicProxyHandler(Object targetObj) {
    super();
    this.targetObj= targetObj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.err.println("开始执行targetObj的方法");
    //执行被代理的targetObj的方法
    method.invoke(targetObj, args);
    System.out.println("执行方法结束");
   return null;
}
复制代码

复制代码<br />} 复制代码<br />然后执行Proxy.newProxyInstance方法创建代理对象，最后执行代理对象的方法，代码实现如下：<br />User user = new UserImpl();<br />DynamicProxyHandler dynamicProxy = new DynamicProxyHandler(user);<br />//第一个参数：类加载器；第二个参数：user.getClass().getInterfaces()：被代理对象的接口；第三个参数：代理对象<br />User userProxy = (User ) Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(), dynamicProxy);<br />userProxy.login();<br />userProxy.logout();<br />复制代码<br />以上的实现是jdk的动态代理方式，还有一种动态代理是Cglib的动态代理方式，Cglib动态代理也是被广泛的使用，比如Spring AOP框架中，**实现了方法的拦截功能**。<br />在ORM框架Hibernate框架也是使用Cglib框架来代理单端single-ended的关联关系。<br />jdk的动态代理与Cglib的动态代理的区别在于**jdk动态代理必须实现接口，而Cglib的动态代理是对那些没有实现接口的类**，实习那的原理通通过继承称为子类，并覆盖父类中的一些方法。<br />对于Cglib的动态代理这里由于篇幅的原因不再做详细讲解，下一篇将会详细的讲解jdk的动态代理和Cglib的动态代理的实现。<br />下面我们来看看JDBC中反射的应用案例，在JDBC中使用Class.forName()方法来加载数据库驱动，就是使用反射的案例。<br />让我们来一波入门的时候写的代码，一波回忆杀历历在目，具体的实现代码我相信也是很多人在初学者的时候也写过，如下所示：<br /> Class.forName(“com.mysql.jdbc.Driver”); //1、使用CLASS 类加载驱动程序 ,反射机制的体现 <br /> con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test","root","root"); //2、连接数据库 <br />复制代码<br />最后一个案例实现是使用反射模拟Spring通过xml文件初始化Bean的过程，学过ssm的项目都会依稀的记得Spring的配置文件，比如：<br /><br /> <property name="jdbcUrl" value="${jdbc.url}"></property><br /> <property name="driverClass" value="${jdbc.driverName}"></property><br /> <property name="user" value="${jdbc.username}"></property><br /> <property name="password" value="${jdbc.pwd}"></property><br /></bean><br />复制代码<br />上面的配置文件非常的熟悉，在标签里面有属性，属性有属性值，以及标签还有子标签，子标签也有属性和属性值，那么怎么用他们初始化成Bean呢？<br />思路可以是这样的，首先得得到配置文件的位置，然后加载配置文件，加载配置文件后就可以解析具体的标签，获取到属性和属性值，通过属性值初始化Bean。<br />实现的代码如下，首先加载配置文件的内容，并获取到配置文件的根节点：<br />SAXReader reader = new SAXReader();<br />ClassLoader classLoader = Thread.currentThread().getContextClassLoader();<br />InputStream is= classLoader.getResourceAsStream(beanXml);<br />Document doc = reader.read(is);<br />Element root = doc.getRootElement(); <br />复制代码<br />拿到根节点后，然后可以获取bean标签中的属性和属性值，当拿到属性class属性值后就可以通过反射初始化Bean对象。<br />for (Iterator i = root.elementIterator(“bean”); i.hasNext();) { <br /> Element foo = (Element) i.next();<br /> //获取Bean中的属性值<br /> Attribute idValue = foo.attribute("id"); <br /> Attribute clazzValue = foo.attribute("class");<br /> //通过反射获取Class对象<br /> Class bean = Class.forName(clazzValue.getText());<br /> //并实例化Bean对象<br /> Object obj = bean.newInstance();<br /> }<br />复制代码<br />除了初始化对象你还可以为Bean对象赋予初始值，例如上面的bean标签下还有property标签，以及它的属性值value：<br /><br /><property name="driverClass" value="${jdbc.driverName}"></property><br /><property name="user" value="${jdbc.username}"></property><br /><property name="password" value="${jdbc.pwd}"></property><br />复制代码<br />我们就可以通过一下代码来初始化这些值：<br />BeanInfo beanInfo = Introspector.getBeanInfo(bean);`
// bean对象的属性信息
PropertyDescriptor propertyDescriptor[] = beanInfo .getPropertyDescriptors();
for (Iterator ite = foo.elementIterator(“property”); ite.hasNext();) {
Element property= (Element) ite.next();
Attribute name = property.attribute(“name”);
Attribute value = property.attribute(“value”);
for (int i= 0; k < propertyDescriptor.length; i++) {
if (propertyDescriptor[i].getName().equalsIgnoreCase(name.getText())) {
Method method= propertyDescriptor[i].getWriteMethod();
//使用反射将值设置进去
method.invoke(obj, value.getText());
}
}
复制代码
以上就是简单的三个反射的应用案例，也是比较简单，大佬不喜勿喷哈，初学者就当是自己学多一点知识，总之一点一点进步。

反射优点和缺点

优点：反射可以动态的获取对象，调用对象的方法和属性，并不是写死的，比较灵活，比如你要实例化一个bean对象，你可能会使用new User()写死在代码中。
但是使用反射就可以使用class.forName(user).newInstance()，而变量名user可以写在xml配置文件中，这样就不用修改源代码，灵活、可配置。
缺点：反射的性能问题一直是被吐槽的地方，反射是一种解释操作，用于属性字段和方法的接入时要远远慢于直接使用代码，因此普通程序也很少使用反射。

作者：公众号非科班的科班
链接：https://juejin.im/post/5edaf38d6fb9a0479d26b767
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。