从约定编程到理解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日志并进行多维度分析。
相关文章
|
3天前
|
Java Spring
一键注入 Spring 成员变量,顺序编程
介绍了一款针对Spring框架开发的插件,旨在解决开发中频繁滚动查找成员变量注入位置的问题。通过一键操作(如Ctrl+1),该插件可自动在类顶部添加`@Autowired`注解及其成员变量声明,同时保持光标位置不变,有效提升开发效率和代码编写流畅度。适用于IntelliJ IDEA 2023及以上版本。
一键注入 Spring 成员变量,顺序编程
|
1月前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP(面向切面编程)的基本概念和术语,并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语,并提供了完整的示例代码,帮助读者轻松理解和应用Spring AOP。
Spring Aop该如何使用
|
13天前
|
监控 安全 Java
什么是AOP?如何与Spring Boot一起使用?
什么是AOP?如何与Spring Boot一起使用?
40 5
|
17天前
|
Java 开发者 Spring
深入解析:Spring AOP的底层实现机制
在现代软件开发中,Spring框架的AOP(面向切面编程)功能因其能够有效分离横切关注点(如日志记录、事务管理等)而备受青睐。本文将深入探讨Spring AOP的底层原理,揭示其如何通过动态代理技术实现方法的增强。
47 8
|
17天前
|
Java 开发者 Spring
Spring AOP 底层原理技术分享
Spring AOP(面向切面编程)是Spring框架中一个强大的功能,它允许开发者在不修改业务逻辑代码的情况下,增加额外的功能,如日志记录、事务管理等。本文将深入探讨Spring AOP的底层原理,包括其核心概念、实现方式以及如何与Spring框架协同工作。
|
17天前
|
XML 监控 安全
深入调查研究Spring AOP
【11月更文挑战第15天】
32 5
|
17天前
|
Java 开发者 Spring
Spring AOP深度解析:探秘动态代理与增强逻辑
Spring框架中的AOP(Aspect-Oriented Programming,面向切面编程)功能为开发者提供了一种强大的工具,用以将横切关注点(如日志、事务管理等)与业务逻辑分离。本文将深入探讨Spring AOP的底层原理,包括动态代理机制和增强逻辑的实现。
27 4
|
1月前
|
安全 Java 编译器
什么是AOP面向切面编程?怎么简单理解?
本文介绍了面向切面编程(AOP)的基本概念和原理,解释了如何通过分离横切关注点(如日志、事务管理等)来增强代码的模块化和可维护性。AOP的核心概念包括切面、连接点、切入点、通知和织入。文章还提供了一个使用Spring AOP的简单示例,展示了如何定义和应用切面。
96 1
什么是AOP面向切面编程?怎么简单理解?
|
2月前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程,从源码角度详细讲解了Bean如何被AOP代理,包括代理对象的创建、配置与执行逻辑,帮助读者全面掌握Spring AOP的核心技术。
43 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
|
1月前
|
Java Spring
[Spring]aop的配置与使用
本文介绍了AOP(面向切面编程)的基本概念和核心思想。AOP是Spring框架的核心功能之一,通过动态代理在不修改原代码的情况下注入新功能。文章详细解释了连接点、切入点、通知、切面等关键概念,并列举了前置通知、后置通知、最终通知、异常通知和环绕通知五种通知类型。
30 1