代理设计模式

crysw

已于 2023-12-12 22:47:17 修改

阅读量494

点赞数

分类专栏：设计模式文章标签：设计模式 java

于 2023-12-12 22:42:47 首次发布

本文链接：https://blog.csdn.net/u013044713/article/details/134960845

版权

设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1. 代理模式

1.1 代理模式的原理分析

代理设计模式（Proxy Design Pattern）是一种结构型设计模式，它为其他对象提供一个代理对象，以控制对这个对象的访问。代理模式可以用于实现懒加载、安全访问控制、日志记录等功能。

代理模式（Proxy Design Pattern）在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。

在设计模式中，代理模式可以分为静态代理和动态代理。静态代理是指代理类在编译时就已经确定，而动态代理是指代理类在运行时动态生成。

1.2 静态代理使用场景

1.2.1 缓存代理

缓存代理（Caching Proxy）是一种特殊类型的代理模式，它可以为耗时的操作或者重复的请求提供缓存功能，从而提高程序执行效率。缓存代理通常会在内部维护一个缓存数据结构，如 HashMap , 用来存储已经处理过的请求及其结果。
以下是一个缓存代理的应用示例：
假设有一个数据查询接口，它从数据库或其他数据源中检索数据。在没有缓存代理的情况下，每次查询都需要访问数据库，这可能会导致较高的资源消耗和延迟。通过引入缓存代理，我们可以将查询结果存储在内存中，从而避免重复查询数据库。
首先，我们定义一个数据查询接口：

/**
 * 接口描述：数据查询接口
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/4 23:17
 */
public interface DataQuery {

    String query(String queryKey);
}

具体的数据查询实现类（被代理的对象），它从数据库中检索数据：

/**
 * 类描述：数据查询类，它从数据库中检索数据
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/4 23:18
 */
@Slf4j
public class DatabaseDataQuery implements DataQuery {
    @Override
    public String query(String queryKey) {
        log.info(">>>{}", "Result from database:" + queryKey);
        return queryKey + "-val";
    }
}

接下来，我们创建一个缓存代理类，它实现了 DataQuery 接口，并在内部使用HashMap 作为缓存：

/**
 * 类描述：缓存代理类，内部使用HashMap作为缓存
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/4 23:20
 */
public class CachingDataQueryProxy implements DataQuery {

    private static final Map<String, String> CACHE = new HashMap<>();

    /**
     * 被代理对象
     */
    private final DatabaseDataQuery dataQuery;

    public CachingDataQueryProxy() {
        // 屏蔽被代理的对象
        this.dataQuery = new DatabaseDataQuery();
    }

    @Override
    public String query(String queryKey) {
        // 对被代理对象做增强; 查询缓存，命中则返回，否则查database
        String result = CACHE.get(queryKey);
        if (result != null) {
            System.out.println("命中缓存");
            return result;
        }

        System.out.println("没有命中缓存，继续查database");
        result = dataQuery.query(queryKey);

        if (result != null) {
            // 同步缓存
            CACHE.put(queryKey, result);
            System.out.println("命中database，同步缓存");
            return result;
        }

        return null;
    }
}

在客户端代码中（测试案例）使用缓存代理：

/**
 * 类描述：代理设计模式测试案例
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/4 23:28
 */
@Slf4j
public class ProxyPatternTest {

    /**
     * 测试静态代理
     */
    @Test
    public void testStaticProxy() {
        DataQuery dataQuery = new CachingDataQueryProxy();
        // 第一次查询，从数据库中获取数据并将其缓存
        String value = dataQuery.query("key1");
        System.out.println(value);
        // 第二次查询相同的数据，从缓存中获取
        value = dataQuery.query("key1");
        System.out.println(value);

    }
}

通过以上示例，你可以看到缓存代理如何提供缓存功能，以提高程序的执行效率。

1.2.2 安全代理

安全代理（Security Proxy）是一种代理模式的应用，它用于控制对真实主题对象的访问。通过安全代理，可以实现访问控制、权限验证等安全相关功能。

假设我们有一个敏感数据查询接口，只有具有特定权限的用户才能访问；首先，我们定义一个数据查询接口：

/**
 * 类描述：数据查询接口（安全代理）
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/7 22:45
 */
public interface SensitiveDataQuery {
    String queryData(String userId);   
}

接着，实现一个真实的敏感数据查询类：

/**
 * 类描述：敏感数据查询的具体实现类 （被安全代理的对象）
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/7 22:47
 */
public class SensitiveDataQueryImpl implements SensitiveDataQuery {
    @Override
    public String queryData(String userId) {
        // 查询敏感数据并返回结果
        return "Sensitive data for user: " + userId;
    }
}

