springboot中aop的应用场景_SpringBoot学习笔记(三)——动态代理、AOP、以及实现Redis缓存...

最新推荐文章于 2022-11-05 14:04:33 发布

weixin_39975810

最新推荐文章于 2022-11-05 14:04:33 发布

阅读量274

点赞数

文章标签： springboot中aop的应用场景

本文链接：https://blog.csdn.net/weixin_39975810/article/details/111811414

版权

摘要

都知道Java是面向对象的程序设计语言(Object-oriented programming)，也就是说程序设计的思路是通过对象之间相互调用方法实现的。那么与之相对的就是AOP(Aspect Oriented Programming)-面向切面编程，既在运行时动态的将代码切入到指定的类的方法、指定的位置上。

1.AOP

为什么需要AOP ? 比如说，现在有大量的方法都需要添加日志功能，如果为每个方法都添加日志功能的代码，那么会大大增加代码的重复性。如果新建一个类，在类里面写好日志方法，然后所有的方法都去实现类中的日志方法，那么会大大增加类之间的耦合。这时候就可以把这个方法抽取到某个切面中，其他方法需要调用这个方法时，再切入其中。所以我们不需要关注对象和方法本身，只需要关注方法进入切面的一瞬间的这个切面。

在Spring中我们会经常使用AOP的编程思想。与此同时，在OOP中，我们可以使用装饰器模式来实现AOP的设计理念。

1.1 AOP适合于哪些场景

需要统一处理的场景，比如：日志、缓存、以及鉴权。

1.2 装饰器模式

与OOP的实现类似，如果想对类中的方法添加某项功能。为了不破坏原有方法，那么在类的外面再包裹一层。这样每次访问类中的方法之前，都会先访问包裹层中的方法。举例说明：

使用装饰器模式实现打印日志和缓存的功能：

声明接口，用以获取一个随机数：

public interface DataService {

String getRandomString();

}

复制代码新建接口的实现类：

