反射机制是什么

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

反射机制能做什么

反射机制主要提供了以下功能：

• 在运行时判断一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 在运行时调用任意一个对象的方法
• 生成动态代理

反射机制的相关api的代码演示

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

package com.sschen.reflect;
public class TestReflect {
    public static void main(String[] args) {
        TestReflect testReflect = new TestReflect();
        System.out.println(testReflect.getClass().getName());
        //执行结果：com.sschen.reflect.TestReflect
    }
}

实例化class对象

package com.sschen.reflect;
public class TestReflect {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> class1 = null;
        Class<?> class2 = null;
        Class<?> class3 = null;

        class1 = Class.forName("com.sschen.reflect.TestReflect");
        class2 = new TestReflect().getClass();
        class3 = TestReflect.class;
        System.out.println("ClassName is : " + class1.getName());
        System.out.println("ClassName is : " + class2.getName());
        System.out.println("ClassName is : " + class3.getName());
    }
}

这三种方式，最终的结果都是一致的，目前编程中使用较多的是Class.forName

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

import java.io.Serializable;

public class TestReflect implements Serializable {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> classI = Class.forName("com.sschen.reflect.TestReflect");
        //取得父类
        Class<?> classParent = classI.getSuperclass();
        System.out.println("classI 的父类是 : " + classParent.getName());
        //执行结果：classI 的父类是 : java.lang.Object

        //获取实现的接口
        Class<?>[] iClass = classI.getInterfaces();
        System.out.println("classI 实现的接口有 : ");
        for (int i = 0; i < iClass.length; i++){
            System.out.println((i + 1) + " : " + iClass[i].getName());
        }
        //执行结果：classI 实现的接口有 : 
        //1 : java.io.Serializable
    }
}

获取类中的构造函数，且使用反射机制构造类的实例对象

import java.io.Serializable;
import java.lang.reflect.Constructor;

public class TestReflect implements Serializable {
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("com.sschen.reflect.User");
        //第一种方法，实例化默认构造函数，使用set赋值
        User user = (User) class1.newInstance();
        user.setAge(20);
        user.setName("ZhangSan");
        System.out.println(user);
        //执行结果：User{age=20, name='ZhangSan'}

        //第二种方法，取得全部的构造函数，使用构造函数赋值
        Constructor<?> cons[] = class1.getConstructors();
        //查看每个构造方法所需要的参数
        for (int i = 0; i < cons.length; i++) {
            Class<?>[] classParam = cons[i].getParameterTypes();
            System.out.print("[ class1 " + i + " ] (");
            for (int j = 0; j < classParam.length; j++) {
                if (j == classParam.length - 1) {
                    System.out.print(classParam[j].getName());
                }
                else {
                    System.out.print(classParam[j].getName() + ",");
                }
            }
            System.out.println(" )");
        }
        /*执行结果
        [ class1 0 ] (java.lang.String )
        [ class1 1 ] (int,java.lang.String )
        [ class1 2 ] ( )*/
        User user1 = (User) cons[0].newInstance("LiSi");
        System.out.println(user1);
        //执行结果：User{age=0, name='LiSi'}
        User user2 = (User) cons[1].newInstance(22, "Wangwu");
        System.out.println(user2);
        //执行结果：User{age=22, name='Wangwu'}
    }
}

获取某个类的全部属性

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class TestReflect implements Serializable {
    private static final long serialVersionUID = -12423423523423234L;
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("com.sschen.reflect.TestReflect");
        System.out.println("=======本类属性=======");
        //取得本类的全部属性
        Field[] fields = class1.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            //取得属性的权限修饰符
            int mod = fields[i].getModifiers();
            String priv = Modifier.toString(mod);
            //属性类型
            Class<?> type = fields[i].getType();
            System.out.println(priv + " " + type.getName() + " " + fields[i].getName());
        }
        //执行结果：private static final long serialVersionUID

        System.out.println("=======实现的接口或者父类的属性=======");
        //取得实现的接口或者父类的属性
        Field[] fields1 = class1.getFields();
        for (int i = 0; i < fields1.length; i++) {
            //取得属性的权限修饰符
            int mod = fields1[1].getModifiers();
            String priv = Modifier.toString(mod);
            //属性类型
            Class<?> type = fields1[i].getType();
            System.out.println(priv + " " + type.getName() + " " + fields1[i].getName() + ";");
        }
    }
}

获取某个类的全部方法

import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class TestReflect implements Serializable {
    private static final long serialVersionUID = -12423423523423234L;
    public static void main(String[] args) throws Exception {
        Class<?> class1 = null;
        class1 = Class.forName("com.sschen.reflect.TestReflect");
        Method[] methods = class1.getMethods();
        for (int i = 0; i < methods.length; i++) {
            Class<?> returnType = methods[i].getReturnType();
            Class<?>[] params = methods[i].getParameterTypes();
            int temp = methods[i].getModifiers();
            System.out.print(Modifier.toString(temp) + " ");
            System.out.print(returnType.getName() + "  ");
            System.out.print(methods[i].getName() + " ");
            System.out.print("(");
            for (int j = 0; j < params.length; ++j) {
                System.out.print(params[j].getName() + " " + "arg" + j);
                if (j < params.length - 1) {
                    System.out.print(",");
                }
            }
            Class<?> exce[] = methods[i].getExceptionTypes();
            if (exce.length > 0) {
                System.out.print(") throws ");
                for (int k = 0; k < exce.length; ++k) {
                    System.out.print(exce[k].getName() + " ");
                    if (k < exce.length - 1) {
                        System.out.print(",");
                    }
                }
            } else {
                System.out.print(")");
            }
            System.out.println();
        }
        /**
         * 执行结果：
         * public static void  main ([Ljava.lang.String; arg0) throws java.lang.Exception 
         * public final void  wait (long arg0,int arg1) throws java.lang.InterruptedException 
         * public final native void  wait (long arg0) throws java.lang.InterruptedException 
         * public final void  wait () throws java.lang.InterruptedException 
         * public boolean  equals (java.lang.Object arg0)
         * public java.lang.String  toString ()
         * public native int  hashCode ()
         * public final native java.lang.Class  getClass ()
         * public final native void  notify ()
         * public final native void  notifyAll ()
         */
    }
}

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

