从约定编程到理解Spring AOP

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: 想要理解Spring 源码光有OOP 的思想是不够的,还要有AOP 的思想武装自己,才能更好的理解Spring 的源码

概述

提到Spring 不得不赞叹其IOC 跟AOP 实现之精巧,设计之伟大。平时工作中我们也会通过AOP 去实现一些功能,如对接口环形日志打印,通用的防止重复提交的功能。我觉得第一次感受到AOP 的强大就是其对数据库事务的冗余代码的解放。


在了解Spring aop 之前我们先了解一下约定编程。


约定编程

下面基于Java Proxy实现一个小demo 体验一下什么是约定编程,其实这也是与AOP 有着异曲同工之妙的。

/*** 首先创建一个接口*/publicinterfaceUserService {
/*** say hello* @param name 名字*/voidsayHello(Stringname);
}
/*** 接着创建一个类实现接口*/publicclassUserServiceImplimplementsUserService{
@OverridepublicvoidsayHello(Stringname) {
System.out.println("name:"+name+" hello");
    }
}

以上是准备工作,接下来实现一个约定的接口

/*** 首先创建约定编程接口* 定义约定的方法*/publicinterfaceInterceptor {
/*** 事前方法** @return 是否*/booleanbefore();
/*** 事后方法*/voidafter();
/*** 取代原有事件方法** @param invocation 回调参数,可以通过proceed 方法 调用原有目标方法* @return 原有事件返回结果* @throws InvocationTargetException* @throws IllegalAccessException*/Objectaround(Invocationinvocation)throwsInvocationTargetException,IllegalAccessException;
/*** 事后返回方法,事件没有发生异常执行*/voidafterReturning();
/*** 事后异常方法,当事件发生异常后执行*/voidafterThrowing();
}
/*** 接着创建约定编程接口的实现* 具体实现自己想要的功能*/publicclassMyInterceptorimplementsInterceptor{
@Overridepublicbooleanbefore() {
log.info("before.........");
returntrue;
    }
@Overridepublicvoidafter() {
log.info("after ....");
    }
@OverridepublicObjectaround(Invocationinvocation) throwsInvocationTargetException, IllegalAccessException {
log.info("around before.........");
Objectproceed=invocation.proceed();
log.info("around after.........");
returnproceed;
    }
@OverridepublicvoidafterReturning() {
log.info("afterReturning.........");
    }
@OverridepublicvoidafterThrowing() {
log.info("afterThrowing.........");
    }
}
/*** Invocation 类封装具体反射调用方法*/publicclassInvocation {
privateObject[] params;
privateMethodmethod;
privateObjecttarget;
publicInvocation(Objecttarget,Methodmethod,Object[] params){
this.target=target;
this.method=method;
this.params=params;
    }
publicObjectproceed()throwsInvocationTargetException,IllegalAccessException{
returnmethod.invoke(target,params);
    }
}

接下来是重要的核心,使用Java Proxy 来实现动态代理,完成变身大法;

/*** Java Proxy 代理需要实现InvocationHandler 接口用来实现动态代理*/publicclassProxyBeanimplementsInvocationHandler {
/*** 该target变量 存放的是被代理的类*/privateObjecttarget=null;
/*** 该interceptor变量存放目标拦截器*/privateInterceptorinterceptor=null;
/*** 构建代理对象方法* * @param target 被代理的对象* @param interceptor 想要代理时运行的方法对象* @return 整合好的代理对象*/publicstaticObjectgetProxyBean(Objecttarget,Interceptorinterceptor){
ProxyBeanproxyBean=newProxyBean();
proxyBean.target=target;
proxyBean.interceptor=interceptor;
// 通过Proxy 的方法 生成一个代理对象Objectinstance=Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), proxyBean);
returninstance;
    }
/*** 该方法是代理对象在调用被代理对象方法时一定会调用的方法* 在此对被代理方法进行包装的主要逻辑,其实等同于aop 中织入的过程* * @param proxy 目标对象* @param method 代理方法对象* @param args 方法入参* @return 返回被代理的方法的结果* @throws Throwable 抛出异常*/@OverridepublicObjectinvoke(Objectproxy, Methodmethod, Object[] args) throwsThrowable {
booleanexceptionFlag=false;
Invocationinvocation=newInvocation(target,method,args);
Objectobj=null;
try{
if (this.interceptor.before()){
obj=this.interceptor.around(invocation);
            }else {
obj=method.invoke(target,args);
            }
        }catch (Exceptionex){
exceptionFlag=true;
        }
this.interceptor.after();
if (exceptionFlag){
this.interceptor.afterThrowing();
        }else {
this.interceptor.afterReturning();
returnobj;
        }
returnnull;
    }
}

