概念

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问。这种类型的设计模式属于结构型模式
代理模式一般包含三个角色：

抽象主题角色：主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类
真实主题角色：该类也被称为被代理类，该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象
代理主题角色：也被称为代理类，其内部持有真实主题角色的引用，因此具备完全的对真实主题角色的代理权。客户端调用代理对象的方法，同时也调用被代理对象的方法。

分类

代理模式又分为静态代理和动态代理

静态代理

在程序运行前就已经存在代理类的字节码文件，代理类与委托类的关系在运行前就已经确认

1.创建抽象主题角色类

public interface Payment {
    
    

    String doPqy(String uid);
}

2.创建真实主题角色类

public class ThirdChannelPayment implements Payment {
    
    
    public String doPqy(String uid) {
    
    
        System.out.println(uid+"->支付成功");
        return "success";
    }
}

3.创建代理主题角色类

public class StaticProxyDemo implements Payment{
    
    
    private Payment pay;

    public StaticProxyDemo(Payment payment) {
    
    
        this.pay=payment;
    }

    public String doPqy(String uid) {
    
    
        System.out.println(uid+"发起支付");
        return pay.doPqy(uid);
    }
}

4.测试类

public class ProxyDemo {
    
    

    public static void main(String[] args) {
    
    
        StaticProxyDemo pay=new StaticProxyDemo(new ThirdChannelPayment());
        System.out.println(pay.doPqy("Tom"));
        }
}

运行结果：
在这里插入图片描述
UML类图如下：

缺点

代理对象接口只服务于一种类型的对象，如果新增一个方法，所有的代理类都要实现此方法，增加了代码维护成本

动态代理

动态代理类的源码是在程序运行期间，通过JVM反射等机制动态生成，代理类和委托类的关系是在运行时才确认

JDK动态代理

使用jdk生成的动态代理的前提是目标类必须有实现的接口

1.动态代理类

public class DynamicProxy implements InvocationHandler {
    
    
    private Object target;//被代理的对象

    public Object bind(Object target){
    
    
        this.target=target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
        System.out.println("开始");
        Object result=method.invoke(target,args);
        System.out.println("结束");
        return result;
    }
}

2.测试类

public class ProxyDemo {
    
    

    public static void main(String[] args) {
    
    
       //jdk动态代理
        DynamicProxy dp=new DynamicProxy();
        ThirdChannelPayment pay=new ThirdChannelPayment();
        Payment p=(Payment) dp.bind(pay);
        System.out.println(p.doPqy("Jam"));
    }
}

运行结果：
在这里插入图片描述

CGLIB代理

使用前提是目标了不能为final修饰，因为final修饰的类不能被继承。是以动态生成的子类继承目标的方式实现。

代理类

public class CglibProxy 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();
    }
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    
    
        System.out.println("开始啦");
        Object obj=methodProxy.invokeSuper(o,objects);
        System.out.println("付款结束");
        return obj;
    }
}

测试

public class ProxyDemo {
    
    
    public static void main(String[] args) {
    
    
        //cglib代理
        CglibProxy cp=new CglibProxy();
        ThirdChannelPayment tp=new ThirdChannelPayment();
        Payment pay=(Payment) cp.getInstance(tp);
        System.out.println(pay.doPqy("Alia"));
    }
}

运行结果：
在这里插入图片描述

JDK动态代理和CGLIB代理的区别

JDK动态代理实现了被代理对象的接口，CGLIB代理继承了被代理对象
JDK动态代理和CGLIB代理都是在运行期生成字节码，JDK动态代理直接写class字节码，CGLIB代理使用ASM框架写class字节码。CGLIB代理实现更复杂，生成代理类比JDK动态代理效率低
JDK动态代理调用代理方法是通过反射机制调用的，CGLIB代理是通过FastClass机制直接调用方法的，CGLIB代理执行效率更高
在Spring框架在中，当Bean有实现接口时，Sring会用 JDK动态代理；当Bean没有实现接口时，Spring会选择CGLIB代理

静态代理与动态代理区别

静态代理只能通过手动完成代理操作，如果被代理类增加了方法，代理类需要同步增加，违背开闭原则
动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则

开闭原则：一个软件实体如类，模块和函数应该对扩展开放，对修改关闭。

总结

若动态代理要对目标类的增强逻辑进行扩展，可以结合策略模式，只需新增策略类即可完成，无需修改代理类的代码

代理模式的优点：

代理模式将代理对象与真实被调用目标对象分离，在一定程度上降低了系统的耦合性，扩展性好
可以起到保护目标对象的作用
可以增强目标对象的功能

代理模式的缺点：

代理模式会造成系统设计中类的数量增加，增加了系统的复杂度
在客户端和目标对象中增加一个代理对象，导致请求处理速度变慢

常见的设计模式之代理模式

概念

分类