SpringBoot AOP浅析

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量374 收藏
点赞数 1
分类专栏： Spring系列 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HFEzreal/article/details/105656312
版权

SpringBoot AOP浅析

SpingAop

面向切面编程：相对于OOP面向对象编程，Spring的AOP的存在目的是为了解耦。AOP可以让一组类共享相同的行为。在OOP中只能继承和实现接口，且类继承只能单继承，阻碍更多行为添加到一组类上，AOP弥补了OOP的不足，让业务逻辑关注业务本身，不用去关心其它的事情，比如事务。有如下优点：

  1. 集中的处理某一关注点/横切逻辑
  2. 可以很方便的添加/删除 关注点
  3. 侵入性少，增强代码的可读性和可维护性

业务场景

  1. 事务控制：给目标方法添加前后的声明周期，事务开启、回滚、提交等
  2. 日志记录：给目标方法添加日志记录，记录方法的执行时间、接收参数、返回结果等
  3. 权限控制：给目标方法添加权限控制，在方法执行前，判断是否有执行该方法的权限
  4. 异常处理：对于目标方法的返回异常进行处理，给出友善的错误提示
  5. 国际化：对于返回结果进行处理，如中英文替换等
  6. …

常用术语

  • 通知（Advice）

    有的地方又叫做增强，需要完成的工作叫做通知，入事务控制、日志记录等，你要先定义好，等到使用的时候再去用

  • 切点（Poingcut）

    一个类中的所有方法都可以是切点，根据需要筛选出需要添加通知的方法，切点是为了找到需要增强的方法

    最常用的切点：execution(* com.jiuxian..service.*.*(..))

    • execution 表达式的主体
    • 第一个* 代表任意的返回值
    • com.jiuxian aop所横切的包名
    • 包后面… 表示当前包及其子包
    • 第二个* 表示类名，代表所有类
    • .*(…) 表示任何方法,括号代表参数 … 表示任意参数

  • 切面（Aspect）

    其实就是切点和通知的结合，通知和切点定义了切面的全部内容，它是干什么的，什么时候在哪执行

  • 织入（Weaving）

    把切面加入程序代码的过程。切面在指定的连接点被织入到目标对象中，在目标对象的生命周期里有多个点可以进行织入：

    • 编译期： 切面在目标类编译时被织入，这种方式需要特殊的编译器
    • 类加载期： 切面在目标类加载到JVM时被织入，这种方式需要特殊的类加载器，它可以在目标类被引入应用之前增强该目标类的字节码
    • 运行期： 切面在应用运行的某个时刻被织入，一般情况下，在织入切面时，AOP容器会为目标对象动态创建一个代理对象，Spring AOP就是以这种方式织入切面的。

AopDemo

  1. 添加spring-aop依赖
<!-- aop依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
  1. 定义一个切面
package com.nubo.jfs.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
1. @description 日志拦截
2. @author liubin
3. @date 20/4/21 11:45
*/
@Aspect
@Component
public class LogAspect {
   
   @Pointcut("execution(public * com.nubo.jfs.service.*.*(..))")
   public void pointcut() {
   }

   @Around("pointcut()")
   public void around(ProceedingJoinPoint point) {
       long t1 = System.currentTimeMillis();
       System.out.println("日志记录开始");
       try {
           point.proceed();
       } catch (Throwable throwable) {
           throwable.printStackTrace();
       }
       long t2 = System.currentTimeMillis();
       System.out.println("日志记录结束,耗时：" + (t2 - t1) + "ms");
   }
}
  1. 五种通知（增强）代码实现
	@Before("pointcut()")
    public void beginTransaction() {
        System.out.println("before beginTransaction");
    }

    @After("pointcut()")
    public void commit() {
        System.out.println("after commit");
    }

    @AfterReturning(pointcut = "pointcut()", returning = "returnObject")
    public void afterReturning(JoinPoint joinPoint, Object returnObject) {
        System.out.println("afterReturning");
    }

    @AfterThrowing("pointcut()")
    public void afterThrowing() {
        System.out.println("afterThrowing afterThrowing  rollback");
    }
    
	@Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            System.out.println("around");
            return joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
            throw e;
        } finally {
            System.out.println("around");
        }
    }
  1. 注解的方式注入
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Auth {
    boolean hasAuth() default true;
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 - @description 权限拦截
 - @author liubin
 - @date 20/4/21 15:28
 */
@Aspect
@Component
@Order(1)
public class AuthAspect {

    @Pointcut(value = "@annotation(auth)", argNames = "auth")
    public void pointcut(Auth auth) {
    }

    @Around(value = "pointcut(auth)", argNames = "joinPoint,auth")
    public void aroung(ProceedingJoinPoint joinPoint, Auth auth) {
        if (auth.hasAuth()) {
            System.out.println("have auth...");
            try {
                joinPoint.proceed();
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        } else {
            System.out.println("not have auth...");
        }
    }
}

AOP底层原理

在spring对实例进行初始化的时候，最后会调用

  • AbstractAutowireCapableBeanFactory.createBean() 创建bean
  • AbstractAutowireCapableBeanFactory.initializeBean() 初始化bean对象
  • AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization() 注入后续属性
  • AbstractAutoProxyCreator.postProcessAfterInitialization() 织入Aop通知
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
	protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {
		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) 				   this.beanFactory, beanName, beanClass);
		}

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);
		// 如果配置了属性spring.aop.proxy-target-class = true，则强制使用cglib代理
		if (!proxyFactory.isProxyTargetClass()) {
			// 是否需要代理类或者代理接口
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {// 如果代理的是接口，则判断是否实现了接口，没有实现接口使用代理类
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}

		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);

		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}

		return proxyFactory.getProxy(getProxyClassLoader());
	}
}

