Java类加载机制详解

比眉伴天荒 2022-06-08 09:27 181阅读 0赞

# 一、类加载器 #

类加载器（ClassLoader），顾名思义，即加载类的东西。在我们使用一个类之前，JVM需要先将该类的字节码文件（.class文件）从磁盘、网络或其他来源加载到内存中，并对字节码进行解析生成对应的Class对象，这就是类加载器的功能。我们可以利用类加载器，实现类的动态加载。

# 二、类的加载机制 #

在Java中，采用双亲委派机制来实现类的加载。那什么是双亲委派机制？在Java Doc中有这样一段描述：

> The ClassLoader class uses a delegation model to search for classes and resources. Each instance of ClassLoader has an associated parent class loader. When requested to find a class or resource, a ClassLoader instance will delegate the search for the class or resource to its parent class loader before attempting to find the class or resource itself. The virtual machine’s built-in class loader, called the “bootstrap class loader”, does not itself have a parent but may serve as the parent of a ClassLoader instance.

从以上描述中，我们可以总结出如下四点：   
1、类的加载过程采用委托模式实现   
2、每个 ClassLoader 都有一个父加载器。   
3、类加载器在加载类之前会先递归的去尝试使用父加载器加载。   
4、虚拟机有一个内建的启动类加载器（Bootstrap ClassLoader），该加载器没有父加载器，但是可以作为其他加载器的父加载器。   
Java 提供三种类型的系统类加载器。第一种是启动类加载器，由C++语言实现，属于JVM的一部分，其作用是加载 /lib 目录中的文件，并且该类加载器只加载特定名称的文件（如 rt.jar），而不是该目录下所有的文件。另外两种是 Java 语言自身实现的类加载器，包括扩展类加载器（ExtClassLoader）和应用类加载器（AppClassLoader），扩展类加载器负责加载\\lib\\ext目录中或系统变量 java.ext.dirs 所指定的目录中的文件。应用程序类加载器负责加载用户类路径中的文件。用户可以直接使用扩展类加载器或系统类加载器来加载自己的类，但是用户无法直接使用启动类加载器，除了这两种类加载器以外，用户也可以自定义类加载器，加载流程如下图所示：   
![1240][]  
注意：这里父类加载器并不是通过继承关系来实现的，而是采用组合实现的。   
我们可以通过一段程序来验证这个过程：

/** * Java学习交流QQ群：589809992 我们一起学Java！ */
    public class Test { 
    }
    
    public class TestMain { 
        public static void main(String[] args) {
    
            ClassLoader loader = Test.class.getClassLoader();
            while (loader!=null){
                System.out.println(loader);
                loader = loader.getParent();
            }
        }
    }

上面程序的运行结果如下所示:

![1240 1][]

从结果我们可以看出，默认情况下，用户自定义的类使用 AppClassLoader 加载，AppClassLoader 的父加载器为 ExtClassLoader，但是 ExtClassLoader 的父加载器却显示为空，这是什么原因呢？究其缘由，启动类加载器属于 JVM 的一部分，它不是由 Java 语言实现的，在 Java 中无法直接引用，所以才返回空。但如果是这样，该怎么实现 ExtClassLoader 与 启动类加载器之间双亲委派机制？我们可以参考一下源码：

protected Class<?> loadClass(String name, boolean resolve)
           throws ClassNotFoundException
       {
           synchronized (getClassLoadingLock(name)) {
               // First, check if the class has already been loaded
               Class<?> c = findLoadedClass(name);
               if (c == null) {
                   long t0 = System.nanoTime();
                   try {
                       if (parent != null) {
                           c = parent.loadClass(name, false);
                       } else {
                           c = findBootstrapClassOrNull(name);
                       }
                   } catch (ClassNotFoundException e) {
                       // ClassNotFoundException thrown if class not found
                       // from the non-null parent class loader
                   }
    
                   if (c == null) {
                       // If still not found, then invoke findClass in order
                       // to find the class.
                       long t1 = System.nanoTime();
                       c = findClass(name);
    
                       // this is the defining class loader; record the stats
                       sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                       sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                       sun.misc.PerfCounter.getFindClasses().increment();
                   }
               }
               if (resolve) {
                   resolveClass(c);
               }
               return c;
           }
       }

从源码可以看出，ExtClassLoader 和 AppClassLoader都继承自 ClassLoader 类，ClassLoader 类中通过 loadClass 方法来实现双亲委派机制。整个类的加载过程可分为如下三步：

