代理模式(JDK,CGLIB动态代理,AOP切面编程)

代理模式是一种结构型设计模式，它通过一个代理对象作为中间层来控制对目标对象的访问，从而增强或扩展目标对象的功能，同时保持客户端对目标对象的使用方式一致。

代理模式在Java中的应用,例如

1.统一异常处理

2.Mybatis使用代理

3.Spring AOP实现原理

4.日志框架

讲些空话,大话,大白话:

接口:定义行为规范,为了多态

实现类:对具体接口的实现(目标对象),被代理的类

代理类:做功能增强与扩展

静态代理:(常用于代理接口的实现类,也可以代理普通类)

代理接口的实现类

定义接口

public interface Service {
    void doWork();
}

 实现目标对象

public class RealService implements Service {
    @Override
    public void doWork() {
        System.out.println("RealService 正在执行工作。");
    }
}

创建代理类

public class ServiceProxy implements Service {
    private final Service realService; // 持有目标对象的引用

    //我还可以引入些其他,用来在doWork方法前后做增强或者扩展

    //private Xxxx   xxxx;可以构造中做初始化

    public ServiceProxy(Service realService) {
        this.realService = realService;
    }

    @Override
    public void doWork() {
        System.out.println("代理：调用方法之前记录日志...");
        realService.doWork(); // 调用目标对象的方法
        System.out.println("代理：调用方法之后记录日志...");
    }
}

测试静态代理

public class StaticProxyExample {
    public static void main(String[] args) {
        // 创建目标对象
        Service realService = new RealService();

        // 创建代理对象，并传入目标对象
        Service proxy = new ServiceProxy(realService);

        // 调用代理对象的方法
        proxy.doWork();
    }
}

静态代理在Boot中实际使用

---------------------------------------------------------------------------------------------------------------

代理普通类

// 目标类
public class RealService {
    public void doWork() {
        System.out.println("RealService 正在工作...");
    }
}

// 代理类
public class ServiceProxy {
    private RealService realService;

    public ServiceProxy(RealService realService) {
        this.realService = realService;
    }

    public void doWork() {
        System.out.println("代理: 调用方法之前...");
        realService.doWork();
        System.out.println("代理: 调用方法之后...");
    }
}

// 使用代理
public class Main {
    public static void main(String[] args) {
        RealService realService = new RealService();
        ServiceProxy proxy = new ServiceProxy(realService);
        proxy.doWork();
    }
}

JDK动态代理 

1.JDK 动态代理的特点

1. 必须基于接口：

   • 代理对象必须实现目标类的接口。
   • 如果目标类没有接口，JDK 动态代理无法使用。

2. 运行时动态生成代理对象：

   • 代理类的代码不是在编译时生成，而是在运行时动态创建。

3. 通过 InvocationHandler 实现增强逻辑：

   • 使用 InvocationHandler 接口处理方法的调用逻辑。
   • 可以对方法调用进行拦截，并添加额外的增强功能。

4. 生成的代理类是目标接口的实现类：

   • 代理对象的类型是接口类型，不能直接当作目标类使用。

2. JDK 动态代理的核心类

(1) Proxy 类

• Java 动态代理的核心类，用于生成代理对象。
• 方法：

  Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
  

  • ClassLoader loader：目标类的类加载器，用于加载代理对象。
  • Class<?>[] interfaces：目标类实现的接口数组。
  • InvocationHandler h：调用处理器，用于定义代理对象的方法逻辑。

(2) InvocationHandler 接口

• 用于定义代理对象的行为。
• 核心方法：

  Object invoke(Object proxy, Method method, Object[] args) throws Throwable
  

  • proxy：代理对象本身。
  • method：当前调用的方法。
  • args：调用方法的参数。

3. JDK 动态代理的实现步骤

(1) 定义接口和实现类

// 定义接口
public interface Service {
    void doWork();
}

// 实现类（目标类）
public class RealService implements Service {
    @Override
    public void doWork() {
        System.out.println("RealService 正在执行工作...");
    }
}

(2) 创建 InvocationHandler 该接口作用是方法拦截

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

public class ServiceInvocationHandler implements InvocationHandler {
    private Object target; // 持有目标对象的引用

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

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

(3) 创建代理对象

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        // 创建目标对象
        Service realService = new RealService();

        // 创建 InvocationHandler
        ServiceInvocationHandler handler = new ServiceInvocationHandler(realService);

        // 生成代理对象
        Service proxy = (Service) Proxy.newProxyInstance(
                realService.getClass().getClassLoader(), // 类加载器
                new Class<?>[]{Service.class},          // 实现的接口
                handler                                 // 调用处理器
        );

        // 调用代理对象的方法
        proxy.doWork();
    }
}

CGLIB代理