根据代理类型获取代理方式，代理类使用cgilb动态代理，代理接口使用jdk动态代理

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// isOptimize默认false || 是代理类？ || 没继承接口？
		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

	/**
	 * Determine whether the supplied {@link AdvisedSupport} has only the
	 * {@link org.springframework.aop.SpringProxy} interface specified
	 * (or no proxy interfaces specified at all).
	 */
	private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
		Class<?>[] ifcs = config.getProxiedInterfaces();
		return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
	}

}

从上源码可以看到，SpringAop的底层实现是通过jdk动态代理和Cglib代理来实现的，也可以通过参数控制使用哪种代理模式

spring.aop.proxy-target-class = true/false

spring默认使用jdk动态代理，而springboot默认使用的cglib动态代理

spingboot官方是这样解释的：他们认为使用cglib更不容易出现转换错误

This was changed in 1.4 (see 5423). We’ve generally found cglib proxies less likely to cause unexpected cast exceptions.

SpringBoot 默认的配置文件中是这样显示的 spring-configuration-metadata.json

{
      "name": "spring.aop.auto",
      "type": "java.lang.Boolean",
      "description": "Add @EnableAspectJAutoProxy.",
      "defaultValue": true
    },
    {
      "name": "spring.aop.proxy-target-class",
      "type": "java.lang.Boolean",
      "description": "Whether subclass-based (CGLIB) proxies are to be created (true), as opposed to standard Java interface-based proxies (false).",
      "defaultValue": true
    }

我们发现 SpringBoot 中的注解@EnableAspectJAutoProxy 或者@EnableTransactionManagement 默认的proxyTargetClass 就是false，说明这上面的设置并未生效，

@EnableAspectJAutoProxy(proxyTargetClass = false)
@EnableTransactionManagement(proxyTargetClass = false)

如果想要走jdk动态代理，还需要在配置文件设置设置

spring.aop.proxy-target-class = false

以下是走哪个代理方式的配置方式

配置spring.aop.auto配置 spring.aop.proxy-target-class注解的proxyTargetClass代理 方式
truetruetrueCglib
truefalsetrueCglib
truetruefalseCglib
truefalsefalseJDK动态代理
falsetruetrueCglib
falsefalsetrueCglib
falsetruefalseJDK动态代理
falsefalsefalseJDK动态代理

代理模式

静态代理

由程序员创建类再对其进行编译，在程序运行前代理类的的.class就已经存在了

  1. 继承代理

公共的取放的接口类

/**
 * @description 取放的接口
 * @author liubin
 * @date 20/4/21 09:12
 */
public interface TakeService {

    void takeIn();

    void takeOut();
}

取药拿药的操作类

/**
 * @description 拿药
 * @author liubin
 * @date 20/4/21 09:22
 */
@Service
public class DrugServiceImpl implements TakeService {
    @Override
    public void takeIn() {
        // 补药
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("take in drug...");
    }

    @Override
    public void takeOut() {
        // 拿药
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("take out drug...");
    }
}

对取药拿药的操作织入日志记录的功能

/**
 * @description 日志记录
 * @author liubin
 * @date 20/4/21 09:33
 */
public class ExtendDrugLogProxy extends DrugServiceImpl {

    @Override
    public void takeIn() {
        long t1 = System.currentTimeMillis();
        System.out.println("日志记录开始");
        super.takeIn();
        long t2 = System.currentTimeMillis();
        System.out.println("日志记录结束,耗时：" + (t2 - t1) + "ms");
    }
}
  1. 聚合代理

使用聚合代理的方式对拿药取药的操作织入日志记录

/**
 - @description 日志记录
 - @author liubin
 - @date 20/4/21 09:50
 */
public class ImplementDrugLogProxy implements TakeService {

