动态代理代理模式一种比较好的设计模式，使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原

简介

代理模式一种比较好的设计模式，使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。代理模式分为动态代理和静态代理。

静态代理

先举个例子

定义发送短信的接口

public interface SmsService {
    String send(String message);
}

实现发送短信的接口

public class SmsServiceImpl implements SmsService{
    @Override
    public String send(String message) {
        System.out.println("send message: " + message);
        return message;
    }
}

创建代理并实现发送短信的接口

public class SmsServiceProxy implements SmsService{

    private final SmsService smsService;

    /**
     * 代理类中注入目标对象
     *
     * @param smsService
     */
    public SmsServiceProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    /**
     * 调用目标类中的对应的方法
     *
     * @param message
     * @return
     */
    @Override
    public String send(String message) {
        System.out.println("before send");
        smsService.send(message);
        System.out.println("after send");
        return null;
    }

    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsServiceProxy smsServiceProxy = new SmsServiceProxy(smsService);
        smsServiceProxy.send("静态代理");
    }
}

缺点：目标类的每个方法的增强都是手动编写代码实现的，不灵活且繁琐。

动态代理

我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类(CGLIB动态代理机制)。动态代理分为JDK动态代理，CGLIB动态代理。

JDK动态代理

JDK动态代理，InvocationHandler和Proxy类是核心

Proxy类主要用来生成一个代理类

/**
     * 创建代理类
     *
     * @param loader 类加载器
     * @param interfaces 被代理类实现的一些接口
     * @param h 实现了InvocationHandler接口自定义的对象
     * @return
     * @throws IllegalArgumentException
     */
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
            throws IllegalArgumentException
    {
    }

InvocationHandler自定义处理逻辑

public interface InvocationHandler {

    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

举个例子，代理上面的消息发送SmsServiceImpl类

自定义InvocationHandler重写invoke方法，invoke方法里调用被代理类的方法，并自定义一些逻辑

public class MessageInvocationHandler implements InvocationHandler {

    private final Object target;

    public MessageInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("after method" + method.getName());
        return result;
    }
}

通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象

public class JdkProxyFactory {

    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new MessageInvocationHandler(target));
    }

    public static void main(String[] args) {
        SmsService smsService = (SmsService)JdkProxyFactory.getProxy(new SmsServiceImpl());
        smsService.send("jdk动态代理");
    }
}

before method send
send message: jdk动态代理
after methodsend

JDK动态代理只能代理实现了接口的类

CGLIB动态代理

CGLIB动态代理可以解决JDK动态代理只能代理实现了接口的类。在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心

自定义MethodInterceptor接口

/**
 *
 * @param obj 被代理的对象
 * @param method 被拦截的方法
 * @param args 方法入参
 * @param proxy 用于调用原始方法
 * @return
 * @throws Throwable
 */
public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                        MethodProxy proxy) throws Throwable;

使用Enhancer类创建代理类

public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

举个例子，代理AliSmsService, 添加CGlib的依赖

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

public class AliSmsService {

    public String send(String message) {
        System.out.println("send message " + message);
        return message;
    }
}

自定义MethodInterceptor接口，实现intercept接口

public class AliMessageMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, objects);
        System.out.println("after method " + method.getName());
        return object;
    }
}

使用Enhancer类创建代理类

public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(clazz.getClassLoader());
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(new AliMessageMethodInterceptor());
        return enhancer.create();
    }

    public static void main(String[] args) {
        AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
        aliSmsService.send("cglib动态代理");
    }
}