接下来是测试方法

publicclassProxyTest {
publicstaticvoidmain(String[] args) {
UserServiceuserService=newUserServiceImpl();
UserServiceproxyBean= (UserService) ProxyBean.getProxyBean(userService, newMyInterceptor());
// 因为是通过Proxy 实现的代理对象,Java 保证代理对象在调用目标方式时,一定会调用其invoke 方法proxyBean.sayHello("小明");
    }
}

以上就是完成约定编程的案例,其实细心的读者应该也可以发现,我们定义的约定编程的接口,类似于aop 中的通知(事前通知,事后通知,环绕通知等),而MyInterceptor 类相当于我们的切面,构建代理对象时ProxyBean.getProxyBean 方法,像是将目标对象通进行了绑定,最终代理对象调用目标方法时相当于连接点通过动态代理技术及反射技术完成了织入,不过这些都由框架实现了对我们来说透明了,要想探究其本质,则需要深入源码,遨游一番。


Spring AOP 底层实现

AOP 术语介绍

  • 连接点(join point):对应的是具体被拦截的对象,因为Spring只能支持方法,所以被拦截的对象往往就是指特定的方法;
  • 切点(point cut):有时候,切面不单单应用于单个方法,也可能是多个类的不同方法,这时,可以通过正则式和指示器的规则去定义,从而适配连接点。切点就是提供这样一个功能的概念。
  • 通知(advice):就是按照约定的流程下的方法,分为前置通知(beforeadvice)、后置通知(after advice)、环绕通知(around advice)、事后返回通知(afterReturning advice)和异常通知(afterThrowing advice),它会根据约定织入流程中,需要弄明白它们在流程中的顺序和运行的条件。
  • 目标对象(target):即被代理对象
  • 引入(introduction):是指引入新的类和其方法,增强现有Bean的功能。
  • 织入(weaving):它是一个通过动态代理技术,为原有服务对象生成代理对象,然后将与切点定义匹配的连接点拦截,并按约定将各类通知织入约定流程的过程。
  • 切面(aspect):是一个可以定义切点、各类通知和引入的内容,Spring AOP将通过它的信息来增强Bean的功能或者将对应的方法织入流程。

基于AOP 实现控制层日志打印

/*** controller 层日志打印切面*/@Component@Aspect@Slf4jpublicclassControllerLogHandler {
@ResourceprivateObjectMapperobjectMapper;
/*** 定义切点 该切点就是项目的controller 方法*/@Pointcut("execution(public * com.esaycodin.learn.controller.*.*(..))")
publicvoidlogPointCut() {
    }
/*** 定义具体逻辑* * @param joinPoint 切点对象传入* @return 结果* @throws Throwable 异常*/@Around("logPointCut()")
publicObjectaround(ProceedingJoinPointjoinPoint) throwsThrowable {
//判断是否忽略打印日志MethodSignaturemethodSignature= (MethodSignature) joinPoint.getSignature();
IgnoreSysLogignoreSysLog=methodSignature.getMethod().getAnnotation(IgnoreSysLog.class);
if (ignoreSysLog!=null) {
returnjoinPoint.proceed();
        }
//解析请求内容ServletRequestAttributesrequestAttributes= (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequestrequest=requestAttributes.getRequest();
//打印入参log.info("controller:{}-method:{}-param:{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName(), objectMapper.writeValueAsString(Arrays.toString(joinPoint.getArgs())));
log.info("remoteAddr:{}-request url:{}-method:{}", request.getRemoteAddr(), request.getRequestURL().toString(), request.getMethod());
longstartTime=System.currentTimeMillis();
Objectresult=joinPoint.proceed();
//执行时长log.info("resp value:{}", objectMapper.writeValueAsString(result));
log.info("cost:{}ms", (System.currentTimeMillis() -startTime));
returnresult;
    }
}
/*** 忽略controller层中请求的切面日志打印注解*/@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documentedpublic@interfaceIgnoreSysLog {
}

以上就是我们对学习了AOP 的一个具体功能实现。接下来,我们基于源码探秘一下Spring AOP 是如何实现的吧。


Spring AOP 源码

本次探秘的始发站就是AnnotationAwareAspectJAutoProxyCreator 类。下图为该类的结构关系图:

