设计模式-代理模式

        代理模式是一种常用的结构型设计模式，它主要通过代理对象来代替对真实对象的直接访问。这样做可以在不修改真实目标对象的前提下，增加额外的操作或者控制逻辑。在代理模式中，通常会有两个对象实现相同的接口或继承自同一个父类：一个是真实对象（RealSubject），负责具体的业务逻辑；另一个是代理对象（Proxy），它在客户端和真实对象之间起到中介的作用，可以对真实对象的访问进行控制，并在调用前后添加附加功能。

        举一个生活中常见的例子，租房过程中的中介公司就扮演了代理的角色。房客（客户端）通常不会直接与房东（真实对象）交涉，而是通过房屋中介（代理对象）来完成租房的过程。中介会提供房源信息，安排看房，处理租赁合同等，而房东则专注于提供和维护出租的房屋。这里的中介公司就是典型的代理角色，它控制并增强了租房过程，同时房东作为真实角色，专注于房屋的提供与维护。

---

静态代理

        静态代理是在编码阶段就确定了代理类和真实类的关系。这通常涉及到创建一个接口，然后创建两个类，一个是真实对象的实现类，另一个是代理类，两者都实现相同的接口。代理类通常会包含一个真实对象的引用，并在代理方法中调用真实对象的方法，同时可以在调用前后添加额外的逻辑。静态代理的优点是简单直接，易于理解，但它的缺点也很明显，就是每当接口发生变化时，都需要同时修改真实类和代理类，这会导致维护成本增加。

案例:

        假设有一个接口Subject：

public interface Subject { 
    void doSomething(); 
}

        真实对象RealSubject实现了该接口：

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject is doing something...");
    }
}

        代理对象Proxy也实现了该接口，并在构造函数中接收一个RealSubject对象作为参数：

public class Proxy implements Subject {

    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void doSomething() {
        System.out.println("Before calling doSomething() method...");
        realSubject.doSomething();
        System.out.println("After calling doSomething() method...");
    }
}

        在客户端代码中，可以通过代理对象来调用真实对象的doSomething()方法：

public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Proxy proxy = new Proxy(realSubject);
        proxy.doSomething();
    }
}

        输出结果为:

Before calling doSomething() method...
RealSubject is doing something...
After calling doSomething() method...

        可以看到，通过代理对象Proxy调用真实对象的方法时，可以在调用前后添加额外的逻辑，如打印日志等。这就是静态代理模式的基本实现方式。

---

JDK动态代理

        动态代理则在程序运行时动态生成代理类。Java中提供了InvocationHandler接口和Proxy类来实现动态代理。通过实现InvocationHandler接口，并重写invoke方法，可以在运行时决定代理的行为。而Proxy.newProxyInstance方法则用于生成代理类的实例。

案例:

        假设有一个接口Subject：

public interface Subject {
    void doSomething();
}

        真实对象RealSubject实现了该接口：

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject is doing something...");
    }
}

        接着定义一个调用处理器类MyInvocationHandler，它实现了InvocationHandler接口，并重写了invoke方法：

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

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

    //通过构造器传入目标对象
    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before calling " + method.getName() + "() method...");
        //使用反射调用目标对象的方法（被增强/代理的对象）
        Object result = method.invoke(target, args);
        System.out.println("After calling " + method.getName() + "() method...");
        //让代理也返回目标方法的执行结果
        return result;
    }
}

最后在客户端代码中使用JDK动态代理创建代理对象，并通过代理对象调用真实对象的方法：

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        //目标对象
        RealSubject realSubject = new RealSubject();

        MyInvocationHandler handler = new MyInvocationHandler(realSubject);

        //用于加载在运行期间动态生成的字节码
        ClassLoader loader = realSubject.getClass().getClassLoader();

        Subject proxy = (Subject)Proxy.newProxyInstance(loader,realSubject.getClass().getInterfaces(), handler);

        proxy.doSomething();
    }
}

        输出结果为：

Before calling doSomething() method...
RealSubject is doing something...
After calling doSomething() method...

        可以看到，通过JDK动态代理创建的代理对象可以拦截真实对象的方法调用，并在调用前后添加额外的逻辑。这就是JDK动态代理的基本实现方式。

---

CGLIB动态代理

        CGLIB动态代理是Java中实现动态代理的一种方式，它利用了ASM字节码技术。在CGLIB动态代理中，需要定义一个实现了MethodInterceptor接口的拦截器类，该类负责处理代理对象的方法调用。

        在Java中，当使用CGLIB库进行动态代理时，它会通过继承原始（目标）类来创建一个子类，并在子类中实现对方法调用的拦截和处理。这个子类是通过在运行时动态生成字节码并加载到JVM中的。由于子类继承了原始类的方法和属性，因此它可以被看作是原始类的子类型。

        这种代理机制允许CGLIB代理任何类型的对象，无论是实现了接口的还是普通的类。与JDK动态代理只能代理接口不同，CGLIB提供了更广泛的代理能力。

案例:        

    假设有一个接口Subject：

public interface Subject {
    void doSomething();
}

        真实对象RealSubject实现了该接口：

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject is doing something...");
    }
}

        接着定义一个拦截器类MyMethodInterceptor，它实现了MethodInterceptor接口，并重写了intercept方法：

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

import java.lang.reflect.Method;

public class MyMethodInterceptor implements MethodInterceptor {

    /**
        Object：这是由CGLIB生成的代理类实例，即被代理对象的实际实例。
        Method：这代表了实体类中被调用的代理方法的引用。
        Object[]：这个参数是一个数组，包含了传递给被调用方法的参数值。
        MethodProxy：这是代理类对方法的代理引用，可以用来调用原始方法。
    **/
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before calling " + method.getName() + "() method...");

        //反射调用
        //Object result = method.invoke(target,args);

        //可以避免反射调用
        //Object result = proxy.invoke(target, args);//需要目标
        Object result = proxy.invokeSuper(obj, args);//需要代理

        System.out.println("After calling " + method.getName() + "() method...");
        return result;
    }
}

        最后在客户端代码中使用CGLIB动态代理创建代理对象，并通过代理对象调用真实对象的方法：

import net.sf.cglib.proxy.Enhancer;

public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Enhancer enhancer = new Enhancer();

        //代理是子类型，目标是父类型
        enhancer.setSuperclass(realSubject.getClass());
        enhancer.setCallback(new MyMethodInterceptor());

        Subject proxy = (Subject) enhancer.create();
        proxy.doSomething();
    }
}

 输出结果为：

Before calling doSomething() method...
RealSubject is doing something...
After calling doSomething() method...

        可以看到，通过CGLIB动态代理创建的代理对象可以拦截真实对象的方法调用，并在调用前后添加额外的逻辑。这就是CGLIB动态代理的基本实现方式。

---

CGLIB代理和JDK代理的区别

代理实现方式

• JDK动态代理是通过Java的反射机制实现的。它要求目标类实现一个或多个接口，然后通过InvocationHandler接口的实现来处理方法调用。
• 而CGLIB动态代理则是通过操作字节码来实现的，它不要求目标类实现接口，而是通过MethodInterceptor接口的实现来拦截方法调用。

代理对象类型：

• JDK动态代理只能代理接口，这意味着如果一个类没有实现任何接口，那么JDK动态代理将无法对其进行代理。
• CGLIB动态代理则可以代理具体的类，即使目标类没有实现任何接口，CGLIB也可以创建其代理对象，它生成的代理类是目标的子类，因此代理与目标之间是子父关系。限制⛔：根据上述分析 final 类无法被 cglib 增强，也就是说目标不能被final修饰。