    private TakeService takeService;

    public ImplementDrugLogProxy(TakeService takeService) {
        this.takeService = takeService;
    }

    @Override
    public void takeIn() {
        long t1 = System.currentTimeMillis();
        System.out.println("日志记录开始");
        takeService.takeIn();
        long t2 = System.currentTimeMillis();
        System.out.println("日志记录结束,耗时：" + (t2 - t1) + "ms");
    }

    @Override
    public void takeOut() {
        long t1 = System.currentTimeMillis();
        System.out.println("日志记录开始");
        takeService.takeOut();
        long t2 = System.currentTimeMillis();
        System.out.println("日志记录结束,耗时：" + (t2 - t1) + "ms");
    }
}

  • 总结

  • 继承方式：每多一个切点，多写一个通知；通知顺序改变，代理类需要重构

  • 聚合方式：每多一个切点，多写一个通知；通知顺序改变，只需在调用时改变顺序

动态代理

与静态代理相反，动态代理是在程序编译或者运行的的时候才生成代理类，更加灵活和轻便

1. jdk动态代理

jdk动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用业务方法前调用InvocationHandler处理。代理类必须实现InvocationHandler接口，并且，JDK动态代理只能代理实现了接口的类，没有实现接口的类是不能实现JDK动态代理。结合下面代码来看就比较清晰了。

/**
 * @description jdk动态代理
 * @author liubin
 * @date 20/4/21 10:19
 */
public class JdkLogProxy implements InvocationHandler {
    //被代理的对象
    private Object target;
    public JdkLogProxy(Object target) {
        this.target = target;
    }
    /**
     * @param proxy  代理对象
     * @param method  增强的方法
     * @param args 方法参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long t1 = System.currentTimeMillis();
        System.out.println("日志记录开始");
        Object result = method.invoke(target, args);
        long t2 = System.currentTimeMillis();
        System.out.println("日志记录结束,耗时：" + (t2 - t1) + "ms");
        return result;
    }
}

2. Cglib动态代理

cglib是针对类来实现代理的，它会对目标类产生一个代理子类，通过方法拦截技术对过滤父类的方法调用。代理子类需要实现MethodInterceptor接口。

/**
 * @description cglib动态代理
 * @author liubin
 * @date 20/4/21 11:11
 */
public class CglibLogProxy implements MethodInterceptor {
    /**
     * @param object 需要增强的对象
     * @param method 表示拦截的方法
     * @param objects 数组表示参数列表，基本数据类型需要传入其包装类型，如int-->Integer、long-Long、double-->Double
     * @param methodProxy 表示对方法的代理，invokeSuper方法表示对被代理对象方法的调用
     * @return java.lang.Object
     */
    @Override
    public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        long t1 = System.currentTimeMillis();
        System.out.println("日志记录开始");
        Object result = methodProxy.invokeSuper(object, objects);
        long t2 = System.currentTimeMillis();
        System.out.println("日志记录结束,耗时：" + (t2 - t1) + "ms");
        return result;
    }
}
区别jdk动态代理Cglib动态代理
实现原理使用聚合的方式使用继承的方式
不能代理的情况没有实现接口类final类型的类或方法

在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率，只有当进行大量调用的时候，jdk6和jdk7比CGLIB代理效率低一点，但是到jdk8的时候，jdk代理效率高于CGLIB代理，总之，每一次jdk版本升级，jdk代理效率都得到提升，而CGLIB代理消息确有点跟不上步伐。

