手机销售网站怎么做/自己建网站
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 {@Overridepublic 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();}@Overridepublic String query(String queryKey) {// 对被代理对象做增强; 查询缓存,命中则返回,否则查databaseString 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 {/*** 测试静态代理*/@Testpublic 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 {@Overridepublic 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();}@Overridepublic 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);// 真实的图像加载逻辑...}@Overridepublic 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;}@Overridepublic 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 {@Overridepublic 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();}@Overridepublic 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 {@Overridepublic String query(String queryKey) {// 使用数据源从数据库查询数据很慢log.info(">>>query,正在从数据库查询数据");return "value1 from database";}@Overridepublic 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*/@Overridepublic 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实现的动态代理*/@Testpublic 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);}@Testpublic 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*/@Overridepublic 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 {@Testpublic 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);}@Testpublic 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 {@Overridepublic 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 {@Resourceprivate DataQuery dataQuery;@Testpublic 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 的 keyString 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();// 获取延迟时间 mslong 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 {@Autowiredprivate 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 {@Validatepublic void processData(@Valid DataModel data) {// Process data}
}public class DataModel {@NotNullprivate String field1;@Size(min = 5, max = 10)private String field2;// Getters and setters
}
在这个示例中,我们为 processData 方法添加了 @Valid 注解,以便在方法调用时自动进行数据校验。如果校验失败,切面类将抛出一个异常,从而阻止方法的执行。这个示例展示了如何使用 Spring AOP 实现数据校验。你可以根据实际需求调整校验规则,以及自定义异常处理逻辑。
相关文章:

代理设计模式
1. 代理模式 1.1 代理模式的原理分析 代理设计模式(Proxy Design Pattern)是一种结构型设计模式,它为其他对象提供一个代理对象,以控制对这个对象的访问。代理模式可以用于实现懒加载、安全访问控制、日志记录等功能。 代理模式…...

ubuntu安装docker及docker常用命令
docker里有三个部分 daemon 镜像 和 容器 我们需要了解的概念 容器 镜像 数据卷 文章目录 docker命令docker镜像相关命令docker容器相关命令数据卷ubuntu安装docker docker命令 #启动,停止,重启docker systemctl start docker systemctl stop docker s…...

STM32-TIM定时器输出比较
目录 一、输出比较简介 二、PWM简介 三、输出比较通道(通用) 四、输出比较通道(高级) 五、输出比较模式 六、PWM基本结构 七、PWM参数计算 八、外设介绍 8.1 舵机 8.2 直流电机及驱动 九、开发步骤 十、输出比较库函数…...

《Easy3d+Qt+VTK》学习
《Easy3dQtVTK》学习-1、编译与配置 一、编译二、配置注 一、编译 1、 资源下载:easy3d giuhub 2、解压缩 3、用qt打开CMakeLists.txt即可 4、点击项目,选择debug或者release,图中3处可自行选择,因为我的qt版本是6,…...

多平台展示预约的服装小程序效果如何
线下实体服装店非常多,主要以同城生意为主,但随着电商经济增长,传统线下自然流量变少,商家们会选择线上入驻平台开店获得更多线上用户,包括自建私域小程序等。 而除了直接卖货外,线上展示预约在服装行业也…...

Gti GUI添加标签
通过Git Gui打开项目,通过菜单打开分支历史,我这里是名为"develop"的分支 选中需要打标签的commit,右键-Create tag即可 但貌似无法删除标签,只能通过git bash,本地标签通过git tag -d tagname,…...

高云GW1NSR-4C开发板M3硬核应用
1.M3硬核IP下载:Embedded M3 Hard Core in GW1NS-4C - 科技 - 广东高云半导体科技股份有限公司 (gowinsemi.com.cn) 特别说明:IDE必须是1.9.9及以后版本,1.9.8会导致编译失败(1.9.8下1.1.3版本IP核可用) 以下根据官方…...

