Java中类加载和反射技术实例

我们知道一个对象在运行时有两种类型，一个是编译类型，一个是运行时类型。在程序运行时，往往是需要发现类和对象的真实的信息的。那么如何获的这种信息呢？

其一，如果我们在编译和运行时都知道类型的具体信息，这时是可以手动将一个对象转换为运行时的类型。

其二，如果我们在编译时无法预知对象和类到底是属于哪些类，那么程序只有依靠运行时的信息来发现对象和类的真实的信息了，这时就必须要用到反射技术。

在谈具体的反射技术之前，我想先回顾下，有关类的加载的一些基本的性质和原理，以方便我们更好地理解，反射的作用和特点。而实际上，一个类如果可以被执行，那么对于JVM来说，它的执行流程为：类的加载、连接、初始化。通过这种方式，才可以获取到一个类的类对象，即java.lang.Class对象，并在此基础上获取到该类的成员变量，方法和构造器等内在的东东。

那么，什么是类的加载呢？类的加载就是将类的class文件读入内存，并为之创建一个java.lang.Class对象，也就是说当程序使用任何类时，系统都会为之建立一个java.lang.Class对象。

同时，这个java.lang.Class对象又有什么特点呢？

1、Class是一个类，一个描述类的类（也就是描述类本身），封装了描述方法的Method，描述字段的Filed，描述构造器的Constructor等属性
2、对象照镜子后（反射）可以得到的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。
3、对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。
4、Class 对象只能由系统建立对象
5、一个类在 JVM 中只会有一个Class实例

同时，我们了解下一个基本的类加载器的结构：

类的连接：连接阶段负责把类的二进制数据合并到JRE中，分为三个步骤：

第一，验证，检验被加载的类是否有正确的内部结构；第二，准备，负责为类的类变量分配内存，并设置默认初始值。第三，解析将类的二进制数据中的符号引用替换成直接引用。

类的初始化：主要对类变量进行初始化。

这样，我们清楚地认识到了一个类的生命周期变化，那么这些也为我们的反射机制带来了铺垫，通过反射要获取一个类的class对象，有三种方式：

(1)使用Class类的forName(String clazzName)静态方法

(2)调用某个类的class属性获取该类对应的Class对象

(3)调用某个类的getClass()方法

通过这三种手段就可以获取到了一个类的Class对象，这样就可以动态获取该对象的实际的信息了。下面通过一个具体的例子说明下，如果通过反射机制，创建一个类的对象，如何通过获取的对象再进一步获取该对象的属性和方法，以及动态为该对象注入新的参数值。

测试实体类：

package reflection;

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description
 * @date 2017/10/19
 */
public class Person {
    public String name;
    private int age;

    public Person(){
        System.out.println("无参构造器");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    private void privateMethod(){
        System.out.println("这是一个私有的方法！");
    }

    public void setName(String name,int age){
        System.out.println("getName is:"+name);
        System.out.println("getAge is:"+age);
    }

}

通过反射获取类：

package reflection;

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description 通过反射获取类测试
 * @date 2017/10/19
 */
public class GetClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        //Class是一个描述类的类、对每个类而言只有一个不变的Class与其对应、JRE中只有唯一一个
        Class clazz = null;

        //1 直接通过类名.class方式得到
        clazz = Person.class;
        //输出：reflection.Person
        System.out.println("直接通过类名.class得到:"+clazz);

        //2 通过对象的getClass()方法获取
        Object obj = new Person();
        clazz = obj.getClass();
        //输出：reflection.Person
        System.out.println("通过getClass(): " + clazz);

        //3 通过全类名获取，用的比较多，但可能抛出ClassNotFoundException异常
        clazz = Class.forName("reflection.Person");
        //输出：reflection.Person
        System.out.println("通过全类名获取: " + clazz);
    }
}

获取类的实例：

package reflection;

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description 通过反射获取类的实例测试
 * @date 2017/10/19
 */
public class GetInstanceTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class clazz = Class.forName("reflection.Person");
        //使用Class类的newInstance()方法创建类的一个对象
        //实际调用的类的那个 无参数的构造器
        //一般的，一个类若声明了带参数的构造器，也要声明一个无参数的构造器
        Object obj = clazz.newInstance();
        System.out.println(obj.toString());
    }
}