双河古天乐
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot AOP各种注解、自定义注解、鉴权使用案例（免费下载）
02-24
SpringBoot AOP各种注解、自定义注解、鉴权使用案例SpringBoot AOP各种注解、自定义注解、鉴权使用案例SpringBoot AOP各种注解、自定义注解、鉴权使用案例
浅谈springAOP
qq_39855224的博客
12-14 392
Spring的AOP使用的动态代理是：JDK动态代理和CGLIB动态代理。Spring在这两种动态代理中灵活切换，如果是代理接口，会默认使用JDK动态代理，如果代理类，该类没有实现接口，就会使用CGLIB动态代理。也可以使用配置让spring只是用CGLIB
springboot AOP原理浅析和使用实例
林木的专栏
12-20 2990
AOP=Aspect Oriented Programming，面向切面编程。 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是Spring框架中的一个重要内容，它通过对既有程序定义一个切入点，然后在其前后切入不同的执行内容。   原理 通过在代理类中包裹切面，Spring在运行期把切面织入到Spring管理的bean中。     代理类封装了目标类，并拦...
springboot+aop实现限流方式浅析
ldcaws的专栏
08-07 1752
限流，就是在某个时间窗口对资源访问做次数限制，如设定每秒最多100个访问请求。限流具有两个维度，如下在实际开发中，不止设置一种限流规则，而是设置多个限流规则共同作用，常见限流规则如下限流常见方法如下在springboot工程中，通过aop的方式实现限流，应用场景有采用guava的速率限流、采用redis的指定时间指定次数限制、socket请求限制、http请求限制。 实例2：redis指定时间指定次数限制 或切面环绕无返回，请求返回为空 实例3：socket请求限流 ...
springboot工程中切入方式浅析
ldcaws的专栏
03-26 1095
springboot工程中有多种切入的方式，如aop、filter、interceptor、listener、resolver。下面以白名单校验的业务场景进行简单的分析。 1、aop方式 aop是springboot提供的面向切面编程，只需在方法前添加切点，然后再对切点进行处理即可。 首先定义一个注解Whitelist，然后使用@Aspect注解声明一个切面类WhitelistAspect，最后在执行被注解的方法时才会进行切面类的处理方法中。 @Aspect @Component public class
SpringBoot AOP切面类三种写法（源代码）
01-27
SpringBoot AOP 写法一： @Before("execution(* com.bjpowernode.springboot07.javabean.Man.eat(..))") 一、AOP开发 1.1 概述 1.2使用方法 1.3创建项目并添加maven依赖 1.4 创建Javabean测试类 1.5 创建切面 1.6 ...
springboot AOP使用实例源码
12-20
在Springboot上使用AOP的简单实例源码，可以结合本人的文章一起学习理解 https://blog.csdn.net/vincent_yuan89/article/details/85128009
SpringBoot AOP使用笔记
08-26
今天小编就为大家分享一篇关于SpringBoot AOP使用笔记，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
解决springboot的aop切面不起作用问题(失效的排查)
08-19
主要介绍了解决springboot的aop切面不起作用问题(失效的排查)，具有很好的参考价值，希望对大家有所帮助。 一起跟随小编过来看看吧
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 678
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
(三)Spring教程——依赖注入与控制反转
05-14 561
Spring有两个重要的接口：BeanFactory和ApplicationContext，所谓的容器就是实现了BeanFactory接口或者是ApplicationContext接口的类的实例，BeanFactory是最顶层、最基本的接口，它描述了容器需要实现的最基本的功能，比如对象的注册、获取等。在编写传统的Java应用代码时，我们一般是直接在对象内部通过new来创建对象，让程序主动去创建依赖对象，这就是一个“谁使用，谁创建”的过程，创建依赖对象的主动权和创建时机都是由自己来把控。
spring 循环依赖
weixin_45849726的博客
05-14 445
先创建ABean1.0. 记录正在创建ABean singletonCurrentlyInCreation<1.1.实例化ABean–>得到一个对象–>存入singletonFactories1.2. 填充BBean属性–>去单例池找BBean–>没有就创建1.3. 进行其他依赖注入1.4. 初始化前，初始化1.5. 初始化后1.6. 放入单例池创建BBean2.1. 实例化BBean–>得到一个对象。
java云his系统源码 一站式诊所SaaS系统Java+Spring+Angular+Nginx 云HIS系统八大特点
zmm201453的博客
05-15 1216
HIS系统采用面向技术架构的分析与设计方法，应用多层次应用体系架构设计，运用基于构件技术的系统搭建模式与基于组件模式的系统内核结构。通过建立统一接口标准，实现数据交换和集成共享，通过统一身份认证和授权控制，实现业务集成、界面集成。
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
shijialeya
05-18 382
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器进行数据格式化。
springboot接口同时接收文件和json数据
lovebosom的博客
05-18 140
MultipartFile file HttpMediaTypeNotSupportedException
黑马guli商城项目初始化-SpringCloud微服务项目初始化使用SpringCloudAlibaba快速搭建分布式系统
这个人很懒什么都没有留下
05-16 547
*** 1、如何使用Nacos作为配置中心统一管理配置* 1）、引入依赖，* 2）、创建一个bootstrap.properties。* 3）、需要给配置中心默认添加一个叫 数据集（Data Id）gulimall-coupon.properties。默认规则，应用名.properties* 4）、给 应用名.properties 添加任何配置* 5）、动态获取配置。* @RefreshScope：动态获取并刷新配置* @Value("${配置项的名}")：获取到配置。
Spring AI项目Open AI对话接口开发指导
缘友一世的博客
05-14 546
【代码】Spring AI项目Open AI对话接口开发指导。
SpringBoot事件发布与监听，观察者模式使用
小哇
05-16 217
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。
Springboot Aop
08-26
SpringBoot AOP是Spring框架的一个重要特性，用于实现面向切面编程。通过引入AOP依赖，我们可以简化开发操作，并且可以使用一些常用的注解来方便我们的开发。在SpringBoot中，我们可以使用`spring-boot-starter-aop`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值