——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——

反射与动态代理

---

一、类加载器
我们已经知道一个Java程序是由很多的类，以及这些类的对象组成的，因为类是创建对象的模板，所以当某个Java程序中需要使用某个类，那么JVM就会将该类加载到内存，并为之创建一个Class类的对象。
注意：Java中每一个类或接口都会有一个对应的Class类的对象，该对象用于描述所有类共有的属性和行为。
1.类加载器的作用：负责将.class文件加载到内存，并为之生成对应的Class对象。
2.分类：
<1>Bootstrap ClassLoader 根类加载器
负责Java核心类的加载
<2>Extension ClassLoader 扩展类加载器
负责JRE扩展目录中jar包的加载。
<3>System ClassLoader 系统类加载器
负责JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和路径

二、反射
**1.概述**Java的反射机制是一种可以在运行状态中动态的剖析类的结构，获得类中的所有元素，并动态创建类的对象，调用类的成员的一种机制。
反射最强大的功能在于可以动态获取某个类中的所有元素，包括类的名称，父类，实现接口，成员变量，成员方法，构造方法。。

2.Class类介绍
通过查阅API可知，Class类的对象代表运行在Java程序中的类或接口。
Class类没有提供公共的构造方法，Class类的对象由JVM通过调用类加载器的defineClass方法自动创建。
获取某个类的Class类对象的方式有以下三种：
假设已知类的全称：className (包括包名+类名)
<1>类名.class
<2>类的对象变量.getClass()
<3>Class.forName(className)

3.通过反射获取构造方法

public Constructor[] getConstructors():所有公共构造方法
public Constructor[] getDeclaredConstructors():所有构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)获取单个构造方法 ; 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象

通过构造方法创建对象：

Class c = Class.forName(className);
Constructor con = c.getConstructor();// 返回的是构造方法对象
Object obj = con.newInstance();

获取私有构造方法并创建对象：

Class c = Class.forName(className);
Constructor con = c.getDeclaredConstructor(String.class);
//设置暴力访问标志位true,则不进行访问权限检查
con.setAccessible(true);
Object obj = con.newInstance("hello");

4.通过反射获取成员方法

public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
获取指定名称，参数的公有方法对象
public Method getDeclaredMethod(String name, Class<?>...)
获取指定名称，参数的声明方法对象
public Method[] getMethods() throws SecurityException
获取类中的所有共有方法
public Method[] getDeclaredMethods()
获取所有声明方法
void setAccessible(boolean flag)设置暴力访问标记

获取类中所有声明的方法：

Method[] methods = cl.getDeclaredMethods();
for(Method method : methods) {
    System.out.println(method);
}

获取指定名称和参数列表的方法：

Method method = cl.getMethod("methodName", int.class, double.class, ......);
//调用方法
method.invoke(instance, 12, 22.2,.....);

5.通过反射获取成员变量
获取所有成员：getFields,getDeclaredFields
获取单个成员：getField,getDeclaredField
修改成员的值：set(Object obj,Object value)

5.反射的几个综合应用案例
<1>需求：通过反射剖析一个类的内部结构，获取类中的所有元素。
分析：通过Class类对象的方法获取一个类中的所有元素，并将它们按照定义类的格式打印到控制台上。
代码：

/*
 * 通过反射机制获取任意一个类的内部结构
 */
