java反射机制深入理解剖析

---

title: java反射机制深入理解分析
date: 2018-3-3 14:18:40
categories:
- JDK
tags:
- JDK

- 反射

反射的简单介绍

主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

一个类有多个组成部分，例如：成员变量、方法、构造方法等，反射就是加载类,并解剖出类的各个组成部分。
主要功能:
1. 在运行时判断一个对象所属于的类
2. 运行时构造任意一个类的对象
3. 在运行时判断任意一个类所具有的成员变量和方法；
4. 在运行时调用任意一个对象的方法；
5. 生成动态代理

反射以及作用

java反射机制中有哪些类：主要有五个主要的类

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

通过一个对象获得完整的包名和类名

public class TestReflect {
    public static void main(String[] args) {
        TestReflect testReflect = new TestReflect();
        System.out.println(testReflect.getClass().getName());
        // 反射.TestReflect
    }
}

实例化Class类对象

public static void main(String[] args) throws ClassNotFoundException {
        // TODO Auto-generated method stub
        Class<?> class1 = null;
        Class<?> class2 = null;
        Class<?> class3 = null;
        // 一般采用这种形式
        class1 = Class.forName("反射.TestReflect");
        class2 = new TestReflect().getClass();
        class3 = TestReflect.class;
        System.out.println("类名称   " + class1.getName());
        System.out.println("类名称   " + class2.getName());
        System.out.println("类名称   " + class3.getName());
        /**
         *  类名称   反射.TestReflect
            类名称   反射.TestReflect
            类名称   反射.TestReflect
         */
    }

获取一个对象的父类与实现的接口

public class TestReflect1 implements Cloneable, Serializable{
    private static final long seriaVersionUID = -2862585049955236662L;
    public static void main(String[] args) throws ClassNotFoundException {
        // TODO Auto-generated method stub
        Class<?> clazz = Class.forName("反射.TestReflect1");

        // 获取父类
        Class<?> parentClass = clazz.getSuperclass();

        System.out.println("class对象的父类是:" + parentClass.getName());
        // clazz的父类为： java.lang.Object
        // 获取所有的接口

        Class<?> intes[] = clazz.getInterfaces();
        System.out.println("clazz实现的接口有");
        for (int i = 0; i <intes.length; i++) {
            System.out.println(i++ + ":" + intes[i].getName());
        }
        /**
         * class对象的父类是:java.lang.Object
            clazz实现的接口有 0:java.io.Serializable
         */

    }

}

通过反射机制实例化一个类的对象

package 反射;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
* @author 作者 : coderlong
* @version 创建时间：2018年3月3日 下午9:27:11
* 类说明: 
*/
public class TestReflect {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        // TODO Auto-generated method stub
        Class<?> clazz1 = null;
        clazz1 = Class.forName("反射.User");
        User user = (User)clazz1.newInstance();
        user.setAge(20);
        user.setName("林黛玉");
        System.out.println(user);
        // result :  User [age=20, name=林黛玉]

        // 第二种方法 获取构造方法
        Constructor<?> cons[] = clazz1.getConstructors();
        // 看一下 每个构造方法需要的方法
        for (int i = 0; i < cons.length; i++) {
            Class<?> clazzs[] = cons[i].getParameterTypes();
            System.out.print("cons[" + i + "] (");
            for (int j = 0; j < clazzs.length; j++) {
                if (j == clazzs.length - 1)
                    System.out.print(clazzs[j].getName());
                else
                    System.out.print(clazzs[j].getName() + ",");
            }
            System.out.println(")");
        }
        // 结果
        //cons[0] (int,java.lang.String)
//        cons[1] (java.lang.String)
//        cons[2] ()

        User user2 = (User)cons[0].newInstance(20,"林黛玉");

        System.out.println(user2);
    }

}

获取某个类的全部属性 可以使用clazz.getgetDeclaredFields()

获得一个类的所有public属性，和父类所有方法 clazz.getFields()

public class TestReflect2 extends TestReflect implements Serializable,Cloneable{
    private static final long serialVersionUID = -2862585049955236662L;
    public static void main(String[] args) throws ClassNotFoundException{
        // TODO Auto-generated method stub
        Class<?> clazz = Class.forName("反射.TestReflect2");
        System.out.println("本类属性");
        // 取得自己累得全部属性
        Field[] fields = clazz.getDeclaredFields();

        for (int i = 0; i < fields.length; i++) {
            // 获得属性的修饰符
            int mo = fields[i].getModifiers();
            String priv = Modifier.toString(mo);
            System.out.println(priv);
            // 获得属性的类型
            Class<?> type = fields[i].getType();
            System.out.println(priv + " " + type.getName() + " " + fields[i].getName());
        }

        // 取得接口的实现 或者父类的属性
        System.out.println("接口的实现 或者父类的属性");
        Field[] fields2 = clazz.getFields();

        for (int i = 0; i < fields2.length; i++) {
            // 权限修饰符
            int mo = fields2[i].getModifiers();
            String priv = Modifier.toString(mo);
            // 属性的类型
            Class<?> type = fields2[i].getType();
            System.out.println(priv + " " + type.getName() + " " + fields2[i].getName());
        }
    }

}

