@chenxuxiong 2016-05-28T06:44:32.000000Z 字数 4202 阅读 799

Java反射，反射性能提高

未分类

1.Java反射机制定义：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

java.lang.Class;
java.lang.reflect.Constructor;
java.lang.reflect.Field;
java.lang.reflect.Method;
java.lang.reflect.Modifier;

2.获得一个类的类对象有哪些方式？

方法1：类型.class，例如：String.class
方法2：对象.getClass()，例如："hello".getClass()
方法3：Class.forName()，例如：Class.forName("java.lang.String")

3.如何通过反射创建对象？

方法1：通过类对象调用newInstance()方法，例如：String.class.newInstance()
方法2：通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器（Constructor）对象并调用其newInstance()方法创建对象，例如：String.class.getConstructor(String.class).newInstance("Hello");

4.如何通过反射获取和设置对象私有字段的值？

答：可以通过类对象的getDeclaredField()方法得到字段（Field）对象，然后再通过字段对象的setAccessible(true)将其设置为可以访问，接下来就可以通过get/set方法来获取/设置字段的值了。

5.哪里用到反射机制？

jdbc中有一行代码：Class.forName('com.mysql.jdbc.Driver.class').newInstance();那个时候只知道生成驱动对象实例，后来才知道，这就是反射，现在

很多框架都用到反射机制，hibernate，struts都是用反射机制实现的。
拦截器是基于 java 反射机制的

6.反射机制的优缺点？

但反射有两个缺点。
第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

7.如何通过反射调用对象的方法？

答：先获取类对象getClass()，再通过方法名获取所要方法getMethod("xxx")，最后根据所得方法用invoke(参数)方法执行。

import java.lang.reflect.Method;
class MethodInvokeTest {
    public static void main(String[] args) throws Exception {
        String str = "hello";
        Method m = str.getClass().getMethod("toUpperCase");
        System.out.println(m.invoke(str));  // HELLO
    }
}

8.原理

Class.forName(classname)方法,实际上是调用了Class类中的 Class.forName(classname, true, currentLoader)方法。参数：name - 所需类的完全限定名；initialize - 是否必须初始化类；loader - 用于加载类的类加载器。currentLoader则是通过调用ClassLoader.getCallerClassLoader()获取当前类加载器的。类要想使用，必须用类加载器加载，所以需要加载器。反射机制，不是每次都去重新反射，而是提供了cache，每次都会需要类加载器去自己的cache中查找，如果可以查到，则直接返回该类。

9.如何提高性能？

1.在系统启动阶段使用反射。
2.尽量不要getMethods()后再遍历筛选，而直接用getMethod(methodName)来根据方法名获取方法
3.缓存：比如，需要多次动态创建一个类的实例的时候，有缓存的写法会比没有缓存要快很多，需要注意线程安全问题
4.将反射得到元数据保存起来，使用时，只需从内存中调用即可。
5.hotspot虚拟机会对执行次数较多的方法进行优化（例如使用jit技术）。
6.使用高性能的反射库，应该会比自己写缓存效果好

import java.lang.reflect.Array;     
import java.lang.reflect.Constructor;     
import java.lang.reflect.Field;     
import java.lang.reflect.Method;     
/**   
 * Java Reflection Cookbook   
 *   
 * @author Michael Lee   
 * @since 2006-8-23   
 * @version 0.1a   
 */    
public class Reflection {     
    /**   
     * 得到某个对象的公共属性   
     *   
     * @param owner, fieldName   
     * @return 该属性对象   
     * @throws Exception   
     *   
     */    
    public Object getProperty(Object owner, String fieldName) throws Exception {     
        Class ownerClass = owner.getClass();     
        Field field = ownerClass.getField(fieldName);     
        Object property = field.get(owner);     
        return property;     
    }     
    /**   
     * 得到某类的静态公共属性   
     *   
     * @param className   类名   
     * @param fieldName   属性名   
     * @return 该属性对象   
     * @throws Exception   
     */    
    public Object getStaticProperty(String className, String fieldName)     
            throws Exception {     
        Class ownerClass = Class.forName(className);     
        Field field = ownerClass.getField(fieldName);     
        Object property = field.get(ownerClass);     
        return property;     
    }     
    /**   
     * 执行某对象方法   
     *   
     * @param owner   
     *            对象   
     * @param methodName   
     *            方法名   
     * @param args   
     *            参数   
     * @return 方法返回值   
     * @throws Exception   
     */    
    public Object invokeMethod(Object owner, String methodName, Object[] args)     
            throws Exception {     
        Class ownerClass = owner.getClass();     
        Class[] argsClass = new Class[args.length];     
        for (int i = 0, j = args.length; i < j; i++) {     
            argsClass[i] = args[i].getClass();     
        }     
        Method method = ownerClass.getMethod(methodName, argsClass);     
        return method.invoke(owner, args);     
    }     
      /**   
     * 执行某类的静态方法   
     *   
     * @param className   
     *            类名   
     * @param methodName   
     *            方法名   
     * @param args   
     *            参数数组   
     * @return 执行方法返回的结果   
     * @throws Exception   
     */    
    public Object invokeStaticMethod(String className, String methodName,     
            Object[] args) throws Exception {     
        Class ownerClass = Class.forName(className);     
        Class[] argsClass = new Class[args.length];     
        for (int i = 0, j = args.length; i < j; i++) {     
            argsClass[i] = args[i].getClass();     
        }     
        Method method = ownerClass.getMethod(methodName, argsClass);     
        return method.invoke(null, args);     
    }     
    /**   
     * 新建实例   
     *   
     * @param className   
     *            类名   
     * @param args   
     *            构造函数的参数   
     * @return 新建的实例   
     * @throws Exception   
     */    
    public Object newInstance(String className, Object[] args) throws Exception {     
        Class newoneClass = Class.forName(className);     
        Class[] argsClass = new Class[args.length];     
        for (int i = 0, j = args.length; i < j; i++) {     
            argsClass[i] = args[i].getClass();     
        }     
        Constructor cons = newoneClass.getConstructor(argsClass);     
        return cons.newInstance(args);     
    }     
    /**   
     * 是不是某个类的实例   
     * @param obj 实例   
     * @param cls 类   
     * @return 如果 obj 是此类的实例，则返回 true   
     */    
    public boolean isInstance(Object obj, Class cls) {     
        return cls.isInstance(obj);     
    }     
    /**   
     * 得到数组中的某个元素   
     * @param array 数组   
     * @param index 索引   
     * @return 返回指定数组对象中索引组件的值   
     */    
    public Object getByArray(Object array, int index) {     
        return Array.get(array,index);     
    }     
}