public class ReflectionDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过用户输入获取类的名称：注意类的名称包括包名加类名
        String name;
        {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个类名(例如：java.lang.Object) : ");
            name = sc.nextLine();
        }

        // 获取类的Class类对象
        Class clazz = Class.forName(name);
        // 获取父类的Class对象
        Class superClass = clazz.getSuperclass();
        // 获取类的修饰符
        String modifiers = Modifier.toString(clazz.getModifiers());
        // 获取接口
        Class[] interfaces = clazz.getInterfaces();
        String interfacesNames = "";
        if(interfaces.length > 0) {
            for (int i = 0; i < interfaces.length; i++) {
                interfacesNames += interfaces[i].getName();
                if(i != interfaces.length-1) {
                    interfacesNames += ",";
                }
            }
        }

        //按定义类的格式输出
        if (modifiers.length() > 0) {
            System.out.print(modifiers + " ");
        }
        System.out.print("class " + name);
        if (superClass != null && superClass != Object.class) {
            System.out.print(" extends " + superClass.getName());
        }
        if (interfaces != null) {
            System.out.println();
            System.out.print("  implements " + interfacesNames);
        }
        System.out.print(" {\n");
        //打印所有构造方法
        printConstructors(clazz);
        System.out.println();
        //打印所有成员方法，静态方法
        printMethods(clazz);
        System.out.println();
        //打印所有成员变量，静态变量
        printFields(clazz);
        System.out.println("}");
    }

    public static void printConstructors(Class cl) {
        Constructor[] constructors = cl.getDeclaredConstructors();

        for (Constructor constructor : constructors) {
            //获取构造方法修饰符
            String modifiers = Modifier.toString(constructor.getModifiers());
            //获取构造方法名称
            String name = constructor.getName();
            //获取构造方法参数列表
            Class[] types = constructor.getParameterTypes();

            //按格式打印方法
            System.out.print("\t");
            if(modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print(name + "(");
            for (int i = 0; i < types.length; i++) {
                if(i > 0) {
                    System.out.print(", ");
                }
                System.out.print(types[i].getName());
            }
            System.out.println(");");
        }
    }

    public static void printMethods(Class cl) {
        //获取方法
        Method[] methods = cl.getDeclaredMethods();
        for (Method method : methods) {
            //获取方法名
            String name = method.getName();
            //获取修饰符
            String modifiers = Modifier.toString(method.getModifiers());
            //获取方法参数列表
            Class[] types = method.getParameterTypes();

            //按格式打印
            System.out.print("\t");
            if(modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.print(name + "(");
            for (int i = 0; i < types.length; i++) {
                if(i > 0) {
                    System.out.print(", ");
                }
                System.out.print(types[i].getName());
            }
            System.out.println(");");
        }

    }

    public static void printFields(Class cl) {
        Field[] fields = cl.getDeclaredFields();
        for (Field field : fields) {
            //获取变量名
            String name = field.getName();
            //获取修饰符
            String modifiers = Modifier.toString(field.getModifiers());
            //获取类型
            Class type = field.getType();

            //按格式打印
            System.out.print("\t");
            if(modifiers.length() > 0) {
                System.out.print(modifiers + " ");
            }
            System.out.println(type.getName() + " " + name + ";");
        }
    }
}

运行结果：

请输入一个类名(例如：java.lang.Object) : 
java.util.ArrayList
public class java.util.ArrayList extends java.util.AbstractList
  implements java.util.List,java.util.RandomAccess,java.lang.Cloneable,java.io.Serializable {
    
    public java.util.ArrayList(java.util.Collection);
    public java.util.ArrayList();
    public java.util.ArrayList(int);

    public clone();
    public add(int, java.lang.Object);
    public add(java.lang.Object);
    public contains(java.lang.Object);
    public get(int);
    public indexOf(java.lang.Object);
    public isEmpty();
    public lastIndexOf(java.lang.Object);
    public size();
    public subList(int, int);
    public toArray();
    public toArray([Ljava.lang.Object;);
    static access$100(java.util.ArrayList);
    static access$200(java.util.ArrayList);
    public addAll(int, java.util.Collection);
    public addAll(java.util.Collection);
    public iterator();
    public remove(int);
    public remove(java.lang.Object);
    private readObject(java.io.ObjectInputStream);
    private writeObject(java.io.ObjectOutputStream);
    public clear();
    public set(int, java.lang.Object);
    public ensureCapacity(int);
    public trimToSize();
    private ensureCapacityInternal(int);
    elementData(int);
    private grow(int);
    private static hugeCapacity(int);
    public listIterator();
    public listIterator(int);
    public removeAll(java.util.Collection);
    protected removeRange(int, int);
    public retainAll(java.util.Collection);
    private outOfBoundsMsg(int);
    private rangeCheckForAdd(int);
    private rangeCheck(int);
    private batchRemove(java.util.Collection, boolean);
    private ensureExplicitCapacity(int);
    private fastRemove(int);
    static subListRangeCheck(int, int, int);

    private static final long serialVersionUID;
    private static final int DEFAULT_CAPACITY;
    private static final [Ljava.lang.Object; EMPTY_ELEMENTDATA;
    private transient [Ljava.lang.Object; elementData;
    private int size;
    private static final int MAX_ARRAY_SIZE;
}

通过上面的示例可以看出反射功能的强大之处，可以用来获取类中的所有元素，包括私有元素。

<2>需求：通过配置文件运行类中的方法。
假设有三个类：Student, Teacher, Worker，这三个类中都有一个love方法，通过配置文件和反射机制在运行时指定运行哪个类的方法。
分析：
1. 需要有配置文件，定义class.txt为配置文件
2.配置文件中有两个键：className 类名， methodName 方法名
3.获取类名
4.通过类名获取类名对应的Class对象
5.通过Class对象创建实例，调用方法
代码：

//配置文件中的内容如下
//className=cn.itcast.test.Worker
//methodName=love

//三个测试用类
public class Student {
    public void love() {
        System.out.println("学生爱学习");
    }
}

public class Teacher {
    public void love() {
        System.out.println("老师爱教课");
    }
}

public class Worker {
    public void love() {
        System.out.println("工人爱工作");
    }
}

//测试类
public class ReflectionDemo {
    public static void main(String[] args) {
        //通过Properties类获取配置文件中的内容
        Properties prop = new Properties();
        FileReader reader = new FileReader("class.txt");
        prop.load(reader);
        reader.close;
        //获取数据
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");
        //通过反射获取Class对象
        Class cl = Class.forName(className);
        //创建对象
        Constructor c = cl.getConstructor();
        Object instance = c.newInstance();
        //调用方法
        Method method = cl.getMethod(methodName, null);
        method.invoke(instance, null);
    }
}

运行结果： 工人爱工作

<3>通过反射越过泛型检查
需求：向ArrayList对象中添加一个Integer数据
代码：

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

public class ReflectionDemo3 {
    public static void main(String[] args) throws NoSuchMethodException,
            SecurityException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        // 创建一个ArrayList<String>对象
        ArrayList<String> list = new ArrayList<String>();
        list.add("hello");
        //list.add(12); 编译不通过
        // 获取ArrayList的Class对象
        Class cl = list.getClass();
        // 获取add()方法
        Method add = cl.getMethod("add", Object.class);
        // 调用add方法添加元素
        add.invoke(list, 12);

        System.out.println(list);
    }
}

输出结果：
[hello, 12]

如结果所示，成功将Integer类型数据存入了集合，由此可见，泛型检测机制是在编译时期完成的。

三、动态代理
1.概述
想要理解动态代理，那么首先要理解什么是代理。
代理其实是一种面向对象的设计模式。
从现实生活的角度去考虑，比如说我们要买一管高露洁牙膏，那么按正常思维来说我们肯定是到这种牙膏的出售点去买，而不是到生产厂商那里去买，那么这个牙膏售卖点其实就是一种代理，看下图：

下面用代码来描述这种情况：

public class ProxyDemo {
    
    public static void main(String[] args) {
        ProduceFactory pf = new ProduceFactory();
        //厂家自己卖
        pf.sell();

        ProxyShop ps = new ProxyShop(pf);
        //代理商替厂家卖
        ps.sell();
    }
}

interface SellSomething {
    
    void sell();
}

class ProduceFactory implements SellSomething {
    

    @Override
    public void sell() {
        System.out.println("卖牙膏");
    }

}

class ProxyShop implements SellSomething {
    

    //获取生产厂家的对象
    ProduceFactory factory;

    ProxyShop(ProduceFactory factory) {
        this.factory = factory;
    }

    //代理类来代替生产厂家卖东西
    @Override
    public void sell() {
        factory.sell();
    }   
}

那么这样做的好处是什么呢？
首先分析代理设计模式中的三个要素：
1.抽象接口：声明了真实对象和代理对象的公共行为
2.代理对象：代理对象内部含有真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
3.真实对象：代理角色所代表的真实对象，是我们最终要引用的对象。
好处：
对外部提供统一的接口方法，而代理类在接口中实现对真实类的附加操作行为，从而可以在不影响外部调用情况下，进行系统扩展。

2.动态代理
在程序运行过程中为某一个接口创建代理对象。
Java中通过Proxy类中的newProxyInstance方法来创建动态代理。
注意：Proxy类只能针对接口做动态代理。
程序实例：为List集合接口创建一个动态代理对象。
代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public class ProxyDemo {
    

    public static void main(String[] args) {
        //创建实际对象
        final List list = new ArrayList();
        //创建代理对象对list接口做代理
        /*
         * newProxyInstance参数的含义：
         * ClassLoader : 通过要代理的类的Class对象获取类加载器，以便于代理类获取实际类的内部结构
         * Interface[] : 获取代理类的所有接口
         * InvocationHandler : 通过调用处理器接口调用接口的方法。
         */
        List proxy = (List) Proxy.newProxyInstance(list.getClass()
                .getClassLoader(), list.getClass().getInterfaces(),
                new InvocationHandler() {

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

        proxy.add("I love Java.");
        proxy.add(34);

        System.out.println(proxy);
    }
}

运行结果：
[I love Java., 34]

注：关于反射和动态代理的应用需要在实际项目中去体会。