然后，我们创建一个安全代理类，它实现了 SensitiveDataQuery 接口，并在内部进行权限验证：

/**
 * 类描述：敏感数据查询的代理类
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/7 22:49
 */
public class SecurityProxy implements SensitiveDataQuery {

    private final SensitiveDataQuery sensitiveDataQuery;
    private final UserAuthenticator userAuthenticator;

    public SecurityProxy(SensitiveDataQuery sensitiveDataQuery, UserAuthenticator userAuthenticator) {
        this.sensitiveDataQuery = sensitiveDataQuery;
        this.userAuthenticator = userAuthenticator;
    }
    
    public static UserAuthenticator getUserAuthenticator() {
        return new UserAuthenticator();
    }

    @Override
    public String queryData(String userId) {
        if (userAuthenticator.hasPermission(userId)) {
            return sensitiveDataQuery.queryData(userId);
        } else {
            return "Access Denied: Insufficient permission for user " + userId;
        }
    }

    /**
     * 我们使用一个 UserAuthenticator 类来模拟用户权限验证
     */
    static class UserAuthenticator {
        private final List<String> authorizedUserIds;

        public UserAuthenticator() {
            // 模拟从数据库或配置文件中获取已授权的用户列表
            authorizedUserIds = Arrays.asList("user1", "user2", "user3");
        }

        public boolean hasPermission(String userId) {
            return authorizedUserIds.contains(userId);
        }
    }
}

测试案例：在客户端代码中使用安全代理

/**
 * 测试静态代理-安全代理
 */
@Test
public void SecurityProxy() {
    // 被代理的对象
	SensitiveDataQueryImpl sensitiveDataQuery = new SensitiveDataQueryImpl();
    // 代理对象
	SecurityProxy securityProxy = new SecurityProxy(sensitiveDataQuery, SecurityProxy.getUserAuthenticator());
    // 代理对象调用方法
	String user = securityProxy.queryData("user");
	log.info(">>>user:{}", user);
	user = securityProxy.queryData("user2");
	log.info(">>>user:{}", user);
}

写了缓存代理和安全代理两个例子后，我觉得它们实现的方式和装饰者设计模式很像。实际上，代理模式和装饰者模式之间有一定的相似性。两者都属于结构型设计模式，它们都使用组合而不是继承来扩展对象的行为。这两种模式都涉及到一个接口和一些实现该接口的类，其中一个类充当代理或装饰者，将对接口方法的调用委托给另一个代理类或装饰类。

1.2.3 虚拟代理

虚拟代理（Virtual Proxy）是一种代理模式，用在需要延迟创建耗时或资源密集型对象。虚拟代理在初始访问时才创建实际对象，之后将直接使用该对象。这可以避免在实际对象尚未使用的情况下就创建它，从而节省资源。（有点儿预加载的味道）

假设我们有一个大型图片类，它从网络加载图像。由于图像可能非常大，我们希望在需要显示时才加载它。为了实现这一点，我们可以创建一个虚拟代理来代表大型图片类。首先，我们定义一个图片接口：

/**
 * 接口描述：大型图片抽象接口
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/7 23:07
 */
public interface Image {
    void display();
}

然后，实现一个大型图片类（被代理的类），它从网络加载图像并实现 display() 方法：

/**
 * 类描述：大型图片实现类（被代理的类）
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/7 23:09
 */
@Slf4j
public class LargeImage implements Image {
    private final String imageUrl;

    public LargeImage(String imageUrl) {
        this.imageUrl = imageUrl;
        // 加载图片资源
        this.loadImageFromNetwork();
    }

    private void loadImageFromNetwork() {
        log.info("Loading image from network: {}", imageUrl);
        // 真实的图像加载逻辑...
    }

    @Override
    public void display() {
        // 使用图片资源
        log.info(">>>Displaying image: {}", imageUrl);
    }
}

接下来，我们创建一个虚拟代理类，它实现了 Image 接口，并在内部使用LargeImage ：

/**
 * 类描述：大型图片的代理类
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/7 23:15
 */
public class VirtualImageProxy implements Image {

    private final String imgUrl;

    private Image image;

    public VirtualImageProxy(String imgUrl) {
        this.imgUrl = imgUrl;
    }

    @Override
    public void display() {
        if (image == null) {
            image = new LargeImage(imgUrl);
        }

        image.display();
    }
}

测试案例：在客户端代码中使用虚拟代理

/**
 * 测试静态代理-虚拟代理
 */