> 1、查找对应的类是否已经加载。   
> 2、若未加载，则判断当前类加载器的父加载器是否为空，不为空则委托给父类去加载，否则调用启动类加载器加载（findBootstrapClassOrNull 再往下会调用一个 native 方法）。   
> 3、若第二步加载失败，则调用当前类加载器加载。

通过上面这段程序，可以很清楚的看出扩展类加载器与启动类加载器之间是如何实现委托模式的。

现在，我们再验证另一个问题。我们将刚才的Test类打成jar包，将其放置在 \\lib\\ext 目录下，然后再次运行上面的代码，结果如下：

![1240 2][]

现在，该类就不再通过 AppClassLoader 来加载，而是通过 ExtClassLoader 来加载了。如果我们试图把jar包拷贝到\\lib，尝试通过启动类加载器加载该类时，我们会发现编译器无法识别该类，因为启动类加载器除了指定目录外，还必须是特定名称的文件才能加载。

# 三、自定义类加载器 #

通常情况下，我们都是直接使用系统类加载器。但是，有的时候，我们也需要自定义类加载器。比如应用是通过网络来传输 Java 类的字节码，为保证安全性，这些字节码经过了加密处理，这时系统类加载器就无法对其进行加载，这样则需要自定义类加载器来实现。自定义类加载器一般都是继承自 ClassLoader 类，从上面对 loadClass 方法来分析来看，我们只需要重写 findClass 方法即可。下面我们通过一个示例来演示自定义类加载器的流程：