image.jpeg

我们可以看到其实现了BeanPostProcessor,也就是说在IOC 管理bean 的时候会调用BeanPostProcessor 的接口;具体可以看源码,这里指出几个关键方法。父类AbstractAutoProxyCreator的postProcessAfterInitialization 方法被框架调用,其执行过程中wrapIfNecessary方法判断bean 是否需要被AOP。我们具体关注getAdvicesAndAdvisorsForBean 方法及createProxy 方法。

wrapIfNecessary 源码:

protectedObjectwrapIfNecessary(Objectbean, StringbeanName, ObjectcacheKey) {
// 处理过不需要进行aop 逻辑if (StringUtils.hasLength(beanName) &&this.targetSourcedBeans.contains(beanName)) {
returnbean;
    } elseif (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
returnbean;
// 不是基础类的bean 且没有标识不需要自动代理的bean 也就是说要过自动代理的流程的bean 走以下逻辑    } elseif (!this.isInfrastructureClass(bean.getClass()) &&!this.shouldSkip(bean.getClass(), beanName)) {
// 获取AOP 相关切面几切面beanObject[] specificInterceptors=this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
if (specificInterceptors!=DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建proxyObjectproxy=this.createProxy(bean.getClass(), beanName, specificInterceptors, newSingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
returnproxy;
        } else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
returnbean;
        }
    } else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
returnbean;
    }
}

根据上面的方法,其实可以分析出,this.getAdvicesAndAdvisorsForBean 方法其实是对整个框架进行搜索Advisors 并确定与该bean 有关的advisor。


匹配bean合适的Advices

沿着getAdvicesAndAdvisorsForBean 该方法走我们会来到AnnotationAwareAspectJAutoProxyCreator 的findCandidateAdvisors 方法往下走会看到一个比较关键的方法就是BeanFactoryAspectJAdvisorsBuilder的buildAspectJAdvisors();该方法实现的功能是

  • 获取所有beanName,并将其从beanFacotry 中提取出来
  • 遍历所有的bean,并找出AspectJ 注解类,进行进一步的处理
  • 对标记为AspectJ注解的类进行提取
  • 将提取结果加入缓存(这一步就是再有其它bean 需要绑定时节省了获取的步骤了)

感兴趣的可以对照源码。

advice获取到了那么接下来就需要找到与当前bean匹配的了,具体的方法是AbstractAdvisorAutoProxyCreator类的findAdvisorsThatCanApply ;当我们找到了匹配的则进入到创建代理的流程。


创建代理

对于代理类的创建及处理,Srping 委托给了ProxyFactory来进行,接下来通过DefaultAopProxyFactory 下的createAopProxy 方法来看Spring 是通过什么来选择代理技术的:

publicAopProxycreateAopProxy(AdvisedSupportconfig) throwsAopConfigException {
if (!config.isOptimize() &&!config.isProxyTargetClass() &&!this.hasNoUserSuppliedProxyInterfaces(config)) {
returnnewJdkDynamicAopProxy(config);
    } else {
Class<?>targetClass=config.getTargetClass();
if (targetClass==null) {
thrownewAopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
        } else {
return (AopProxy)(!targetClass.isInterface() &&!Proxy.isProxyClass(targetClass) ?newObjenesisCglibAopProxy(config) : newJdkDynamicAopProxy(config));
        }
    }
}

从上面可以看出:

  • 如果目标对象实现了接口,默认情况下会采用Java的动态代理实现AOP。
  • 如果目标对象实现了接口,可以强制使用CGLIB实现AOP。
  • 如果目标对象没有实现了接口,必须采用CGLIB库,Spring会自动在JavaJava动态代理和CGLIB之间转换。


如何强制使用CGLIB 做AOP 代理?

  • 在SpringBoot 2.x中,如果需要替换使用Java动态代理可以通过配置项spring.aop.proxy-target-class=false来进行修改


Java动态代理和CGLIB字节码生成的区别?

  • Java动态代理只能对实现了接口的类生成代理,而不能针对类。
  • CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法,因为是继承,所以该类或方法最好不要声明成final。


由此结合开始的约定编程的案例,可以了解到Java Proxy 的调用流程,CGlib 则是通过构建一个链,串联的将方法进行增强。篇幅有限,就不过多介绍CGlib 了。


到此对于Spring AOP 的理解就告一段落了,大家加油。


