动态代理（基于接口和基于子类的）

用一个例子解决：
创建一个IActor接口

	/**
	 * 经济公司对签约艺人的标准
	 */
	public interface IActor {
	    /**
	     * 基本的表演
	     */
	    public void basicAct(float money);
	
	    /**
	     * 危险的表演
	     */
	    public void dangerAct(float money);
	}

创建一个Actor类

	/**
	 * 演员
	 */
	public class Actor implements IActor{
	
	    /**
	     * 基本的表演
	     */
	    public void basicAct(float money) {
	        System.out.println("拿到钱，开始基本的表演：" + money);
	    }
	
	    /**
	     * 危险的表演
	     */
	    public void dangerAct(float money) {
	        System.out.println("拿到钱，开始危险的表演：" + money);
	    }
	}

最后一个主类：

/**
 * 模拟一个剧组
 */
public class Client {

    public static void main(String[] args) {
        final Actor actor = new Actor();
//        actor.basicAct(100f);
//        actor.dangerAct(500f);
        /**
         * 动态代理：
         *     作用：不改变源码的基础上，对已有的方法增强，是AOP思想的实现基础
         *     分类：
         *      1、基于接口的动态代理：
         *         要求：被代理类最少实现一个接口
         *         提供者：JDK官方
         *         涉及的类：Proxy
         *         创建代理对象的方法：newProxyInstance(ClassLoader, Class[], InvocationHandler)
         *         参数一：类加载器，和被代理对象使用相同的类加载器，一般都是固定写法
         *         参数二：字节码数组，被代理类实现的接口，要求代理对象和被代理对象具有相同的行为，一般都是固定写法
         *         参数三：接口，就是用于我们提供被代理类增强代码的。一般写一个该接口的实现类，可以是匿名
         *                 内部类，也能不是。含义就是：如何代理，只能是谁用谁提供
         *                 策略模式（一个接口，多个实现，多个实现类之间可以任意选择不会出错）：
         *                    使用要求：数据已经有了
         *                              目的明确
         *                              达成目标的过程就是策略
         *
         *     2、基于子类的动态代理：
         *        要求：被代理类不能是最终类，即不能被final修饰。且没有接口了！
         *        提供者：第三方CGLib（需要导入第三方的包）
         *        涉及的类：Enhancer
         *        创建代理对象的方法：create(Class, Callback);
         *        参数一：被代理对象的字节码
         *        参数二：如何代理。它和InvocationHandler作用是一样的。它也是一个接口，
         *                一般使用该接口的子接口MethodInterceptor，在使用时也是创建该
         *                接口的匿名内部类
         *
         */
        IActor proxyActor = (IActor) Proxy.newProxyInstance(actor.getClass().getClassLoader(),
                                actor.getClass().getInterfaces(),
                                new InvocationHandler() {
                                    /**
                                     * 执行被代理对象的任何方法都会经过该方法，该方法有拦截功能
                                     * 方法的参数：
                                     *   proxy：代理对象的引用，不一定每次都会用
                                     *   method：当前执行的方法反射出来的对象
                                     *   args：当前执行方法所需的参数
                                     *   返回值：当前执行方法的返回值
                                     */
                                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                        Object rtVal = null;
                                        //1、取出执行方法中的参数：给的多少钱
                                        Float money = (Float) args[0];
                                        //2、判断当前执行的是什么方法
                                        if("basicAct".equals(method.getName())) {
                                            //基本演出
                                            if(money > 10000) {
                                                //执行方法，开始表演，经济公司抽取50%
                                                rtVal = method.invoke(actor, money/2);
                                            }
                                        }
                                        if("dangerAct".equals(method.getName())) {
                                            //危险演出
                                            if(money > 50000) {
                                                //执行方法，开始表演，经济公司抽取50%
                                                rtVal = method.invoke(actor, money/2);
                                            }
                                        }
                                        return rtVal;
                                    }
                                });

        proxyActor.basicAct(10000);//不演，被经济公司拦截
        proxyActor.dangerAct(50000);//不演，被经济公司拦截
        proxyActor.basicAct(100000);//演


        Actor cglibActor = (Actor) Enhancer.create(actor.getClass(), new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                /**
                 * 执行被代理对象的任何方法，都会经过该方法，和基于接口的动态代理
                 * 的invoke方法的作用是一模一样的
                 * 方法参数：
                 *     前面三个跟invoke方法的参数含义和作用一模一样
                 *     methodProxy：当前执行方法的代理对象，一般不同
                 */
                System.out.println("进入cglib了！");
                Object rtVal = null;
                //1、取出执行方法中的参数：给的多少钱
                Float money = (Float) args[0];
                //2、判断当前执行的是什么方法
                if ("basicAct".equals(method.getName())) {
                    //基本演出
                    if (money > 10000) {
                        //执行方法，开始表演，经济公司抽取50%
                        rtVal = method.invoke(actor, money / 2);
                    }
                }
                if ("dangerAct".equals(method.getName())) {
                    //危险演出
                    if (money > 50000) {
                        //执行方法，开始表演，经济公司抽取50%
                        rtVal = method.invoke(actor, money / 2);
                    }
                }
                return rtVal;
            }
        });

        cglibActor.basicAct(10000);//不演，被经济公司拦截
        cglibActor.dangerAct(50000);//不演，被经济公司拦截
        cglibActor.basicAct(100000);//演
    }
}

感兴趣的同学详细的把代码抄一遍，肯定能理解基于接口和基于子类的动态代理的原理了！