【RTOS学习】模拟实现任务切换 | 寄存器和栈的变化
🐱作者:一只大喵咪1201 🐱专栏:《RTOS学习》 🔥格言:你只管努力,剩下的交给时间! 目录 🏀认识任务切换🏐切换的实质🏐栈中的内容🏐切…...

1.2 轻量级数据交互格式–JSON
对于接口来说,数据交互大部分都是使用的JSON格式,我们这里说的数据,就是我们上一章里讲解HTTP协议的时候,HTTP协议结构里的实体,也就是放在body里。body里存放需要传输的数据,数据是JSON格式,然后通过HTTP协议来传输给接口,接口再以同样的方式给我们返回。理解了这一层…...

charCodeAt() 方法
charCodeAt() 是 JavaScript 中用于获取字符串指定位置字符的 Unicode 编码的方法 语法如下: str.charCodeAt(index) str:要获取字符的字符串。index:要获取的字符在字符串中的索引。返回值是一个表示给定索引处字符 Unicode 编码的整数。…...

Flask中redis的配置与使用
注意点: 在__init__.py中需要将redis_store设置成全局变量,这样方便其他文件导入 一、config.py import logging import os from datetime import timedeltafrom redis import StrictRedisclass Config:# 调试信息DEBUG TrueSECRET_KEY os.urandom(3…...

生产者与消费者模型
初识linux之线程同步与生产者消费者模型_生产者线程和消费者线程-CSDN博客 Linux线程(三)—— 多线程(生产者消费者模型、信号量、线程池)-CSDN博客...

透析回溯的模板
关卡名 认识回溯思想 我会了✔️ 内容 1.复习递归和N叉树,理解相关代码是如何实现的 ✔️ 2.理解回溯到底怎么回事 ✔️ 3.掌握如何使用回溯来解决二叉树的路径问题 ✔️ 回溯可以视为递归的拓展,很多思想和解法都与递归密切相关,在很多…...

浅谈web性能测试
什么是性能测试? web性能应该注意些什么? 性能测试,简而言之就是模仿用户对一个系统进行大批量的操作,得出系统各项性能指标和性能瓶颈,并从中发现存在的问题,通过多方协助调优的过程。而web端的性能测试…...

Qt 容器QGroupBox带有标题的组框框架
控件简介 QGroupBox 小部件提供一个带有标题的组框框架。一般与一组或者是同类型的部件一起使用。教你会用,怎么用的强大就靠你了靓仔、靓妹。 用法示例 例 qgroupbox,组框示例(难度:简单),使用 3 个 QRadioButton 单选框按钮,与QVBoxLayout(垂直布局)来展示组框的…...

Linux系统解决“Key was rejected by service”
Linux系统下加载驱动模块出现如上错误提示的原因为:此驱动未经过签名。 方法一、关闭Secure Boot 如果是物理机,需要开机进入BIOS,找到“Secure Boot”的选项,然后关闭。 如果是虚拟机,可以打开虚拟设置,…...

【C++ Primer Plus学习记录】字符函数库cctype
C从C语言继承了一个与字符相关的、非常方便的函数软件包,它可以简化诸如确定字符是否为大写字母、数字、标点符号等工作,这些函数的原型是在头文件cctype中定义的。 cctype中的字符函数 函数名称返回值isalnum()如果参数是字母或数字,该函数返…...

C# WebSocket简单使用
文章目录 前言Fleck调试工具初始化简单使用 前言 最近接到了一个需求,需要网页实现上位机的功能。那就对数据传输的实时性要求很高。那就只能用WebSocket了。这里简单说一下我的WebSocket如何搭建 Fleck C# WebSocket(Fleck) 客户端:html Winfrom Fleck Github官网…...

uni-app 一些实用的页面模板
时间倒计时 <!-- 时间倒计时 --> <template><view class"container"><view class"flex-row time-box"><view class"time-item">{{ laveTimeList[0] }}</view><text>天</text><view class&qu…...