@Test
public void testVirtualProxy() {
	// 代理对象
	VirtualImageProxy virtualImageProxy = new VirtualImageProxy("https://example.com/large-image.jpg");
	log.info("Image will not be loaded until it is displayed.");
	// 调用 display() 方法时，才会创建并加载大型图片
	virtualImageProxy.display();
}

通过这个示例，你可以看到虚拟代理如何实现懒加载，以减少资源消耗和提高程序性能。当实际对象的创建和初始化非常耗时或占用大量资源时，虚拟代理是一个很好的选择。

1.2.4 远程代理

远程代理（Remote Proxy）是一种代理模式，用于访问位于不同地址空间的对象。远程代理可以为本地对象提供与远程对象相同的接口，使得客户端可以透明地访问远程对象。通常远程代理需要处理网络通信、序列化和反序列化等细节。

以下是一个简化的远程代理示例。首先，我们定义一个服务接口：

/**
 * 接口描述：远程代理接口
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/11 22:49
 */
public interface RemoteService {
    String fetchData(String dataId);
}

被代理的类，实现远程代理的接口。

/**
 * 类描述：远程代理接口实现类
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/11 22:50
 */
public class RemoteServiceImpl implements RemoteService {
    @Override
    public String fetchData(String dataId) {
        // 实际操作，例如从数据库获取数据
        return "Data from remote service: " + dataId;
    }
}

创建一个远程代理类，它实现了 RemoteService 接口，并在内部处理网络通信等细节：

/**
 * 类描述：远程代理的代理类
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/11 22:51
 */
@Slf4j
public class RemoteServiceProxy implements RemoteService {

    private final String remoteUrl;

    private RemoteService remoteService;

    public RemoteServiceProxy(String remoteUrl) {
        this.remoteUrl = remoteUrl;
        // 被代理的对象
        remoteService = new RemoteServiceImpl();
    }

    @Override
    public String fetchData(String dataId) {
        // 网络通信、序列化和反序列化等逻辑
        log.info("Connecting to remote service at:{} ", remoteUrl);
        // 假设我们已经获取到远程服务的数据
        String result = remoteService.fetchData(dataId);
        System.out.println("Received data from remote service.");
        return result;
    }
}

测试案例：在客户端代码中使用远程代理

/**
 * 测试静态代理-远程代理
 */
@Test
public void testRemoteServiceProxy() {
	// 创建代理对象
	RemoteService remoteService = new RemoteServiceProxy("https://example.com/remote-service");
	// 使用远程代理访问远程服务
	String dataId = "example_data_id";
	String result = remoteService.fetchData(dataId);
	log.info("Result:{}", result);
}

为了简化代码，这里省略了实际的网络通信、序列化和反序列化逻辑。在实际应用中可以使用 Java RMI、RPC 或其他远程通信库来实现远程代理。

1.2.5 静态代理总结

通过前四个案例，大致了解了静态代理的使用方式，流程如下：

创建一个接口，定义代理类和被代理类共同实现的方法
创建被代理类，实现这个接口，并且在其中定义实现方法
创建代理类，也要实现这个接口，同时在其中定义一个被代理类的对象作为成员变量
在代理类中实现接口中的方法，方法中调用被代理类中的对应方法
通过创建代理对象，并调用其方法，方法增强

这样，被代理类的方法就会被代理类所覆盖，实现了对被代理类的增强或修改。

1.3 动态代理

Java 中动态代理的实现方式主要有两种：基于 JDK 的动态代理和基于 CGLIB 的动态代理。

静态代理需要手动编写代理类，代理类与被代理类实现相同的接口或继承相同的父类，对被代理对象进行包装。在程序运行前，代理类的代码就已经生成，并在程序运行时调用。静态代理的优点是简单易；缺点是需要手动编写代理类，代码复杂度较高，且不易扩展。

动态代理是在程序运行时动态生成代理类，无需手动编写代理类，大大降低了代码的复杂度。动态代理一般使用 Java 提供的反射机制实现，可以对任意实现了接口的类进行代理。动态代理的优点是灵活性高，可以根据需要动态生成代理类；缺点是性能相对较低，由于使用反射机制，在运行时会产生额外的开销。

总之，静态代理和动态代理都是代理模式的实现方式，其主要区别在于代理类的生成时机和方式。静态代理需要手动编写代理类，适用于代理类数量较少、不需要频繁修改的场景。而动态代理不需要手动编写代理类，可以动态生成代理类，适用于代理类数量较多、需要频繁修改的场景。

1.3.1 JDK动态代理

基于 JDK 的动态代理需要使用 java.lang.reflect.Proxy 类和java.lang.reflect.InvocationHandler 接口。我们依旧使用上述的缓存代理的案例来实现。首先定义一个接口，声明需要代理的方法：

