AOP（Aspect Oriented Programming）是基于切面编程的，可无侵入的在原本功能的切面层添加自定义代码，一般用于日志收集、权限认证等场景。
AOP基本概念
通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理；
Before ：前置通知，在连接点方法前调用；对应Spring中@Before注解； After ：后置通知，在连接点方法后调用；对应Spring中的@After注解； AfterReturning：返回通知，在连接点方法执行并正常返回后调用，要求连接点方法在执行过程中没有发生异常；对应Spring中的@AfterReturning注解； AfterThrowing：异常通知，当连接点方法异常时调用；对应Spring中的@AfterThrowing注解； Around：环绕通知，它将覆盖原有方法，但是允许你通过反射调用原有方法；对应Spring中的@Around注解；
连接点（Join Point）: 连接点表示应用执行过程中能够插入切面的一个点。在 Spring AOP 中，连接点总是方法的调用，可以说目标对象中的方法就是一个连接点；
切点（Pointcut）: 就是连接点的集合；对应Spring中的@Pointcut注解；
目前Spring支持的切点匹配表达式主要有以下几种： execution：可以定义到的最小粒度是方法，修饰符，包名，类名，方法名，Spring AOP主要也是使用这个匹配表达式； within：只能定义到类；例如@Pointcut(within(com.jnu.example.*)) this：当前生成的代理对象的类型匹配； target：目标对象类型匹配； annotation：针对注解； args：只针对参数； 例如： execution (* com.sample.service..*. *(..)) 整个表达式可以分为五个部分： 1、execution():：表达式主体； 2、第一个*号：表示返回类型， *号表示所有的类型； 3、包名：表示需要拦截的包名，包名后面的..，表明com.sample.service包、及其子包； 4、第二个*号：表示类名，*号表示所有的类； 5、*(..)：最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个点表示任何参数；
切面（Aspect）: 切面是通知和切点的结合；对应Spring中的注解@Aspect修饰的一个类；
目标对象（Target object）：即被代理的对象；
代理对象（AOP proxy）：包含了目标对象的代码和增强后的代码的那个对象；
自定义注解实例可以参见：注解
@EnableAspectJAutoProxy分析
在spring-boot-autoconfigure-**.jar中，有个配置类，来控制AOP功能的开启和关闭：
@Configuration(proxyBeanMethods = false) @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true) public class AopAutoConfiguration { @Configuration(proxyBeanMethods = false) @ConditionalOnClass(Advice.class) static class AspectJAutoProxyingConfiguration { @Configuration(proxyBeanMethods = false) @EnableAspectJAutoProxy(proxyTargetClass = false) @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false) static class JdkDynamicAutoProxyConfiguration { } @Configuration(proxyBeanMethods = false) @EnableAspectJAutoProxy(proxyTargetClass = true) @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true) static class CglibAutoProxyConfiguration { } } @Configuration(proxyBeanMethods = false) @ConditionalOnMissingClass("org.aspectj.weaver.Advice") @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true) static class ClassProxyingConfiguration { ClassProxyingConfiguration(BeanFactory beanFactory) { if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry); AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry); } } } }
AopAutoConfiguration
使用@ConditionalOnProperty注解，默认开启AOP功能；
spring.aop.proxy-target-class没有配置时，默认开启Cglib动态代理；
@EnableAspectJAutoProxy注解，声明开启AOP功能。
@EnableAspectJAutoProxy注解的核心是引入了AspectJAutoProxyRegistrar，然后向容器中注册一个AnnotationAwareAspectJAutoProxyCreator：
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar { /** * Register, escalate, and configure the AspectJ auto proxy creator based on the value * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing * {@code @Configuration} class. */ @Override public void registerBeanDefinitions( AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class); if (enableAspectJAutoProxy != null) { if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) { AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry); } if (enableAspectJAutoProxy.getBoolean("exposeProxy")) { AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry); } } } }
registerBeanDefinitions
此时下面源码中的第三个方法会进入if代码块内，然后返回null：
@Nullable public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) { return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null); } @Nullable public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary( BeanDefinitionRegistry registry, @Nullable Object source) { return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source); } @Nullable private static BeanDefinition registerOrEscalateApcAsRequired( Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) { BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME); if (!cls.getName().equals(apcDefinition.getBeanClassName())) { int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName()); int requiredPriority = findPriorityForClass(cls); if (currentPriority < requiredPriority) { apcDefinition.setBeanClassName(cls.getName()); } } return null; } RootBeanDefinition beanDefinition = new RootBeanDefinition(cls); beanDefinition.setSource(source); beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE); beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition); return beanDefinition; }
AopConfigUtils
AnnotationAwareAspectJAutoProxyCreator分析
在AnnotationAwareAspectJAutoProxyCreator的继承关系中，有一个AbstractAutoProxyCreator类。该类定义了下面两个方法，它们分别拦截目标bean创建，和初始化流程：
@Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { Object cacheKey = getCacheKey(beanClass, beanName); if (beanName == null || !this.targetSourcedBeans.contains(beanName)) { if (this.advisedBeans.containsKey(cacheKey)) { return null; } if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return null; } } // Create proxy here if we have a custom TargetSource. // Suppresses unnecessary default instantiation of the target bean: // The TargetSource will handle target instances in a custom fashion. if (beanName != null) { TargetSource targetSource = getCustomTargetSource(beanClass, beanName); if (targetSource != null) { this.targetSourcedBeans.add(beanName); Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource); Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } } return null; } //在创建其他bean时，调用该方法，创建代理的bean，从而将AOP方式注入的方法，注入到目标bean中 @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (!this.earlyProxyReferences.contains(cacheKey)) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean;
postProcessAfterInitialization方法中的wrapIfNecessary方法，会为目标对象动态地创建JdkDynamicAopProxy或者ObjenesisCglibAopProxy的代理对象。
AOP实战
日期代理：
1 @Aspect 2 @Component("logAspect") 3 public class LogAspect { 4 5 private static final Logger log = LoggerFactory.getLogger(LogAspect.class); 6 7 // 配置织入点 8 @Pointcut("@annotation(com.ryj.annotation.Log)") 9 public void logPointCut() { 10 } 11 12 /** 13 * 是否存在注解，如果存在就获取 14 */ 15 private static Log getAnnotationLog(JoinPoint joinPoint) throws Exception { 16 Signature signature = joinPoint.getSignature(); 17 MethodSignature methodSignature = (MethodSignature) signature; 18 Method method = methodSignature.getMethod(); 19 if (method != null) { 20 return method.getAnnotation(Log.class); 21 } 22 return null; 23 } 24 25 26 @Around("logPointCut()") 27 public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable { 28 long startTimeMillis = System.currentTimeMillis(); 29 Log controllerLog = getAnnotationLog(joinPoint); 30 if (controllerLog == null) { 31 return null; 32 } 33 // 获得方法名称 34 String className = joinPoint.getTarget().getClass().getSimpleName(); 35 String methodName = joinPoint.getSignature().getName(); 36 String action = controllerLog.action(); 37 String title = controllerLog.title(); 38 Object[] args = joinPoint.getArgs(); 39 //序列化时过滤掉request和response 40 List<Object> logArgs = Arrays.stream(args) 41 .filter(arg -> (!(arg instanceof HttpServletRequest) && !(arg instanceof HttpServletResponse))) 42 .collect(Collectors.toList()); 43 String argStr = JSON.toJSONString(logArgs); 44 //打印日志，如有需要还可以存入数据库 45 log.info(">>>>>模块[{}]：{} 操作[{}]：{} 参数：{}",className,title,methodName,action,argStr); 46 //log.info("访问的接口 ==> {} 请求参数 ==> {}" ,requestPath, argStr); 47 Object result = joinPoint.proceed() ; 48 log.info(">>>>>耗时 ==> {}ms" ,System.currentTimeMillis() - startTimeMillis); 49 return result ; 50 } 51 52 }
LogAspect
支付宝扫一扫
微信扫一扫
最新评论