• 获取某个类的全部方法 *

public class testReflect3 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class<?> clazz = Class.forName("反射.testReflect3");

        Field[] fields = clazz.getDeclaredFields();
        Method[] methods = clazz.getDeclaredMethods();
        for (int i = 0; i < methods.length; i++) {
            // 返回值
            Class<?> returnType = methods[i].getReturnType();
            // 获得方法参数
            Class<?>[] para = methods[i].getParameterTypes();
            int mo = methods[i].getModifiers();
            // 修饰符
            String priv = Modifier.toString(mo);
            System.out.print(priv + " ");
            System.out.print(returnType.getName() + " ");
            System.out.print(methods[i].getName() + " ");
            System.out.print("(");
            for (int j = 0; j < para.length; j++) {
                System.out.print(para[i].getName() + " arg " + j);
                if (j < methods.length - 1) {
                    System.out.print(",");
                }
            }
            Class<?>[] excel = methods[i].getExceptionTypes();
            if (excel.length > 0) {
                for (int k = 0; k < excel.length; k++) {
                    System.out.print(excel[k].getName() + " ");
                    if (k < excel.length - 1) {
                        System.out.print(",");
                    }
                }

            }
            else {
                System.out.print(")");
            }
            System.out.print(")");
        }
    }

    // result:
    // public static void main ([Ljava.lang.String; arg 0java.lang.Exception )

}

• 通过反射机制调用某个类的方法 *

public class TestReflect4 {

    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("反射.TestReflect4");
        Method method = clazz.getMethod("reflect1");
        method.invoke(clazz.newInstance());

        // 带参数的方法如何调用
        method = clazz.getMethod("reflect2", int.class, String.class);
        method.invoke(clazz. newInstance(),20,"wangyake");

    }
    public void reflect1() {
        System.out.println("Java 反射机制 - 调用某个类的方法shibushi1.");
    }
    public void reflect2(int age, String name) {
        System.out.println("Java 反射机制 - 调用某个类的方法2.");
        System.out.println("age -> " + age + ". name -> " + name);
    }
}

• 通过反射机制操作某个类的属性 *

public class TestReflect5 {
    private String name  = "coderlong";
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class<?> clazz = Class.forName("反射.TestReflect5");
        // 反射对对象属性赋值
        Field field = clazz.getDeclaredField("name");
        Object object = clazz.newInstance();
        System.out.println(field.get(object));
        field.setAccessible(true);
        field.set(object,"yake");
        System.out.println(field.get(object));
    }

}

• 反射机制的动态代理 *

// 获取类加载器的方法
TestReflect testReflect = new TestReflect();
        System.out.println("类加载器  " + testReflect.getClass().getClassLoader().getClass().getName());

在java中有三种类类加载器。

*. Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。
*. Extension ClassLoaderyong来进行扩展类的加载，一般对应的是jrelibext目录中的类

*. AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。

如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作

反射的应用

在泛型为Integer的ArrayList中存放一个String类型的对象

ArrayList<Integer> list = new ArrayList<>();
        Method method = list.getClass().getMethod("add", Object.class);
        method.invoke(list, "可以添加String？");
        System.out.println(!list.isEmpty());

反射修改数组元素

public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        // TODO Auto-generated method stub
        ArrayList<Integer> list = new ArrayList<>();
        Method method = list.getClass().getMethod("add", Object.class);
        method.invoke(list, "可以添加String？");
        System.out.println(!list.isEmpty());

        int[] temp = {1,2,3,4,5};
        Class<?> clazz = temp.getClass().getComponentType();
        System.out.println("数组类型" + clazz.getName());
        System.out.println("长度"  + Array.getLength(temp));
        System.out.println("数组第一个元素" + Array.get(temp,0));
        Array.set(temp, 0, 100);
        System.out.println("修改后第一个元素" + Array.get(temp, 0));
    }

优点：
1. 能够运行时动态获取类的实例，大大提高系统的灵活性和扩展性。
2. 与Java动态编译相结合，可以实现无比强大的功能

缺点：
1. 使用反射的性能较低
2. 使用反射相对来说不安全
3. 破坏了类的封装性，可以通过反射获取这个类的私有方法和属性