获取类所定义的方法：

package reflection;

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

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description 通过反射获取类所定义的方法的测试
 * @date 2017/10/19
 */
public class GetMethodTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //获取clazz
        Class clazz = Class.forName("reflection.Person");

        //1、得到clazz 对应的类中有哪些方法,不能获取private方法
        Method[] methods = clazz.getMethods();
        System.out.println("getMethods:");
         //遍历方法集合 获取对应的方法名称
        for (Method method : methods) {
            System.out.print(method.getName() + ", ");
        }
        System.out.println();
        //2、获取所有的方法(包括private方法）
        Method[] methods2 = clazz.getDeclaredMethods();
        System.out.println("getDeclaredMethods:");
        for (Method method : methods2) {
            System.out.print(method.getName() + ", ");
        }

        System.out.println();
        //3、获取指定的方法
        Method method = clazz.getDeclaredMethod("setName", String.class);
        System.out.println("method : " + method);

        Method method2 = clazz.getDeclaredMethod("setName", String.class, int.class);//第一个参数是方法名，后面的是方法里的参数
        System.out.println("method2: " + method2);

        //4、执行方法
        Object obj = clazz.newInstance();
        //此处注意下该invoke方法，参数为：执行该方法的对象，为该方法传入的参数列表
        method2.invoke(obj, "jaycee", 23);
    }
}

获取Fileds：

package reflection;

import java.lang.reflect.Field;

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description 通过反射获取field测试
 * @date 2017/10/19
 */
public class GetFieldTest {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Class clazz = Class.forName("reflection.Person");

        //1、获取字段
        //1.1 获取Field的数组,私有字段也能获取
        Field[] fields = clazz.getDeclaredFields();
        for (Field field: fields) {
            System.out.print(field.getName() + ", ");
        }

        //1.2 获取指定名字的Field
        Field field = clazz.getDeclaredField("name");
        System.out.println("\n获取指定Field名=: " + field.getName());

        Person person = new Person("jaycee", 23);
        //2、获取指定对象的Field的值
        Object val = field.get(person);
        System.out.println("获取指定对象字段'name'的Field的值=：" + val);

        //3、设置指定对象的Field的值
        field.set(person, "admin");
        System.out.println("设置指定对象字段'name'的Field的值=: " + person.name);

        //4、若该字段是私有的，需要调用setAccessible(true)方法
        Field field2 = clazz.getDeclaredField("age");
        field2.setAccessible(true);
        System.out.println("获取指定私有字段名=: " + field2.getName());
    }
}

获取父类定义的信息：

申明父类：

package reflection.invoke;

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description 父类
 * @date 2017/10/19
 */
public class Father {
    /**
     * 父类无参构造函数
     */
    public Father(){

    }
    /**
     * 父类私有方法1
     */
    private String method(){
        return "Father's private method";
    }
}

申明子类：

package reflection.invoke;

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description 儿子类
 * @date 2017/10/19
 */
public class Son extends Father{
    /**
     * @author [e-mail]
     * @date 2017/10/19 10:19
     * @param
     * @return
     * @description 儿子私有方法
     */
    private void method1(Integer age){
        System.out.println("son's age=:" +age);
    }
}

获取父类中定义的方法：

package reflection.invoke;

/**
 * @author [e-mail]
 * @version 1.0
 * @name
 * @description 获取父类中定义的私有的方法
 * @date 2017/10/19
 */
public class GetSuperClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        String className = "reflection.invoke.Son";
        Class clazz = Class.forName(className);
        //得到父类的Class
        Class superClazz = clazz.getSuperclass();
        //输出：class reflection.invoke.Father
        System.out.println(superClazz);
    }
}

总结下反射的优点和缺点：

 优点：
 （1）提高程序的灵活性和拓展性，能够在运行时动态地获取类的实例。
 （2）和java的动态编译相结合，可以提高更强大的功能。
 （3）提前无需硬编码，便可以通过类名获取对应类的实例，进而操作该实例。

 缺点：
 （1）性能较低，反射是一种接入式的操作需要找到对应的字段和方法，比起直接的代码赋值，要慢的多。
 （2）使用反射应该在一个相对安全的环境下进行。
 （3）使用时会破坏类的封装性，破坏OOP的整体设计思想。