concept

Proxy Pattern refers to providing a proxy for other objects to control access to this object. This type of design pattern belongs to the structural pattern. The
agency pattern generally contains three roles:

Abstract theme role : The main responsibility is to declare the common interface method of the real theme and the agent. This class can be an interface or an abstract class
Real theme role : This class is also called the agent class, which defines the real object represented by the agent, and is responsible for the real logical business object of the execution system
Agent theme role : also known as the agent class, which holds a reference to the real theme role internally , so it has complete agency power for the real theme role . The client calls the methods of the proxy object and also calls the methods of the proxy object.

classification

The proxy mode is divided into static proxy and dynamic proxy

Static proxy

The bytecode file of the proxy class already exists before the program runs, and the relationship between the proxy class and the delegate class has been confirmed before running

1. Create an abstract theme role class

public interface Payment {
    
    

    String doPqy(String uid);
}

2. Create a real theme character class

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

3. Create agent theme role class

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. Test class

public class ProxyDemo {
    
    

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

Operation result:
Insert picture description here
UML class diagram is as follows:

Disadvantage

The proxy object interface only serves one type of object. If a new method is added, all proxy classes must implement this method, which increases the code maintenance cost

Dynamic proxy

The source code of the dynamic proxy class is dynamically generated through JVM reflection and other mechanisms during the running of the program, and the relationship between the proxy class and the delegate class is confirmed at runtime

JDK dynamic proxy

The premise of using the dynamic proxy generated by jdk is that the target class must have an implemented interface

1. Dynamic proxy class

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. Test class

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"));
    }
}

operation result:
Insert picture description here

CGLIB agent

The premise of use is that the target cannot be finalized, because final modified classes cannot be inherited. It is implemented in a way that dynamically generated subclasses inherit the target.

Proxy class

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;
    }
}

test

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"));
    }
}