Java中的动态代理

1. 动态代理

动态代理：
（1）定义：简而言之，就是讲事物交给第三方代为处理。
（2）特点：字节码随时用随时创建，随时用随时加载。
（3）分类：动态代理有两种代理方式：
　 　（a）基于接口的动态代理
　　 （b）基于子类的动态代理
（4）举例：以用户、代理商和生产厂家为例，以前用户直接向生产厂家直接购买商品，现在转为向代理商够买商品，而代理商从中间获取差价，代理商负责向用户出售商品和进行商品的售后服务，生产厂家负责向代理商出售商品和进行售后。这种服务方式的转移称之为动态代理。

2. 基于接口的动态代理方式

2.1 涉及的类及提供者

涉及的类有Proxy，提供者为JDK官方

2.2 如何创建代理对象

首先被代理类必须要实现一个接口，其次使用Proxy类中提供的newProxyInstance方法，其源码如下：

	@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
        Objects.requireNonNull(h);
        Class<?> caller = System.getSecurityManager() == null ? null : Reflection.getCallerClass();
        Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
        return newProxyInstance(caller, cons, h);
    }

可以看出newProxyInstance方法里面有三个参数：类加载器ClassLoader、字节码数组Class[]和用于提供增强的代码InvocationHandler。
（1）类加载器ClassLoader：
　　　用于加载代理对象字节码；被代理对象使用相同的类加载器。固定写法
（2）字节码数组Class[]：
　　　用于代理对象与被代理对象有相同的方法。固定写法
（3）InvocationHandler：
　　　它是让我们写如何代理。我们一般写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须写此接口的实现类都是谁用谁写。

2.3 案例分析

（1）生产者

package com.zyj.proxy;
/**
 * 一个生产者
 * (1)卖产品
 * (2)售后
 *
 */
public class Producer implements IProducer{
    /**
     * 销售
     * @param money
     */
    public void sellProduct(double money){
        System.out.println("销售产品："+money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(double money){
        System.out.println("提供售后服务："+money);
    }
}

（2）代理商接口

package com.zyj.proxy;
/**
 * 代理商对生产厂家的要求
 */
public interface IProducer {
    void sellProduct(double money);
    void afterService(double money);
}

（3）消费者

package com.zyj.proxy;

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

/**
 * 模拟消费者
 */
public class Client {
    public static void main(String[] args) {
        Producer producer = new Producer();
        producer.sellProduct(10000);
        producer.afterService(2000);
        
        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * @param proxy   代理对象的引用
                     * @param method  当前执行的方法
                     * @param objects  当前执行方法所需的参数
                     * @return 和被代理对象方法有相同的返回值
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;
                        //1.获取方法执行的参数
                        double money = (double) objects[0];
                        if ("sellProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer, money*0.8);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.sellProduct(10000);
    }
}

（5）输出结果

销售产品：10000.0
提供售后服务：2000.0
销售产品：8000.0

3. 基于子类的动态代理

由于基于接口的动态的代理方式必须满足被代理类要实现一个接口的要求，它无法代理普通的java类，因此下面将介绍基于子类的动态代理方式。

3.1 涉及的类及提供者

涉及的类为Enhancer类
public class Enhancer extends AbstractClassGenerator
提供者：cglib库

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.10</version>
</dependency>

3.2 如何创建代理对象

首先，被代理的类不能是final类；其次，使用Enhancer类中的create方法。该方法有两个参数：
（1）Class：字节码
　　　　　用于指定被代理对象的字节码。
（2）Callback:用于提供增强的代码
　　　　　一般写的都是该接口的子接口实现类：MethodInterceptor

	public static Object create(Class type, Callback callback) {
        Enhancer e = new Enhancer();
        e.setSuperclass(type);
        e.setCallback(callback);
        return e.create();
    }

3.3 案例

（1）消费者

package com.zyj.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

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

/**
 * 模拟消费者
 */
public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        producer.sellProduct(10000);
        producer.afterService(2000);
   
        Producer producer1 = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {
            /**
             * 执行动态代理的任何方法都会经过该方法
             * @param proxy
             * @param method
             * @param objects
             *          以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
             * @param methodProxy：当前执行方法的代理对象
             * @return
             * @throws Throwable
             */
            public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object returnValue = null;
                Double money = (Double) objects[0];
                if("sellProduct".equals(method.getName())){
                    returnValue = method.invoke(producer,money*0.8);
                }
                return returnValue;
            }
        });
        producer1.sellProduct(10000);
    }
}

（2）生产者

package com.zyj.cglib;
/**
 * 一个生产者
 * (1)卖产品
 * (2)售后
 *
 */
public class Producer {
    /**
     * 销售
     * @param money
     */
    public void sellProduct(double money){
        System.out.println("销售产品："+money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(double money){
        System.out.println("提供售后服务："+money);
    }
}

4. 动态代理在项目中的作用

（1）连接池的问题，close方法在关闭的时候不能真正的关闭，而是还回池中，可以使用动态代理的方式将Connection增强，把它加回池里面去。
（2）解决全栈中文乱码的request对象的方法增强