代理模式是在我们的日常生活以及开发学习中应用十分广泛的一种设计模式；房屋租赁的过程中，我们如果没有办法可以直接找到房东，可以通过中介或者代理去完成承租；而在程序的世界里这样的例子也是数不胜数。

代理模式

与房屋租赁的场景类似，当客户端无法直接引用或者使用目标对象时，可以通过代理对象搭建起客户端对象与目标对象的桥梁；这样的设计思路，通过代理对象保护了目标对象，由代理对象担任客户端与目标对象的中介，便于扩展；而目标对象的职责也更加清晰明了。在代理模式中一般分为两种，一种是静态代理，一种是动态代理。

静态代理

静态代理是指在程序编译阶段就已经明确了代理对象与目标对象的关系。

java代码实现如下：

接口类：

public interface PayInterface {

    /**
     * 支付接口
     */
    String pay();

}

目标类：

//目标类实现接口
public class PayImpl implements PayInterface {

    @Override
    public String pay() {
        System.out.println("支付成功");
        return "pay success";
    }
}

代理类：

//实现接口，职责由具体实现类完成
public class PayProxy implements PayInterface {

    /**目标对象*/
    private PayInterface payInterface;
    
    /**代理对象*/
    public PayProxy(PayInterface payInterface) {
        this.payInterface = payInterface;
    }
        
    @Override
    public String pay() {
        System.out.println("进入代理类");
        return payInterface.pay();
    }
}

演示Demo：

/**
 * 代理模式示例
 * 静态代理
 */
public class ProxyDemo {


    public static void main(String[] args) {
        PayProxy payProxy = new PayProxy(new PayImpl());
        payProxy.pay();
    }

}

静态代理有如下优缺点：

优点：可以在不修改目标对象的前提下扩展目标对象的功能。

缺点：

冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

动态代理

动态代理则是在程序运行阶段才明确代理对象与目标对象的关系；我们常见的动态代理的实现方式有两种；一种是jdk的动态代理，一种是cglib的动态代理；以下我们分别来演示一下两种实现。

jdk动态代理

特点：
动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理

接口类与实现类：同上

public interface PayInterface {

    /**
     * 支付接口
     */
    String pay();

}

public class PayImpl implements PayInterface {

    @Override
    public String pay() {
        System.out.println("支付成功");
        return "pay success";
    }
}

代理类如下：

//需要实现InvocationHandler 接口
public class DynamicPayProxy implements InvocationHandler {

    /**目标对象*/
    private Object target;


    /**获取代理对象实例*/
    public Object newProxyInstance(Object target) {
        this.target = target;
        Class<?> clazz = target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }

    /**方法调用*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入代理类");
        Object invoke = null;
        try {
            invoke = method.invoke(target, args);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return invoke;
    }
}

演示Demo：

public class DynamicProxyDemo {

    public static void main(String[] args) {
        DynamicPayProxy proxy = new DynamicPayProxy();
        PayInterface payInstance =
               (PayInterface) proxy.newProxyInstance(new PayImpl());
        payInstance.pay();
    }
}

通过比较动态代理与静态代理的代理类的实现，我们发现代理的目标对象从PayInterface 升级为 Object ;方法也不在局限于 pay()方法。动态代理还有另一种实现是通过cglib，需要引入相关的jar包

cglib动态代理

cglib特点

  • JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口；如果想代理没有实现接口的类，就可以使用CGLIB实现。

  • CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。
    它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

  • CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。
    不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

代码实现：

目标类与jdk目标类一致，不再需要接口类PayInterface：

public class PayImpl implements PayInterface {

    @Override
    public String pay() {
        System.out.println("支付成功");
        return "pay success";
    }
}

代理类：

/**需要引入cglib相关jar包*/
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

//需要实现MethodInterceptor
public class CglibPayProxy implements MethodInterceptor {


    /**
     * 构建代理对象
     * 代理对象是目标类的子类
     */
    public Object newProxyInstance(Object target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("进入cglib代理类");
        return methodProxy.invokeSuper(o, objects);
    }
}

演示demo：

public class CglibProxyDemo {

    public static void main(String[] args) {
        CglibPayProxy proxy = new CglibPayProxy();
        PayInterface payInstance = 
                (PayInterface) proxy.newProxyInstance(new PayImpl());
        payInstance.pay();
    }
}

通过调试以上代码，我们发现

  • jdk的动态代理，依赖接口类，可以说是在接口的基础上实现的代理；需要实现InvocationHandler

  • 而cglib的动态代理是通过构建目标类的子类，然后通过子类调用父类方法来实现的，所以声明为final的类将无法被代理；需要实现MethodInterceptor。