Java代理(jdk静态代理、动态代理和cglib动态代理)

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 

一. JDK 动态代理

1.业务接口（必须有）

package com.sww.proxy;

public interface HelloWorldJDKProxy {

    void helloWorld();
}

2.业务实现

package com.sww.proxy;

/**
 * JDK 动态代理测试
 *
 * @author TF12778 2019/1/28 09:49
 */
public class HelloWorldJDKProxyImpl implements HelloWorldJDKProxy {

    public void helloWorld() {
        System.out.println("Hello World JDK Proxy!");
    }
}

3.代理类

package com.sww.proxy;

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

/**
 * JDK动态代理
 *
 * @author TF12778 2019/1/28 09:52
 */
public class JDKInvocationHandler implements InvocationHandler {

    private Object target;

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

    /**
     * 创建代理实例
     * @return
     * @throws Throwable
     */
    public Object getProxy() {
        return Proxy.newProxyInstance(Thread.currentThread()
                .getContextClassLoader(), this.target.getClass()
                .getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("method:" + method.getName() + " is invoked!");
        return method.invoke(target, args);
    }
}

4. JDK动态代理测试

package com.sww.proxy;

/**
 * JAVA JDK动态代理
 *
 * 代理是Java常用的设计模式，代理类通过调用被代理类的相关方法，并对相关方法进行增强。加入一些非业务性代码，比如事务、日志、报警发邮件等操作。
 *
 * @author TF12778 2019/1/28 09:44
 */
public class ProxyController {

    public static void main(String[] atgs){

        /**
         * JDK 动态代理
         */
        HelloWorldJDKProxy jdkProxy = new HelloWorldJDKProxyImpl();
        JDKInvocationHandler handle = new JDKInvocationHandler(jdkProxy);

        // 根据目标生成代理对象
        HelloWorldJDKProxy proxy = (HelloWorldJDKProxy)handle.getProxy();
        proxy.helloWorld();

    }
}

测试结果：

method:helloWorld is invoked!
Hello World JDK Proxy!

二. CGLib 动态代理

1. 业务实现（可以没有业务接口类）

package com.sww.proxy;

/**
 * 业务类
 * 没有实现接口
 * 如果类是final的，则没法生成代理对象，报错。
 * 如果方法是final的，代理无效
 *
 *
 * @author TF12778 2019/1/28 10:31
 */
public class HelloWorldCGlibImpl {

    public void showCGLibMsg() {
        System.out.println("CGLibMsg Test Success");
    }
}

2. 代理类

package com.sww.proxy;

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

import java.lang.reflect.Method;

/**
 * 使用Cglib动态代理
 *
 * @author TF12778 2019/1/28 10:35
 */
public class CGlibMethodInterceptor implements MethodInterceptor
{

    private Object target;

    public Object getInstance(Object target) {
        this.target = target;

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        //  设置回掉方法
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }

    /**
     *
     * @param o
     * @param method
     * @param objects
     * @param 实现MethodInterceptor接口要重写的方法
     * @return
     * @throws 回调方法
     */
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

        System.out.println("事物开始。。。。。。");
        Object result = methodProxy.invokeSuper(obj, args);
        System.out.println("事物结束。。。。。。");
        return result;
    }
}

3. 测试

package com.sww.proxy;

/**
 * JAVA JDK动态代理
 *
 * 代理是Java常用的设计模式，代理类通过调用被代理类的相关方法，并对相关方法进行增强。加入一些非业务性代码，比如事务、日志、报警发邮件等操作。
 *
 * @author TF12778 2019/1/28 09:44
 */
public class ProxyController {

    public static void main(String[] atgs){

    /**
     * CGLib 动态代理
     */
    CGlibMethodInterceptor cglibProxy = new CGlibMethodInterceptor();
    HelloWorldCGlibImpl  HelloCGlibImpl = (HelloWorldCGlibImpl)cglibProxy.getInstance(new HelloWorldCGlibImpl());
        HelloCGlibImpl.showCGLibMsg();

    }
}

测试结果：

事物开始。。。。。。
CGLibMsg Test Success
事物结束。。。。。。

三、总结

1、原理

   jdk静态代理实现比较简单，一般是直接代理对象直接包装了被代理对象。

　 jdk动态代理是接口代理，被代理类A需要实现业务接口，业务代理类B需要实现InvocationHandler接口。

    jdk动态代理会根据被代理对象生成一个继承了Proxy类，并实现了该业务接口的jdk代理类，该类的字节码会被传进去的ClassLoader加载，创建了jdk代理对象实例，

   jdk代理对象实例在创建时，业务代理对象实例会被赋值给Proxy类，jdk代理对象实例也就有了业务代理对象实例，同时jdk代理对象实例通过反射根据被代理类的业务方法创建了相应的Method对象m（可能有多个）。当jdk代理对象实例调用业务方法，如proxy.addUser();这个会先把对应的m对象作为参数传给invoke()方法（就是invoke方法的第二个参数），调用了jdk代理对象实例的invoke()回调方法，在invoke方法里面再通过反射来调用被代理对象的因为方法，即result = method.invoke(target, args);。

  cglib动态代理是继承代理，通过ASM字节码框架修改字节码生成新的子类，重写并增强方法的功能。

2、优缺点

     jdk静态代理类只能为一个被代理类服务，如果需要代理的类比较多，那么会产生过多的代理类。jdk静态代理在编译时产生class文件，运行时无需产生，可直接使用，效率好。

     jdk动态代理必须实现接口，通过反射来动态代理方法，消耗系统性能。但是无需产生过多的代理类，避免了重复代码的产生，系统更加灵活。

     cglib动态代理无需实现接口，通过生成子类字节码来实现，比反射快一点，没有性能问题。但是由于cglib会继承被代理类，需要重写被代理方法，所以被代理类不能是final类，被代理方法不能是final。

因此，cglib的应用更加广泛一点。

参考： https://www.cnblogs.com/fillPv/p/5939277.html