/**
 * 接口描述：被代理对象的抽象接口
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/5 22:04
 */
public interface DataQueryService {
    String query(String queryKey);

    String queryAll(String queryKey);
}

创建一个被代理类，实现这个接口，并在其中定义实现方法：

/**
 * 类描述：被代理的对象类
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/5 22:04
 */
@Slf4j
public class DatabaseDataQuery implements DataQueryService {
    @Override
    public String query(String queryKey) {
        // 使用数据源从数据库查询数据很慢
        log.info(">>>query,正在从数据库查询数据");
        return "value1 from database";
    }

    @Override
    public String queryAll(String queryKey) {
        // 使用数据源从数据库查询数据很慢
        log.info(">>>queryAll,正在从数据库查询数据");
        return "all data from database";
    }
}

创建一个代理类，在代理类中实现了 InvocationHandler 接口，并在其中定义了一个被代理类的对象作为target属性。在 invoke 方法中，我们可以对被代理对象的方法进行增强，并在方法调用前后输出日志。

/**
 * 类描述：代理对象类
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/5 22:06
 */
@Slf4j
public class CacheInvocationHandler implements InvocationHandler {

    /**
     * 缓存容器
     */
    private static final Map<String, String> CACHE = new LinkedHashMap<>(256);

    /**
     * 被代理的对象
     */
    private DatabaseDataQuery target;

    public CacheInvocationHandler() {
    }

    public CacheInvocationHandler(DatabaseDataQuery target) {
        this.target = target;
    }