public class DataServiceImply implements DataService {

@Override

public String getRandomString() {

return UUID.randomUUID().toString();

}

复制代码第一层装饰器，用以添加日志：

public class Decorator implements DataService{

DataServiceImply dataServiceImply;

public Decorator(DataServiceImply dataServiceImply) {

this.dataServiceImply = dataServiceImply;

}

@Override

public String getRandomString() {

System.out.println("interface is called");

System.out.println("interface is finish");

return dataServiceImply.getRandomString();

}

复制代码第二层装饰器，用以增加缓存功能：

public class Cache implements DataService {

private Map resultMap = new HashMap<>();

private DataService dataService;

public Cache(DataService dataService) {

this.dataService = dataService;

}

@Override

public String getRandomString() {

String cacheValue = resultMap.get("getRandomString");

if (cacheValue == null) {

String realValue = dataService.getRandomString();

resultMap.put("getRandomString", realValue);

return realValue;

} else {

return cacheValue;

}

复制代码在主函数中实现装饰后的方法：

public class Main {

private static Cache cache = new Cache(new Decorator(new DataServiceImply()));

public static void main(String[] args) {

System.out.println(cache.getRandomString());

}

复制代码

结果：

interface is called

interface is finish

c3a3e736-6c59-4973-a9d5-7992c62fba92

Process finished with exit code 0

复制代码

由结果可知：

在没有修改源代码的基础下，我们实现了日志功能。

对于容器中已经存在的值，我们实现了缓存功能。

从这个例子中可以看出，装饰器模式适用于当我们不能对源代码进行修改，但是又要添加其他功能的情形(参考mybatis的executor接口)。除此之外还可以看到，decorator的适用场景是面向接口的，因为每个装饰器必须实现一个接口。

但是，问题来了，如果有很多方法都需要实现额外的功能，那么需要在每个地方都要添加相应的代码，这样是不是显得很臃肿。所以，这就需要AOP的设计理念了。

2. AOP的两种实现

2.1 JDK动态代理

记得在前面的文章《类型与反射》中，提到过类加载过程的动态代理，那个是在类加载的过程中，由类加载器根据字节流动态的生产类的实例。在AOP中，动态代理是在方法被调用的一瞬间，为方法添加新的功能。这样看来二者其实是有异曲同工之妙的。

还是以前面的例子为例：

声明一个接口：

public interface DataService {

String getRandomString();

Integer getRandomInteger();

}

复制代码接口的实现类：

public class DataServiceImply implements DataService{

@Override

public String getRandomString() {

return UUID.randomUUID().toString();

}

@Override

public Integer getRandomInteger() {

return new Random().nextInt(100);

}

复制代码日志服务的实现

//必须实现InvocationHandler接口

public class LogProxy implements InvocationHandler {

DataService dataService;

public LogProxy(DataService dataService) {

this.dataService = dataService;

}

//未来被代理的类被调用时，就会进入这个方法

@Override

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

System.out.println(method.getName() + "is called "+ Arrays.toString(args));

Object object = method.invoke(dataService,args);

System.out.println(method.getName() + "is finish,result is "+ object);

return object;

}

复制代码主函数中调用：

public class Main {

static DataService dataService = new DataServiceImply();

public static void main(String[] args) {

//创建一个新的代理对象，参数分别是需要代理的类、被代理的接口、处理被拦截后的方法的代理

DataService service = (DataService) Proxy.newProxyInstance(

dataService.getClass().getClassLoader(),

new Class[]{DataService.class},

new LogProxy(dataService));

service.getRandomString();

service.getRandomInteger();

}

复制代码

结果：

getRandomStringis called null

getRandomStringis finish,result is 1e906a73-5023-45e1-b1e2-6af9407bbdf0

getRandomIntegeris called null

getRandomIntegeris finish,result is 54

复制代码

注意：这种方式的代理只能处理接口方法。

2.2 字节码生成

在前面我们使用JDK的动态代理实现了拦截接口中的方法，为方法试下了动态增强。但是也是只能用于拦截接口，如果我们想拦截类中的方法呢？这时候就需要用到动态字节码增强技术了。在这里可以使用：ByteBuddy或者CGLIB，由于在以前的文章《Java的注解》中介绍过ByteBuddy的使用，这里就不再做介绍。

使用CGLIB实现，CGLIB本质上就是在底层生成一个新的类，这个类继承了原先的类，所以可以实现对子类中的方法的增强。那么问题来了，为什么我们不自己创建一个类去继承其他类，然后对类中的方法进行增强呢？原因在于使用CGLIB是通过对字节码的增强来实现动态增强功能的，不占用资源，所以无论对多少个方法进行增强，都不会造成浪费。接下来用实例演示这个过程：

引入CGLIB的 maven依赖之后，接口与接口的实现类还是一样，日志拦截器不一样，其中代码如下：

public class LogInterceptor implements MethodInterceptor {

DataServiceImply dataServiceImply;

public LogInterceptor(DataServiceImply dataServiceImply) {

this.dataServiceImply = dataServiceImply;

}

@Override

public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

System.out.println(method.getName() + "is called "+ Arrays.toString(objects));

Object object = method.invoke(dataServiceImply,objects);

System.out.println(method.getName() + "is finish,result is "+ object);

return object;

}

复制代码

主函数中：

public class Main {

public static void main(String[] args) {

DataServiceImply dataServiceImply = new DataServiceImply();

Enhancer enhancer = new Enhancer();

//设置超类

enhancer.setSuperclass(DataServiceImply.class);

//设置一个回调

enhancer.setCallback(new LogInterceptor(dataServiceImply));

//产生一个新的实例

DataServiceImply newDataServiceImply = (DataServiceImply)enhancer.create();

newDataServiceImply.getRandomInteger();

newDataServiceImply.getRandomString();

}

复制代码

结果：

getRandomIntegeris called []

getRandomIntegeris finish,result is 58

getRandomStringis called []

getRandomStringis finish,result is e655fe89-124b-4c1c-b8e8-1aa0b10b2d88

复制代码

可以看到，这个过程实现了对类中的方法的拦截，然后进行字节码增强，接着通过反射调用超类中的方法，实现了日志的效果。但是由于这种方法本质上是通过类的继承关系来实现日志功能的，所以弊端也很明显，就是不能对final类以及final/private类型的方法进行增强。

3. 在SpringBoot中使用AOP

说了这么多最终还是要回归到实际的生产中，如何在SpringBoot中实现AOP的思想。在上一篇文章中，我们实现了从数据库中拿数据，然后渲染成HTML页面的功能。那么问题来了，如果我同时有几千台电脑在同时访问这个页面，那么意味着数据库要同时接受几千次查询操作，这样数据库的压力会很大，所以这时候就需要AOP的思想来解决并发访问的问题。

3.1 使用@Aspect声明切面

首先引入AOP的 maven依赖,接着可以看到，我们要拦截的方法是与Dao层交互的Service层中的类中的方法，代码如下：

@Service

public class RankService {

@Autowired

private RankDao rankDao;

public List sort() {

return rankDao.getRankItem();

}

复制代码

所以这时候可以明确了，我们不能使用JDK的动态代理实现拦截，需要使用CGLIB实现拦截。由于SpringBoot中默认的是使用JDK的代理，所以需要在SpirngBoot的application.properties文件中加入这段代码：spring.aop.proxy-target-class=true

声明一个cache注解，用以标记需要被拦截的方法:

@Retention(RetentionPolicy.RUNTIME)

public @interface Cache {

}

复制代码

接下来声明一个缓存切面类:

//声明这是一个切面

@Aspect

//声明这个类是与configuration有关

@Configuration

public class CacheAspect {

//声明切面把方法包裹起来，参数是需要拦截的注解的全限定类名

@Around("@annotation(hello.anno.Cache)")

public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {

System.out.println("method is called");

//proceed表示让方法继续前进

return joinPoint.proceed();

}

复制代码

启动SpringBoot:

可以看到，拦截器正常运行了。

3.2 使用HashMap容器实现缓存功能

接下来用两种方式实现缓存功能：

@Aspect

@Configuration

public class CacheAspect {

Map map = new HashMap<>();

@Around("@annotation(hello.anno.Cache)")

public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {

String methodName = joinPoint.getSignature().getName();

Object obj = map.get(methodName);

if (obj == null){

Object real = joinPoint.proceed();

map.put(methodName,real);

System.out.println("Get value form database");

return real;

}else{

System.out.println("Get value form cache");

return obj;

}

复制代码

两次运行SpringBoot的结果：

说明我们的缓存起作用了。

3.3 使用Redis实现缓存功能

首先回答下几个问题：

1.Redis是什么？

引自维基百科的解释：Redis是一个使用ANSI C编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库。

大家都知道Redis的优点之一就是速度非常快，那么问题来了：

2.Redis为什么这么快？

完全基于内存

优秀的数据结构设计

单一线程，避免上下文切换开销

事件驱动，非阻塞

构件了自己的VM机制

使用docker启动Redis

1.使用命令：sudo docker run -p 6379:6379 -d redis 实现将Redis的6379端口与本地的6379端口进行映射，接着使用docker ps命令查看是否成功运行Redis。

可以看到redis已经起来了。

2. 在SpringBoot中配置Redis，将下面的代码贴入application.properties文件中:

spring.redis.host=localhost

spring.redis.port=6379

复制代码

3. 引入Redis的 Maven依赖之后，接下来进行Redis的配置，新建一个类，在其中写入：

//告诉SpringBoot这是用以生成配置文件的

@Configuration

public class AppConfig {

//Redis会扫描所有的带Bean注解的方法，并自动调用它，生成相关的Bean

@Bean

//RedisTemplate用以实现与Redis进行交互

RedisTemplate redisTemplate(RedisConnectionFactory factory){

RedisTemplate redisTemplate = new RedisTemplate<>();

redisTemplate.setConnectionFactory(factory);

return redisTemplate;

}

复制代码

接下来就可以在切面方法中使用RedisTemplate代替HashMap了，修改后的代码如下：

@Aspect

@Configuration

public class CacheAspect {

@Autowired

RedisTemplate redisTemplate;

@Around("@annotation(hello.anno.Cache)")

public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {

String methodName = joinPoint.getSignature().getName();

Object obj = redisTemplate.opsForValue().get(methodName);

if (obj == null) {

Object real = joinPoint.proceed();

redisTemplate.opsForValue().set(methodName, real);

System.out.println("Get value form database");

return real;

} else {

System.out.println("Get value form cache");

return obj;

}

复制代码

从结果中可以看出缓存起作用了：

4. 解惑

4.1 为什么有时候可以在SpringBoot的mvn依赖中不指定依赖的版本信息？

答曰：

可以在pom.xml中看到类似：

org.springframework.boot

spring-boot-starter-parent

2.1.6.RELEASE

复制代码

这样的标签，那么对于没有指定版本信息的依赖：

org.springframework.boot

spring-boot-starter-web

复制代码

则会继承parent中指定的版本，结果可以在Maven->Dependencies中查看。也可以通过命令mvn dependency:tree可以用以查看依赖树信息。或者直接使用mvn dependency:tree > xxx.txt将其导入到txt中方便查看。

4.2 在IDEA中输入命令docker run -p 6379:6379 -d redis出现docker: command not found如何解决？

答曰：

出现这种情况说明你的电脑中没有安装docker引擎，在gitbash中按照docker官网的命令，一步一步执行即可。但是，docker对于windows系统只支持专业版和企业版，不支持家庭版和教育版。如果运气好，系统刚刚好是这两种不支持的，也没关系，电脑上下个虚拟机就是。不知道怎么操作的话，可以我自己总结的教程。点击跳转页面...

4.3 HashMap可以实现与RedisTemplate类似的效果，那么为什么不直接使用HashMap呢？

答曰：

首先我们要知道分布式部署的概念，由于我们无法保证一台JVM不会出现突发状况，所以为了安全起见，我们的系统在绝大部分情况下，都是配置在多台JVM上，而且每个JVM之间是互不影响的。那么问题来了，如果我们使用HashMap，由于在不同的JVM上，HashMap之间互不联系，自然就无法实现共享缓存。所以就需要中心化的Redis缓存，Redis可以实现在多个集群中共享实例。

4.4 在虚拟机中映射好了6379端口，但是在SpringBoot中却显示连接不上，如何解决？

可以看到，在虚拟机中以及挂起了redis服务：

但是浏览器中却显示不能正常连接：

原因在于，在VirtualBox中没有设定本机的端口与宿主机端口的映射。操作步骤如下：

在浏览器中刷新页面，即可看到正常显示的页面。

项目地址： github.com/Scott-YuYan…

4.5 Redis常用命令

清空Redis中的缓存：

使用命令redis-cli -h localhost -p 6379进入Redis客户端，接着使用flushall(所有库)/flushdb(当前库)清空缓存。

删除指定Key的缓存：

5. 参考资料

1.个人博客.《Spring Boot中使用AOP统一处理Web请求日志》点击此处跳转至源文档