package com.paddx.test.classloading;
    
    import java.io.*;
    
    /** * Created by liuxp on 16/3/12. */
    public class MyClassLoader extends ClassLoader { 
    
        private String root;
    
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            byte[] classData = loadClassData(name);
            if (classData == null) {
                throw new ClassNotFoundException();
            } else {
                return defineClass(name, classData, 0, classData.length);
            }
        }
    
        private byte[] loadClassData(String className) {
            String fileName = root + File.separatorChar
                    + className.replace('.', File.separatorChar) + ".class";
            try {
                InputStream ins = new FileInputStream(fileName);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                int bufferSize = 1024;
                byte[] buffer = new byte[bufferSize];
                int length = 0;
                while ((length = ins.read(buffer)) != -1) {
                    baos.write(buffer, 0, length);
                }
                return baos.toByteArray();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public String getRoot() {
            return root;
        }
    
        public void setRoot(String root) {
            this.root = root;
        }
    
        public static void main(String[] args)  {
    
            MyClassLoader classLoader = new MyClassLoader();
            classLoader.setRoot("/Users/liuxp/tmp");
    
            Class<?> testClass = null;
            try {
                testClass = classLoader.loadClass("com.paddx.test.classloading.Test");
                Object object = testClass.newInstance();
                System.out.println(object.getClass().getClassLoader());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

运行上面的程序，输出结果如下：

![1240 3][]

自定义类加载器的核心在于对字节码文件的获取，如果是加密的字节码则需要在该类中对文件进行解密。由于这里只是演示，我并未对class文件进行加密，因此没有解密的过程。这里有几点需要注意：

> 1、这里传递的文件名需要是类的全限定性名称，即com.paddx.test.classloading.Test格式的，因为 defineClass 方法是按这种格式进行处理的。   
> 2、最好不要重写loadClass方法，因为这样容易破坏双亲委托模式。   
> 3、这类 Test 类本身可以被 AppClassLoader 类加载，因此我们不能把 com/paddx/test/classloading/Test.class 放在类路径下。否则，由于双亲委托机制的存在，会直接导致该类由 AppClassLoader 加载，而不会通过我们自定义类加载器来加载。

# 四、总结 #

双亲委派机制能很好地解决类加载的统一性问题。对一个 Class 对象来说，如果类加载器不同，即便是同一个字节码文件，生成的 Class 对象也是不等的。也就是说，类加载器相当于 Class 对象的一个命名空间。双亲委派机制则保证了基类都由相同的类加载器加载，这样就避免了同一个字节码文件被多次加载生成不同的 Class 对象的问题。但双亲委派机制仅仅是Java 规范所推荐的一种实现方式，它并不是强制性的要求。近年来，很多热部署的技术都已不遵循这一规则，如 OSGi 技术就采用了一种网状的结构，而非双亲委派机制。

=================================================================

http://geek.csdn.net/news/detail/237509

# 动态语言 #

动态语言，是指程序在运行时可以改变其结构：新的函数可以被引进，已有的函数可以被删除等在结构上的变化。比如众所周知的ECMAScript(JavaScript)便是一个动态语言。除此之外如Ruby、Python等也都属于动态语言，而C、C++等语言则不属于动态语言。(引自: 百度百科)

var execString = "alert(Math.floor(Math.random()*10));";
    eval(execString);

# Class 反射机制 #

*  指的是可以于运行时加载,探知和使用编译期间完全未知的类.
 *  程序在运行状态中, 可以动态加载一个只有名称的类, 对于任意一个已经加载的类,都能够知道这个类的所有属性和方法; 对于任意一个对象,都能调用他的任意一个方法和属性;
 *  加载完类之后, 在堆内存中会产生一个Class   
    类型的对象(一个类只有一个Class对象), 这个对象包含了完整的类的结构信息,而且这个Class对象就像一面镜子,透过这个镜子看到类的结构,所以被称之为:反射。

Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions(维度). The primitive Java types (boolean, byte, char, short, int, long, float, anddouble), and the keyword void are also represented as Class objects.   
\- 每个类被加载进入内存之后,系统就会为该类生成一个对应的java.lang.Class   
对象,通过该Class   
对象就可以访问到JVM中的这个类.

Class对象的获取   
\- 对象的getClass()方法;   
\- 类的.class(最安全/性能最好)属性;   
\- 运用Class.forName(String className)动态加载类,className需要是类的全限定名(最常用).

从Class中获取信息

Class类提供了大量的实例方法来获取该Class对象所对应的详细信息,Class类大致包含如下方法,其中每个方法都包含多个重载版本,因此我们只是做简单的介绍,详细请参考[JDK文档][JDK]

获取类内信息

![1240 4][]

一些判断类本身信息的方法

![1240 5][]

使用反射生成并操作对象:

Method Constructor Field这些类都实现了java.lang.reflect.Member接口,程序可以通过Method对象来执行相应的方法,通过Constructor对象来调用对应的构造器创建实例,通过Filed对象直接访问和修改对象的成员变量值.

# 创建对象 #

通过反射来生成对象的方式有两种:   
\- 使用Class对象的newInstance()方法来创建该Class对象对应类的实例(这种方式要求该Class对象的对应类有默认构造器).   
\- 先使用Class对象获取指定的Constructor对象, 再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例(通过这种方式可以选择指定的构造器来创建实例).

通过第一种方式来创建对象比较常见, 像Spring这种框架都需要根据配置文件(如applicationContext.xml)信息来创建Java对象,从配置文件中读取的只是某个类的全限定名字符串,程序需要根据该字符串来创建对应的实例,就必须使用默认的构造器来反射对象.下面我们就模拟Spring实现一个简单的对象池, 该对象池会根据文件读取key-value对, 然后创建这些对象, 并放入Map中.

配置文件

{
      "objects": [ { "id": "id1", "class": "com.fq.domain.User" }, { "id": "id2", "class": "com.fq.domain.Bean" } ] }

ObjectPool

/** * Created by jifang on 15/12/31. */
    public class ObjectPool { 
    
        private Map<String, Object> pool;
    
        private ObjectPool(Map<String, Object> pool) {
            this.pool = pool;
        }
    
        private static Object getInstance(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            return Class.forName(className).newInstance();
        }
    
        private static JSONArray getObjects(String config) throws IOException {
            Reader reader = new InputStreamReader(ClassLoader.getSystemResourceAsStream(config));
            return JSONObject.parseObject(CharStreams.toString(reader)).getJSONArray("objects");
        }
    
        // 根据指定的JSON配置文件来初始化对象池
        public static ObjectPool init(String config) {
            try {
                JSONArray objects = getObjects(config);
                ObjectPool pool = new ObjectPool(new HashMap<String, Object>());
                if (objects != null && objects.size() != 0) {
                    for (int i = 0; i < objects.size(); ++i) {
                        JSONObject object = objects.getJSONObject(i);
                        if (object == null || object.size() == 0) {
                            continue;
                        }
                        String id = object.getString("id");
                        String className = object.getString("class");
    
                        pool.putObject(id, getInstance(className));
                    }
                }
                return pool;
            } catch (IOException | ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
    
        public Object getObject(String id) {
            return pool.get(id);
        }
    
        public void putObject(String id, Object object) {
            pool.put(id, object);
        }
    
        public void clear() {
            pool.clear();
        }
    }

Client

/** * Java学习交流QQ群：589809992 我们一起学Java！ */
    public class Client { 
    
        @Test
        public void client() {
            ObjectPool pool = ObjectPool.init("config.json");
            User user = (User) pool.getObject("id1");
            System.out.println(user);
    
            Bean bean = (Bean) pool.getObject("id2");
            System.out.println(bean);
        }
    }

User

public class User {
    
        private int id;
        private String name;
        private String password;
    
        public int getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '/'' + ", password='" + password + '/'' + '}'; } }

Bean

public class Bean {
        private Boolean usefull;
        private BigDecimal rate;
        private String name;
    
        public Boolean getUsefull() {
            return usefull;
        }
    
        public void setUsefull(Boolean usefull) {
            this.usefull = usefull;
        }
    
        public BigDecimal getRate() {
            return rate;
        }
    
        public void setRate(BigDecimal rate) {
            this.rate = rate;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Bean{" +
                    "usefull=" + usefull +
                    ", rate=" + rate +
                    ", name='" + name + '/'' + '}'; } }

注意: 需要在pom.xml中添加如下依赖:

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.7</version>
    </dependency>
    
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>18.0</version>
    </dependency>

调用方法

当获取到某个类对应的Class对象之后, 就可以通过该Class对象getMethod来获取一个Method数组或Method对象.每个Method对象对应一个方法,在获得Method对象之后,就可以通过调用invoke方法来调用该Method对象对应的方法.

@CallerSensitive
    public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        ...
    }

下面我们对上面的对象池加强:可以看到Client获取到的对象的成员变量全都是默认值,既然我们已经使用了JSON这么优秀的工具,我们又学习了动态调用对象的方法,那么我们就通过配置文件来给对象设置值(在对象创建时), 新的配置文件形式如下:

{
      "objects": [ { "id": "id1", "class": "com.fq.domain.User", "fields": [ { "name": "id", "value": 101 }, { "name": "name", "value": "feiqing" }, { "name": "password", "value": "ICy5YqxZB1uWSwcVLSNLcA==" } ] }, { "id": "id2", "class": "com.fq.domain.Bean", "fields": [ { "name": "usefull", "value": true }, { "name": "rate", "value": 3.14 }, { "name": "name", "value": "bean-name" } ] }, { "id": "id3", "class": "com.fq.domain.ComplexBean", "fields": [ { "name": "name", "value": "complex-bean-name" }, { "name": "refBean", "ref": "id2" } ] } ] }

其中fields代表该Bean所包含的属性, name为属性名称, value为属性值(属性类型为JSON支持的类型), ref代表引用一个对象(也就是属性类型为Object,但是一定要引用一个已经存在了的对象)

/** * @author jifang * @since 15/12/31下午4:00 */
    public class ObjectPool { 
    
        private Map<String, Object> pool;
    
        private ObjectPool(Map<String, Object> pool) {
            this.pool = pool;
        }
    
        private static JSONArray getObjects(String config) throws IOException {
            Reader reader = new InputStreamReader(ClassLoader.getSystemResourceAsStream(config));
            return JSONObject.parseObject(CharStreams.toString(reader)).getJSONArray("objects");
        }
    
        private static Object getInstance(String className, JSONArray fields)
                throws ClassNotFoundException, NoSuchMethodException,
                IllegalAccessException, InstantiationException, InvocationTargetException {
    
            // 配置的Class
            Class<?> clazz = Class.forName(className);
            // 目标Class的实例对象
            Object targetObject = clazz.newInstance();
            if (fields != null && fields.size() != 0) {
                for (int i = 0; i < fields.size(); ++i) {
                    JSONObject field = fields.getJSONObject(i);
                    // 需要设置的成员变量名
                    String fieldName = field.getString("name");
    
                    // 需要设置的成员变量的值
                    Object fieldValue;
                    if (field.containsKey("value")) {
                        fieldValue = field.get("value");
                    } else if (field.containsKey("ref")) {
                        String refBeanId = field.getString("ref");
                        fieldValue = OBJECTPOOL.getObject(refBeanId);
                    } else {
                        throw new RuntimeException("neither value nor ref");
                    }
    
                    String setterName = "set" +
                            fieldName.substring(0, 1).toUpperCase() +
                            fieldName.substring(1);
                    // 需要设置的成员变量的setter方法
                    Method setterMethod = clazz.getMethod(setterName, fieldValue.getClass());
                    // 调用setter方法将值设置进去
                    setterMethod.invoke(targetObject, fieldValue);
                }
            }
    
            return targetObject;
        }
    
        private static ObjectPool OBJECTPOOL;
    
        // 创建一个对象池的实例(保证是多线程安全的)
        private static void initSingletonPool() {
            if (OBJECTPOOL == null) {
                synchronized (ObjectPool.class) {
                    if (OBJECTPOOL == null) {
                        OBJECTPOOL = new ObjectPool(new ConcurrentHashMap<String, Object>());
                    }
                }
            }
        }
    
        // 根据指定的JSON配置文件来初始化对象池
        public static ObjectPool init(String config) {
            // 初始化pool
            initSingletonPool();
    
            try {
                JSONArray objects = getObjects(config);
                for (int i = 0; objects != null && i < objects.size(); ++i) {
                    JSONObject object = objects.getJSONObject(i);
                    if (object == null || object.size() == 0) {
                        continue;
                    }
                    String id = object.getString("id");
                    String className = object.getString("class");
    
                    // 初始化bean并放入池中
                    OBJECTPOOL.putObject(id, getInstance(className, object.getJSONArray("fields")));
                }
                return OBJECTPOOL;
            } catch (IOException | ClassNotFoundException |
                    InstantiationException | IllegalAccessException |
                    NoSuchMethodException | InvocationTargetException e) {
                throw new RuntimeException(e);
            }
        }
    
        public Object getObject(String id) {
            return pool.get(id);
        }
    
        public void putObject(String id, Object object) {
            pool.put(id, object);
        }
    
        public void clear() {
            pool.clear();
        }
    }

Client

ComplexBean

public class ComplexBean {
    
        private String name;
    
        private Bean refBean;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Bean getRefBean() {
            return refBean;
        }
    
        public void setRefBean(Bean refBean) {
            this.refBean = refBean;
        }
    
        @Override
        public String toString() {
            return "ComplexBean{" +
                    "name='" + name + '/'' + ", refBean=" + refBean + '}'; } }

Spring框架就是通过这种方式将成员变量值以及依赖对象等都放在配置文件中进行管理的,从而实现了较好地解耦(不过Spring是通过XML作为配置文件).

# 访问成员变量 #

通过Class对象的的getField()方法可以获取该类所包含的全部或指定的成员变量Field,Filed提供了如下两组方法来读取和设置成员变量值.   
\- getXxx(Object obj): 获取obj对象的该成员变量的值, 此处的Xxx对应8中基本类型,如果该成员变量的类型是引用类型, 则取消get后面的Xxx;   
\- setXxx(Object obj, Xxx val): 将obj对象的该成员变量值设置成val值.此处的Xxx对应8种基本类型, 如果该成员类型是引用类型, 则取消set后面的Xxx;

注: getDeclaredXxx方法可以获取所有的成员变量,无论private/public;

/** * @author jifang * @since 16/1/2下午1:00. */
    public class Client { 
    
        @Test
        public void client() throws NoSuchFieldException, IllegalAccessException {
            User user = new User();
            Field idFiled = User.class.getDeclaredField("id");
            setAccessible(idFiled);
            idFiled.setInt(user, 46);
    
            Field nameFiled = User.class.getDeclaredField("name");
            setAccessible(nameFiled);
            nameFiled.set(user, "feiqing");
    
            Field passwordField = User.class.getDeclaredField("password");
            setAccessible(passwordField);
            passwordField.set(user, "ICy5YqxZB1uWSwcVLSNLcA==");
    
            System.out.println(user);
        }
    
        private void setAccessible(AccessibleObject object) {
            object.setAccessible(true);
        }
    }

# 使用反射获取泛型信息 #

为了通过反射操作泛型以迎合实际开发的需要, Java新增了java.lang.reflect.ParameterizedType java.lang.reflect.GenericArrayTypejava.lang.reflect.TypeVariable java.lang.reflect.WildcardType几种类型来代表不能归一到Class类型但是又和原始类型同样重要的类型.

![1240 6][]

其中, 我们可以使用ParameterizedType来获取泛型信息.

/** * Java学习交流QQ群：589809992 我们一起学Java！ */
    public class Client { 
    
        private Map<String, Object> objectMap;
    
        public void test(Map<String, User> map, String string) {
        }
    
        public Map<User, Bean> test() {
            return null;
        }
    
        /** * 测试属性类型 * * @throws NoSuchFieldException */
        @Test
        public void testFieldType() throws NoSuchFieldException {
            Field field = Client.class.getDeclaredField("objectMap");
            Type gType = field.getGenericType();
            // 打印type与generic type的区别
            System.out.println(field.getType());
            System.out.println(gType);
            System.out.println("**************");
            if (gType instanceof ParameterizedType) {
                ParameterizedType pType = (ParameterizedType) gType;
                Type[] types = pType.getActualTypeArguments();
                for (Type type : types) {
                    System.out.println(type.toString());
                }
            }
        }
    
        /** * 测试参数类型 * * @throws NoSuchMethodException */
        @Test
        public void testParamType() throws NoSuchMethodException {
            Method testMethod = Client.class.getMethod("test", Map.class, String.class);
            Type[] parameterTypes = testMethod.getGenericParameterTypes();
            for (Type type : parameterTypes) {
                System.out.println("type -> " + type);
                if (type instanceof ParameterizedType) {
                    Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
                    for (Type actualType : actualTypes) {
                        System.out.println("/tactual type -> " + actualType);
                    }
                }
            }
        }
    
        /** * 测试返回值类型 * * @throws NoSuchMethodException */
        @Test
        public void testReturnType() throws NoSuchMethodException {
            Method testMethod = Client.class.getMethod("test");
            Type returnType = testMethod.getGenericReturnType();
            System.out.println("return type -> " + returnType);
    
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypes = ((ParameterizedType) returnType).getActualTypeArguments();
                for (Type actualType : actualTypes) {
                    System.out.println("/tactual type -> " + actualType);
                }
            }
        }
    }

# 反射性能测试 #

Method/Constructor/Field/Element都继承了AccessibleObject,AccessibleObject类中有一个setAccessible方法:

public void setAccessible(boolean flag) throws SecurityException {
        ...
    }

该方法有两个作用:

1.  启用/禁用访问安全检查开关:值为true,则指示反射的对象在使用时取消Java语言访问检查;值为false,则指示应该实施Java语言的访问检查;
2.  可以禁止安全检查, 提高反射的运行效率.

/** * @author jifang * @since 15/12/31下午4:53. */
    public class TestReflect { 
    
        @Before
        public void testNoneReflect() {
            User user = new User();
    
            long start = System.currentTimeMillis();
            for (long i = 0; i < Integer.MAX_VALUE; ++i) {
                user.getName();
            }
            long count = System.currentTimeMillis() - start;
            System.out.println("没有反射, 共消耗 <" + count + "> 毫秒");
        }
    
        @Test
        public void testNotAccess() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
            User user = new User();
            Method method = Class.forName("com.fq.domain.User").getMethod("getName");
    
            long start = System.currentTimeMillis();
            for (long i = 0; i < Integer.MAX_VALUE; ++i) {
                method.invoke(user, null);
            }
            long count = System.currentTimeMillis() - start;
            System.out.println("没有访问权限, 共消耗 <" + count + "> 毫秒");
        }
    
        @After
        public void testUseAccess() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
            User user = new User();
            Method method = Class.forName("com.fq.domain.User").getMethod("getName");
            method.setAccessible(true);
    
            long start = System.currentTimeMillis();
            for (long i = 0; i < Integer.MAX_VALUE; ++i) {
                method.invoke(user, null);
            }
            long count = System.currentTimeMillis() - start;
            System.out.println("有访问权限, 共消耗 <" + count + "> 毫秒");
        }
    }

执行上面程序,在我的机器上会有如下结果:

![Java 反射][Java]

机器配置信息如下:

![Java 反射][Java 1]

可以看到使用反射会比直接调用慢3000毫秒,但是前提是该方法会执行20E+次(而且服务器的性能也肯定比我的机器要高),因此在我们的实际开发中,其实是不用担心反射机制带来的性能消耗的,而且禁用访问权限检查,也会有性能的提升。

[1240]: /images/20220608/5dcbcfa725904212b8c84ff82f58d765.png
[1240 1]: /images/20220608/26939124434b4144a23271adc511cd56.png
[1240 2]: /images/20220608/9fe1d24bc36d4ecf98df2d51c4dc1666.png
[1240 3]: /images/20220608/c7965fb116f84e12aab05271efc8d9e5.png
[JDK]: http://docs.oracle.com/javase/8/docs/api/java/lang/Class.html
[1240 4]: /images/20220608/41825341462b468eb8f0060377f503ea.png
[1240 5]: /images/20220608/43344bcb123a40899c0721094d7f3f22.png
[1240 6]: /images/20220608/2caa33f023a34c179372cd566af4a861.png
[Java]: /images/20220608/10dc8e5a12dd4f96aa82a25a6a81722f.png
[Java 1]: /images/20220608/a29554fe102a4eb19bb35328a2e21abe.png