    /**
     * 建立代理对象和目标对象之间的代理关系，并返回代理的对象
     *
     * @param target 被代理的目标(真实)对象
     * @return 返回代理的对象
     */
    public Object bind(DatabaseDataQuery target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    /**
     * 对被代理对象的指定method执行进行增强
     *
     * @param proxy  代理对象
     * @param method 被代理对象的调用的方法对象
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        String result;
        String methodName = method.getName();
        // 对query方法的执行进行增强
        if (Objects.equals("query", methodName)) {
            // 先查缓存，如果命中则返回
            log.info(">>>invoke,查缓存");
            result = CACHE.get(args[0].toString());

            if (result != null) {
                return result;
            }

            log.info(">>>invoke, 查数据库");
            // 反射调用
            result = (String) method.invoke(this.target, args);
            // 同步缓存
            log.info(">>>invoke, 同步缓存");
            CACHE.put(args[0].toString(), result);
            return result;
        }

        // 当其他的方法被调用，不希望被干预，直接调用原生的方法
        return method.invoke(this.target, args);
    }
}

测试案例：在使用代理类时，创建被代理类的对象和代理类的对象，并使用Proxy.newProxyInstance 方法生成代理对象。

/**
 * 类描述：代理设计模式测试案例
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/4 23:28
 */
@Slf4j
public class ProxyPatternTest {
    /**
     * 测试jdk实现的动态代理
     */
    @Test
    public void testJdkProxy() {
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        Class[] interfaces = {DataQueryService.class};
        // 动态代理的 InvocationHandler 对象
        InvocationHandler invocationHandler = new CacheInvocationHandler(new DatabaseDataQuery());
        // 代理对象
        DataQueryService proxyObject = (DataQueryService) Proxy.newProxyInstance(contextClassLoader, interfaces, invocationHandler);
        String value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.queryAll("key1");
        log.info(">>>value1:{}", value1);

    }

    @Test
    public void testJdkProxy2() {
        // 被代理的真实对象
        DatabaseDataQuery databaseDataQuery = new DatabaseDataQuery();
        // 动态代理的 InvocationHandler 对象
        CacheInvocationHandler invocationHandler = new CacheInvocationHandler();
        // 绑定目标对象，生成代理对象
        DataQueryService proxyObject = (DataQueryService) invocationHandler.bind(databaseDataQuery);
        // 访问查询方法，调度代理方法
        String value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.queryAll("key1");
        log.info(">>>value1:{}", value1);
    }
}

1.3.2 CGLIB动态代理

基于 CGLIB 的动态代理需要使用 net.sf.cglib.proxy.Enhancer 类和net.sf.cglib.proxy.MethodInterceptor 接口，先导入相关依赖。

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.1_3</version>
</dependency>

开干，先创建一个被代理类，定义需要被代理的方法。

/**
 * 类描述：被代理的对象类（没有抽象接口），使用cglib代理
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/5 23:05
 */
@Slf4j
public class DatabaseQuery {

    public String query(String queryKey) {
        // 使用数据源从数据库查询数据很慢
        log.info(">>>query,正在从数据库查询数据");
        return "value1 from database";
    }

    public String queryAll(String queryKey) {
        // 使用数据源从数据库查询数据很慢
        log.info(">>>queryAll,正在从数据库查询数据");
        return "all data from database";
    }
}

再来创建一个方法拦截器类，在这个代理类中实现 MethodInterceptor 接口，并在其中定义一个被代理类的对象作为target属性。在 intercept 方法中，我们可以对被代理对象的方法进行增强，并在方法调用前后输出日志。

/**
 * 类描述：cglib代理的方法拦截器
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/5 23:06
 */
@Slf4j
public class CacheMethodInterceptor implements MethodInterceptor {

    /**
     * 缓存容器
     */
    private static final Map<String, String> CACHE = new LinkedHashMap<>(256);

    /**
     * 被代理的对象
     */
    private DatabaseQuery target;

    public CacheMethodInterceptor() {
    }

    public CacheMethodInterceptor(DatabaseQuery target) {
        this.target = target;
    }

    /**
     * 生成 CGLib 代理对象
     *
     * @param clazz 被代理的Class类
     * @return
     */
    public Object getProxy(Class clazz) {
        // CGLib enhancer增强类对象
        Enhancer enhancer = new Enhancer();
        // 设置增强类型父类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器，定义代理逻辑对象为当前对象，要求当前对象实现 MethodInterceptor 接口
        enhancer.setCallback(this);
        // 生成并返回代理对象
        return enhancer.create();
    }

    /**
     * 代理方法的增强处理
     *
     * @param proxy       代理对象
     * @param method      方法
     * @param args        方法参数
     * @param methodProxy 代理方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        String result;
        String methodName = method.getName();
        // 对query方法的执行进行增强
        if (Objects.equals("query", methodName)) {
            // 先查缓存，如果命中则返回
            log.info(">>>invoke,查缓存");
            result = CACHE.get(args[0].toString());

            if (result != null) {
                return result;
            }

            log.info(">>>invoke, 查数据库");
            // 反射调用
            result = (String) method.invoke(this.target, args);
            // 同步缓存
            log.info(">>>invoke, 同步缓存");
            CACHE.put(args[0].toString(), result);
            return result;
        }

        // 当其他的方法被调用，不希望被干预，直接调用原生的方法
        return method.invoke(this.target, args);
    }
}

测试案例：在使用代理类时，创建被代理类的对象和代理类的对象，并使用Enhancer.create 方法生成代理对象。

/**
 * 类描述：代理设计模式测试案例
 *
 * @Author crysw
 * @Version 1.0
 * @Date 2023/12/4 23:28
 */
@Slf4j
public class ProxyPatternTest {
    @Test
    public void testCglibProxy() {
        // CGLib enhancer增强类对象
        Enhancer enhancer = new Enhancer();
        // 设置增强类型父类
        enhancer.setSuperclass(DatabaseQuery.class);
        // 设置方法拦截器，定义代理逻辑对象为当前对象，要求当前对象实现 MethodInterceptor 接口
        enhancer.setCallback(new CacheMethodInterceptor(new DatabaseQuery()));
        // 生成并返回代理对象
        DatabaseQuery proxyObject = (DatabaseQuery) enhancer.create();
        // 访问查询方法，调度代理方法
        String value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.queryAll("key1");
        log.info(">>>value1:{}", value1);
    }

    @Test
    public void testCglibProxy2() {
        // 创建方法拦截器对象，并设置被代理的对象
        CacheMethodInterceptor cacheMethodInterceptor = new CacheMethodInterceptor(new DatabaseQuery());
        // 生成代理对象
        DatabaseQuery proxyObject = (DatabaseQuery) cacheMethodInterceptor.getProxy(DatabaseQuery.class);
        // 访问查询方法，调度代理方法
        String value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.query("key1");
        log.info(">>>value1:{}", value1);

        value1 = proxyObject.queryAll("key1");
        log.info(">>>value1:{}", value1);
    }
}

在实际应用中，基于 CGLIB 的动态代理可以代理任意类，但是生成的代理类比较重量级。如果被代理类是一个接口，建议使用基于 JDK 的动态代理来实现，这也是spring的做法；如果被代理类没有实现接口或者需要代理的方法是 final 方法，建议使用基于 CGLIB 的动态代理来实现。

1.3.3 Spring AOP

1.3.3.1 Spring AOP的使用

在 Spring 中，AOP（面向切面编程）提供了一种有效的方式来对程序中的多个模块进行横切关注点的处理，例如日志、事务、缓存、安全等。使用 Spring AOP可以在程序运行时动态地将代码织入到目标对象中，从而实现对目标对象的增强。

Spring AOP 的使用步骤如下：

（1）引入 AOP 相关依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

（2）开启自动代理@EnableAspectJAutoProxy

@SpringBootApplication
@EnableAspectJAutoProxy
public class Main {
    public static void main(String[] args) {
    	SpringApplication.run(Main.class, args);
    }
}

（3）定义接口和实现类，并将具体实现注入容器：

public interface DataQuery {
	String query(String queryKey);
}
@Component
public class DatabaseDataQuery implements DataQuery {
    @Override
    public String query(String queryKey) {
        // 他会使用数据源从数据库查询数据很慢
        System.out.println("正在从数据库查询数据");
        return "result";
    }
}

（4）定义切面类，对方法做增强

@Component
@Aspect
public class CacheAspectj {
    // 定义切点
    @Pointcut("execution(*cn.itcast.dynamicProxy.aop.DatabaseDataQuery.query(..))")
    public void pointcut() {}
    // 定义通知
    @Around("pointcut()")
    public String around(ProceedingJoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String key = args[0].toString();
        // 1、查询缓存，命中则返回
        String result = Cache.get(key);
        if(result != null){
            System.out.println("数据从缓存中获取");
            return result;
    	}
        // 未命中则去数据库查询，实际上是调用被代理bean的方法
        try {
            result = joinPoint.proceed().toString();
            // 如果查询有结果，进行缓存
            Cache.put(key,result);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        return result;
    }
}

定义缓存

public class Cache {
    private static Map<String,String> map = new ConcurrentHashMap<>(256);
        public static String get(String key){
        return map.get(key);
    }
    public static void put(String key,String value){
    	map.put(key, value);
    }
}

（5）测试. 在使用增强后的 Bean 时，Spring AOP 会自动代理这些 Bean，并在方法调用前后调用相应的通知方法。

@SpringBootTest
public class AopTest {
    @Resource
    private DataQuery dataQuery;
    @Test
    public void testAop(){
        dataQuery.query("key1");
        dataQuery.query("key1");
        dataQuery.query("key2");
    }
}

在使用 Spring AOP 时，还需要注意以下几点：

如果目标对象实现了接口，则默认使用 JDK 动态代理进行代理；如果目标对象没有实现接口，则使用 CGLIB 进行代理。如果想要强制使用 CGLIB 进行代理，可以在配置类中使用 @EnableAspectJAutoProxy(proxyTargetClass =true) 注解。
前置通知、后置通知、环绕通知等通知类型都可以使用 @Before 、@After 、@Around 等注解进行定义。在通知方法中，可以通过 JoinPoint 参数获取目标方法的参数等信息。
如果需要将通知方法定义在不同的切面中，可以使用 @Order 注解指定切面的执行顺序。
如果需要在同一个通知方法中定义多个切点，可以使用 && 和 || 等逻辑运算符来组合切点表达式。

1.3.3.2 代理与Spring AOP的区别

面向切面编程（AOP）和代理是两个相关但不同的概念。

代理是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式可以分为静态代理和动态代理两种。

在静态代理中，代理类和被代理类都必须实现同一个接口，代理类通过实现接口的方式来实现被代理类的功能，并在调用被代理类的方法前后执行一些额外的逻辑实现增强。在动态代理中，代理类是在运行时动态生成的，不需要实现接口，通过 Java 反射机制来
动态地生成代理对象，从而实现对被代理类的增强。

AOP 是一种编程范式，它通过对程序中的多个模块进行横切关注点的处理实现对程序行为的增强。AOP 的实现方式可以有多种，例如基于代理、基于字节码增强、基于注解等。 Spring AOP是一种常见的AOP 实现方式。

在 Spring AOP 中，切面是 AOP 的核心概念，它由切点和通知组成。切点定义了哪些方法或类需要被增强，通知则定义了增强的具体逻辑。在基于代理的 AOP 实现方式中，代理类负责在调用被代理对象的方法前后调用相应的通知方法，从而实现对被代理对象的增强。

因此，代理和 AOP 是两个相关的概念，代理是 AOP 的一种实现方式，它们都可以用于在程序中实现对目标对象的增强。区别在于，代理主要是针对单个对象的方法调用进行增强，而 AOP 则是针对程序中多个模块的横切关注点进行增强。

1.4 动态代理应用场景

1.4.1 API速率限制

这是一个使用 Spring AOP 实现 API 速率限制的简单示例。我们将使用 Spring Boot和 Spring AOP。

添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

接下来，我们创建一个自定义注解 RateLimiter ，用于标记需要进行速率限制的方法：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimiter {
    int value() default 1;
    int durationInSeconds() default 1;
}

创建一个切面类（Aspect），实现速率限制的逻辑。这里我们使用Google Guava 提供的 RateLimiter 类

@Aspect
@Component
public class RateLimiterAspect {
	private final ConcurrentHashMap<String, RateLimiter> rateLimiters = new ConcurrentHashMap<>();
	// 定义切点
	@Pointcut("@annotation(rateLimiterAnnotation)")
	public void rateLimiterPointcut(RateLimiter rateLimiterAnnotation) {}
	// 定义环绕通知
	@Around("rateLimiterPointcut(rateLimiterAnnotation)")
	public Object around(ProceedingJoinPoint joinPoint, RateLimiterrateLimiterAnnotation) throws Throwable {
		int permits = rateLimiterAnnotation.value();
		int durationInSeconds = rateLimiterAnnotation.durationInSeconds();
		// 使用方法签名作为 RateLimiter 的 key
		String key = joinPoint.getSignature().toLongString();
		com.google.common.util.concurrent.RateLimiter rateLimiter = rateLimiters.computeIfAbsent(key, k ->
			com.google.common.util.concurrent.RateLimiter.create((double) permits / durationInSeconds)
		);
		// 尝试获取令牌，如果获取到则执行方法，否则抛出异常
		if (rateLimiter.tryAcquire()) {
			return joinPoint.proceed();
		} else {
			throw new RuntimeException("Rate limit exceeded.");
		}
	}
}

在这个切面类中，我们定义了一个名为 rateLimiterPointcut 的切入点，用于匹配带有 @RateLimiter 注解的方法。around 方法用 @Around 注解标注，实现了速率限制的逻辑。我们使用 ConcurrentHashMap 存储 RateLimiter 实例，以便在多线程环境下安全地访问它们。

最后，可以在需要进行速率限制的方法上添加 @RateLimiter 注解。

@RestController
public class ApiController {
	@GetMapping("/api/limited")
	@RateLimiter(value = 10, durationInSeconds = 60) //限制为每分钟 10 次请求
	public String limitedEndpoint() {
		return "This API has a rate limit of 10 requests per minute.";
	}
	
	@GetMapping("/api/unlimited")
	public String unlimitedEndpoint() {
		return "This API has no rate limit.";
	}
}

1.4.2 重试机制

使用 Spring AOP 实现重试机制的示例。首先创建一个自定义注解Retry ，用于标记需要进行重试的方法：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Retry {
    int maxAttempts() default 3;
    long delayInMillis() default 1000;
    Class<? extends Throwable>[] retryOn() default {Throwable.class};
}

需要创建一个切面类（Aspect），实现重试的逻辑：

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

@Aspect
@Component
public class RetryAspect {
    // 定义切点
    @Pointcut("@annotation(retryAnnotation)")
    public void retryPointcut(Retry retryAnnotation) { }
	// 定义环绕通知
    @Around("retryPointcut(retryAnnotation)")
    public Object around(ProceedingJoinPoint joinPoint, Retry retryAnnotation) throws Throwable {
        // 获取注解配置的最大重试次数
        int maxAttempts = retryAnnotation.maxAttempts();
        // 获取延迟时间 ms
        long delayInMillis = retryAnnotation.delayInMillis();
        Set<Class<? extends Throwable>> retryOn = new HashSet<>
                ( Arrays.asList(retryAnnotation.retryOn()) );
        // 统计重试次数
        int attempts = 0;
        while (true) {
            try {
                attempts++;
                // 放开，执行被代理的方法
                return joinPoint.proceed();
            } catch (Throwable throwable) {
                if (attempts >= maxAttempts || !retryOn.contains(throwable.getClass())) {
					// 达到最大重试次数或非允许重试的系统异常时结束重试，此处可以记录重试日志
                    throw throwable;
                }
					// 如果满足重试条件，等待一段时间后重试
                try {
                    Thread.sleep(delayInMillis);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw throwable;
                }
            }
        }
    }
}

在这个切面类中，定义了一个名为 retryPointcut 的切入点，用于匹配带有@Retry 注解的方法。around 方法用 @Around 注解标注实现了重试的逻辑。当方法抛出异常时，我们检查异常类型是否需要重试，以及是否达到最大重试次数。如果满足重试条件，则等待一段时间后再次尝试执行方法。

在需要进行重试的方法上添加 @Retry 注解。例如，以下是一个简单的服务类：

@Service
public class DemoService {
    // 重试条件：最大重试次数5，重试延迟时间500ms，触发重试的异常是RuntimeException
    @Retry(maxAttempts = 5, delayInMillis = 500, retryOn = {RuntimeException.class})
    public String retryableMethod() {
        System.out.println("Executing retryableMethod...");
        throw new RuntimeException("An error occurred");
    }

    public String nonRetryableMethod() {
        System.out.println("Executing nonRetryableMethod...");
        return "This method does not have a retry mechanism.";
    }
}

在这个示例中，我们为 retryableMethod 方法设置了重试机制（最多重试 5 次，每次间隔 500 毫秒，仅在发生RuntimeException的时候进行重试。

1.4.3 日志记录

使用 Spring AOP 实现日志记录，添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

创建一个切面类（Aspect）来实现日志记录的逻辑：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Aspect
@Component
public class LoggingAspect {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    // 定义切点
    @Pointcut("within(@org.springframework.web.bind.annotation.RestController*)")
    public void restControllerMethods() {
    }
	// 定义前置通知
    @Before("restControllerMethods()")
    public void logMethodCall(JoinPoint joinPoint) {
        String className = joinPoint.getSignature().getDeclaringTypeName();
        String methodName = joinPoint.getSignature().getName();
        logger.info("Entering method [{}.{}]", className, methodName);
    }
	// 定义后置通知
    @AfterReturning(pointcut = "restControllerMethods()", returning = "result")
    public void logMethodReturn(JoinPoint joinPoint, Object result) {
        String className = joinPoint.getSignature().getDeclaringTypeName();
        String methodName = joinPoint.getSignature().getName();
        logger.info("Exiting method [{}.{}], return value: {}", className, methodName, result);
    }
}

在这个切面类中，定义了一个名为 restControllerMethods 的切入点，用于匹配所有带有 @RestController 注解的类中的方法。我们使用 @Before 注解标注 logMethodCall 方法，以便在方法调用前记录日志。类似地，我们使用@AfterReturning 注解标注 logMethodReturn 方法，以便在方法成功返回后记录日志。

这里使用SLF4J 作为日志记录库，你可以根据自己的需求更换其他日志记录库。请确保项目中包含 SLF4J 及其所需的依赖。

以下是一个简单的 REST 控制器示例，它将自动记录方法调用和返回的日志：

@RestController
public class SampleController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

当你访问 /hello 端点时，控制台将输出如下日志：

Entering method [SampleController.hello]
Exiting method [SampleController.hello], return value: Hello, World!

1.4.4 数据校验

使用 Spring AOP 实现数据校验，创建一个切面类，对方法的输入参数进行校验。这里将使用 JSR 380（Java Bean Validation 2.0）规范实现数据校验。添加下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

创建一个自定义注解 Validate ，用于标记需要进行数据校验的方法：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Validate {
}

创建一个切面类（Aspect），实现数据校验逻辑：

@Aspect
@Component
public class ValidationAspect {
    @Autowired
    private Validator validator;
	// 定义切点
    @Pointcut("@annotation(Validate)")
    public void validationPointcut() {
    }
	// 定义前置通知
    @Before("validationPointcut()")
    public void validateMethodArguments(JoinPoint joinPoint) {
        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            // 校验参数
            Errors errors = new BeanPropertyBindingResult(arg,arg.getClass().getName());
            validator.validate(arg, errors);
            if (errors.hasErrors()) {
                throw new ValidationException("Validation failed: " + errors.toString());
            }
        }
    }
}

在这个切面类中，定义了一个名为 validationPointcut 的切入点，用于匹配带有 @Validate 注解的方法。我们使用 @Before 注解标注validateMethodArguments 方法，在方法调用前进行数据校验。如果校验失败，我们将抛出一个 ValidationException 异常。

在需要进行数据校验的方法上添加 @Validate 注解。例如，以下是一个简单的服务类：

@Service
public class DemoService {
    @Validate
    public void processData(@Valid DataModel data) {
		// Process data
    }
}

public class DataModel {
    @NotNull
    private String field1;
    @Size(min = 5, max = 10)
    private String field2;
	// Getters and setters
}

在这个示例中，我们为 processData 方法添加了 @Valid 注解，以便在方法调用时自动进行数据校验。如果校验失败，切面类将抛出一个异常，从而阻止方法的执行。这个示例展示了如何使用 Spring AOP 实现数据校验。你可以根据实际需求调整校验规则，以及自定义异常处理逻辑。

crysw

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代理设计模式

创建一个接口，定义代理类和被代理类共同实现的方法创建被代理类，实现这个接口，并且在其中定义实现方法创建代理类，也要实现这个接口，同时在其中定义一个被代理类的对象作为成员变量在代理类中实现接口中的方法，方法中调用被代理类中的对应方法通过创建代理对象，并调用其方法，方法增强这样，被代理类的方法就会被代理类所覆盖，实现了对被代理类的增强或修改。
复制链接

扫一扫