import java.lang.reflect.Field;
public class TestReflect {
    private String proprety = null;
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.sschen.reflect.TestReflect");
        Object obj = clazz.newInstance();
        // 可以直接对 private 的属性赋值，此处也就是我们所说单例模式中失效的反射机制
        //单例模式本身也就是对于自身私有属性的控制，而通过反射，可以直接修改私有属性的值，也就没有单例模式的概念。
        Field field = clazz.getDeclaredField("proprety");
        field.setAccessible(true);
        field.set(obj, "Java反射机制");
        System.out.println(field.get(obj));
        //执行结果：Java反射机制
    }
}

反射机制的动态代理

//定义项目接口
public interface ISubject {
    public String say(String name, int age);
}
//定义真实项目
public class RealSubject implements ISubject {
    public String say(String name, int age) {
        return name + " " + age;
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyInvocationHandler implements InvocationHandler {
    private Object obj = null;
    public Object bind(Object obj){
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object temp = method.invoke(this.obj, args);
        return temp;
    }
}

public class TestReflect {
    public static void main(String[] args) throws Exception {
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        ISubject subject = (ISubject) myInvocationHandler.bind(new RealSubject());
        String info = subject.say("Sschen", 27);
        System.out.println(info);
    }
}

从上述代码中我们可以看出

//获取类的加载器
类的实例.getClass().getClassLoader()
//获取类所实现的接口
类的实例.getClass().getInterfaces()

而反射实现动态代理就是传入类的实例，反向使用类实现的接口，通过调用接口方法，实现对于具体实例类的调用。
在java中有三种类类加载器。
1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。
2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jrelibext目录中的类
3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。

反射机制的应用实例

在泛型为Integer的ArrayList中放入String类型的对象

public class TestReflect {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(23);
        Method method = arrayList.getClass().getMethod("add", Object.class);
        method.invoke(arrayList, "Hello World");
        System.out.println(arrayList.get(1));
    }
}

通过这个例子可以看到，反射机制可以绕过声明泛型实例时对于类型的指定，而直接调用ArrayList的Add方法，放入Object类型的对象，这点是很强大的。

通过反射获取并修改数组的信息

import java.lang.reflect.Array;

public class TestReflect {
    public static void main(String[] args) throws Exception {
        int[] temp = {1, 2, 3, 4, 5};
        Class<?> demo = temp.getClass().getComponentType();
        System.out.println("数组类型为： " + demo.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));
        /**
         * 执行结果为
         * 数组类型为： int
         * 数组长度为： 5
         * 数组第一个元素为： 1
         * 修改后的第一个元素为： 100
         */
    }
}

通过反射机制修改数组的大小

import java.lang.reflect.Array;

public class TestReflect {
    public static void main(String[] args) throws Exception {
        int[] temp = {1, 3, 5, 7, 9};
        int[] newTemp = (int[])arrayInc(temp, 15);
        print(newTemp);
        String[] arrStr = {"aa", "bb", "cc"};
        String[] newStr = (String[])arrayInc(arrStr, 8);
        print(newStr);
        /**
         * 执行结果
         * 数组长度为： 15
         * 1 | 3 | 5 | 7 | 9 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
         * 数组长度为： 8 
         * aa | bb | cc | null | null | null | null | null | 
         */
    }

    /**
     * 修改数据大小
     * @param obj 数组元素
     * @param len 新的长度
     * @return 返回修改后的数组
     */
    public static Object arrayInc(Object obj, int len) {
        //得到数组数据类型
        Class<?> temp = obj.getClass().getComponentType();
        //根据数组类型使用新的长度生成新的数组
        Object newArr = Array.newInstance(temp, len);
        //得到原有数据的长度
        int newCo = Array.getLength(obj);
        //将原有数组的内容拷贝到新的数组上
        System.arraycopy(obj, 0, newArr, 0, newCo);
        return newArr;
    }

    /**
     * 打印输出
     * @param obj
     */
    public static void print(Object obj) {
        Class<?> type = obj.getClass();
        if (!type.isArray()) {
            return;
        }
        System.out.println("数组长度为： " + Array.getLength(obj));
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i) + " | ");
        }
        System.out.println();
    }
}

使用反射机制实现工厂模式

interface fruit {
    public abstract void eat();
}
class Apple implements fruit {
    public void eat() {
        System.out.println("Apple");
    }
}
class Orange implements fruit {
    public void eat() {
        System.out.println("Orange");
    }
}
class Factory {
    public static fruit getInstance(String ClassName) {
        fruit f = null;
        try {
            f = (fruit) Class.forName(ClassName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
public class TestReflect {
    public static void main(String[] args) throws Exception {
        fruit f = Factory.getInstance("net.xsoftlab.baike.Apple");
        if (f != null) {
            f.eat();
        }
    }
}

参考：
Java反射机制详解