相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
目录
打赏
0
0
0
0
2
分享
相关文章
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面(Aspect)、连接点(Join Point)、通知(Advice)、切点(Pointcut)等关键概念,解析了JDK动态代理与CGLIB代理的原理及对比,并深入探讨了通知执行链路和责任链模式的应用。同时,详细分析了AspectJ注解驱动的AOP解析过程,包括切面识别、切点表达式匹配及通知适配为Advice的机制,帮助理解Spring AOP的工作原理与实现细节。
面向切面编程(AOP)介绍--这是我见过最易理解的文章
这是我见过的最容易理解的文章,由浅入深介绍AOP面向切面编程,用科普版和专家版分别解说,有概念,有代码,有总结。
|
4月前
|
微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——Spring Boot 中的 AOP 处理
本文详细讲解了Spring Boot中的AOP(面向切面编程)处理方法。首先介绍如何引入AOP依赖,通过添加`spring-boot-starter-aop`实现。接着阐述了如何定义和实现AOP切面,包括常用注解如`@Aspect`、`@Pointcut`、`@Before`、`@After`、`@AfterReturning`和`@AfterThrowing`的使用场景与示例代码。通过这些注解,可以分别在方法执行前、后、返回时或抛出异常时插入自定义逻辑,从而实现功能增强或日志记录等操作。最后总结了AOP在实际项目中的重要作用,并提供了课程源码下载链接供进一步学习。
180 0
微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——什么是AOP
本文介绍了Spring Boot中的切面AOP处理。AOP(Aspect Oriented Programming)即面向切面编程,其核心思想是分离关注点。通过AOP,程序可以将与业务逻辑无关的代码(如日志记录、事务管理等)从主要逻辑中抽离,交由专门的“仆人”处理,从而让开发者专注于核心任务。这种机制实现了模块间的灵活组合,使程序结构更加可配置、可扩展。文中以生活化比喻生动阐释了AOP的工作原理及其优势。
91 0
Spring AOP—通知类型 和 切入点表达式 万字详解(通俗易懂)
Spring 第五节 AOP——切入点表达式 万字详解!
252 25
|
5月前
|
Spring AOP—深入动态代理 万字详解(通俗易懂)
Spring 第四节 AOP——动态代理 万字详解!
146 24
Spring Boot中的WebFlux编程模型
Spring WebFlux 是 Spring Framework 5 引入的响应式编程模型,基于 Reactor 框架,支持非阻塞异步编程,适用于高并发和 I/O 密集型应用。本文介绍 WebFlux 的原理、优势及在 Spring Boot 中的应用,包括添加依赖、编写响应式控制器和服务层实现。WebFlux 提供高性能、快速响应和资源节省等优点,适合现代 Web 应用开发。
403 15
阿里云工程师跟通义灵码结伴编程, 用Spring AI Alibaba来开发 AI 答疑助手
本次分享的主题是阿里云工程师跟通义灵码结伴编程, 用Spring AI Alibaba来开发 AI 答疑助手,由阿里云两位工程师分享。
267 0
阿里云工程师跟通义灵码结伴编程, 用Spring AI Alibaba来开发 AI 答疑助手
Spring Boot中的AOP实现
Spring AOP(面向切面编程)允许开发者在不修改原有业务逻辑的情况下增强功能,基于代理模式拦截和增强方法调用。Spring Boot通过集成Spring AOP和AspectJ简化了AOP的使用,只需添加依赖并定义切面类。关键概念包括切面、通知和切点。切面类使用`@Aspect`和`@Component`注解标注,通知定义切面行为,切点定义应用位置。Spring Boot自动检测并创建代理对象,支持JDK动态代理和CGLIB代理。通过源码分析可深入了解其实现细节,优化应用功能。
260 6
Spring Boot 3 集成Spring AOP实现系统日志记录
本文介绍了如何在Spring Boot 3中集成Spring AOP实现系统日志记录功能。通过定义`SysLog`注解和配置相应的AOP切面,可以在方法执行前后自动记录日志信息,包括操作的开始时间、结束时间、请求参数、返回结果、异常信息等,并将这些信息保存到数据库中。此外,还使用了`ThreadLocal`变量来存储每个线程独立的日志数据,确保线程安全。文中还展示了项目实战中的部分代码片段,以及基于Spring Boot 3 + Vue 3构建的快速开发框架的简介与内置功能列表。此框架结合了当前主流技术栈,提供了用户管理、权限控制、接口文档自动生成等多项实用特性。
315 8
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等