STM32——震动传感器点亮LED灯
震动传感器简单介绍 若产品不震动,模块上的 DO 口输出高电平; 若产品震动,模块上的 DO 口输出低电平,D0-LED绿色指示灯亮。 震动传感器与STM32的接线 编程实现 需求:当震动传感器接收到震动信号时,使用中断…...

使用 Timm 库替换 YOLOv8 主干网络 | 1000+ 主干融合YOLOv8
文章目录 前言版本差异说明替换方法parse_moedl( ) 方法_predict_once( ) 方法修改 yaml ,加载主干论文引用timm 是一个包含最先进计算机视觉模型、层、工具、优化器、调度器、数据加载器、数据增强和训练/评估脚本的库。 该库内置了 700 多个预训练模型,并且设计灵活易用。…...

PHP中什么是闭包(Closure)?
在PHP中,闭包(Closure)是一种匿名函数,它可以作为变量传递、作为参数传递给其他函数,或者被作为函数的返回值。闭包可以在定义时捕获上下文中的变量,并在以后的执行中使用这些变量。闭包在处理回调函数、事…...

boost::graph学习
boost::graph API简单小结 boost::graph是boost为图算法提供的API,简单易用。 API说明 boost::add_vertex 创建一个顶点。 boost::add_edge 创建一条边。 boost::edges 获取所有的边。 boost::vertices 获取所有的顶点。 graph.operator[vertex_descriptor] 获…...

【C语言:动态内存管理】
文章目录 前言1.malloc2.free3.calloc4.realloc5.动态内存常见错误6.动态内存经典笔试题分析7.柔性数组8.C/C中的内存区域划分 前言 文章的标题是动态内存管理,那什么是动态内存管理?为什么有动态内存管理呢? 回顾一下以前学的知识ÿ…...

【Python基础】迭代器
文章目录 [toc]什么是迭代可迭代对象判断数据类型是否是可迭代类型 迭代器对可迭代对象进行迭代的本质获取可迭代对象的迭代器通过迭代器获取数据StopIteration异常 自定义迭代器__iter__()方法__next__()方法判断数据类型是否是可迭代类型自定义迭代器案例分离模式整合模式 fo…...

QVTK 可视化
#ifndef MAINWINDOW_H #define MAINWINDOW_H#include <QMainWindow>#include <vtkNew.h> // 智能指针 #include <QVTKOpenGLNativeWidget.h> #include <vtkCylinderSource.h> // 圆柱#include <vtkPolyDataMapper.h&g…...

【初阶C++】入门(超详解)
C入门 前言1. C关键字(C98)2. 命名空间2.1 命名空间定义2.2 命名空间使用2.3嵌套命名空间 3. C输入&输出4. 缺省参数4.1 缺省参数概念4.2 缺省参数分类 5. 函数重载5.1 函数重载概念5.2 C支持函数重载的原理--名字修饰(name Mangling) 6. 引用6.1 引用概念6.2 引用特性6.3 …...

Java正则表达式的使用
标题:Java正则表达式的使用 介绍: 正则表达式是一种强大的文本匹配模式和搜索工具。在Java中,通过使用正则表达式,我们可以快速有效地进行字符串的匹配、查找和替换。本文将介绍Java正则表达式的基本使用方法,并提供相…...

Collecting Application Engine Performance Data 收集应用程序引擎性能数据
You can collect performance data of any specific SQL action of an Application Engine program to address any performance issue. 您可以收集应用程序引擎程序的任何特定SQL操作的性能数据,以解决任何性能问题。 You can collect performance data of the S…...

C Primer Plus阅读--章节16
C Primer Plus阅读–章节16 翻译程序的第一步 预处理之前,编译器必须对该程序进行一些翻译处理。 首先,编译器将源代码中出现的字符映射到源字符集。第二,编译器定位每个反斜杠后面跟着换行符的实力,并删除他们。物理行的合并。…...