源码解析Spring AOP的加载与生效
本次博主主要进行Spring AOP这里的解析，因为在工作中使用后，却不知道背后的实现原理并在使用的过程中发现了一些认知缺陷，所以决定写这么一篇文章以供大家参考参考，进入正题。
本次博主使用了@Aspect、@Around、@PointCut注解实现了一些小的需求，大家想必都用过，我就简单的举个例子吧。
@Aspect
@Component
public class CrmCacheAspect {
@Autowired
StringRedisTemplate stringRedisTemplate;
private ConcurrentHashMap<String, ICacheResultParser> parserMap = new ConcurrentHashMap();
private ConcurrentHashMap<String, IKeyGenerator> generatorMap = new ConcurrentHashMap();
private ConcurrentHashMap<String,Boolean> keyMap = new ConcurrentHashMap<>();
@Pointcut("@annotation(com.bjh.hms.crm.annotation.CrmCache)")
public void pointCut(){}
@Around("pointCut() && @annotation(crmCache)")
public Object joinPoint(ProceedingJoinPoint joinPoint, CrmCache crmCache) throws InstantiationException, IllegalAccessException {
String value = "";
String key = "";
Object result = "";
try {
key = getKey(crmCache,joinPoint);
value = stringRedisTemplate.opsForValue().get(key);
} catch (Exception e) {
XxlJobHelper.log("获取缓存{}失败：{}",crmCache.key(),e);
} finally {
if (StringUtils.isBlank(value)) {
value = synchronizeCache(key, joinPoint, crmCache);
}
result = getResult(crmCache, value, joinPoint);
}
return result;
}
private Object getResult(CrmCache crmCache,
String value,
ProceedingJoinPoint joinPoint) throws InstantiationException, IllegalAccessException {
if (value == null) {
return null;
}
String name = crmCache.parser().getName();
ICacheResultParser iCacheResultParser;
if (parserMap.containsKey(name)) {
iCacheResultParser = parserMap.get(name);
} else {
iCacheResultParser = crmCache.parser().newInstance();
parserMap.put(name,iCacheResultParser);
}
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Class returnType = signature.getReturnType();
Object parse = iCacheResultParser.parse(value, returnType);
return parse;
}
/**
* Title: 解决redis并发穿透
* @author 2021/8/13 17:15
* @return java.lang.String
*/
private String synchronizeCache(String key,
ProceedingJoinPoint joinPoint,
CrmCache crmCache) {
String value = "";
//暂停100-200ms，线程顺序执行
try {
Thread.sleep((int)(Math.random()*(200 - 100 + 1) + 100));
} catch (InterruptedException e) {
XxlJobHelper.log("synchronizeCache error {}", ExceptionUtil.stacktraceToString(e));
}
while (StringUtils.isBlank(value = stringRedisTemplate.opsForValue().get(key))
&& (keyMap.get(key) == null || keyMap.get(key))){
//防止重复调用
if (keyMap.get(key) == null || !keyMap.get(key)) {
keyMap.put(key,true);
Object proceed = null;
try {
proceed = joinPoint.proceed();
} catch (Throwable e) {
XxlJobHelper.log("处理失败：{}",ExceptionUtil.stacktraceToString(e));
}
putValueByRedis(key,proceed,crmCache);
keyMap.put(key,false);
}
}
keyMap.remove(key);
return value;
}
private void putValueByRedis(String key, Object value, CrmCache crmCache) {
if (value == null) {
return;
}
if (value instanceof String) {
stringRedisTemplate.opsForValue().set(key, value.toString());
} else {
String jsonString = JSONObject.toJSONString(value);
stringRedisTemplate.opsForValue().set(key,jsonString);
}
//-1代表不过期
if (crmCache.expire() != -1) {
stringRedisTemplate.expire(key, crmCache.expire(), TimeUnit.MINUTES);
}
}
private String getKey(CrmCache crmCache, ProceedingJoinPoint joinPoint) throws InstantiationException, IllegalAccessException {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
Object[] args = joinPoint.getArgs();
String iKeyGeneratorName = crmCache.generator().getName();
String key = crmCache.key();
IKeyGenerator iKeyGenerator = null;
if (generatorMap.containsKey(iKeyGeneratorName)) {
iKeyGenerator = generatorMap.get(iKeyGeneratorName);
} else {
iKeyGenerator = crmCache.generator().newInstance();
generatorMap.put(iKeyGeneratorName,iKeyGenerator);
}
return iKeyGenerator.generate(key,method,args);
}
}
本例子主要是对结果与请求进行解析缓存，spring其实有自带的，但是不可以使用缓存时间，有缓存时间又需要引入其他依赖包，公司内部私服又是内网访问的，所以就自写了一个简单的注解实现了缓存有限时间功能。这不是重点，我们来分析一下注解是如何加载进来的，又是如何被spring走进来解析的吧。
讲解之前，博主还是一如既往的为大家画了几张草图，以便大家防止看代码看晕，先来第一张：aspect注解源码分析加载与生效
https://www.processon.com/view/link/6134aae163768906a2203894
我们开始走代码，我们直接走bean的创建开始，如果有小伙伴不知道整个bean创建流程的话，可以看一下博主以前的画 的草图脑补一下：
https://www.processon.com/view/link/5f704050f346fb166d0f3e3c
代码走起，任意的bean创建都可以，如果看不了静态代码，自行debug就可以了。
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// 确定是否有aspect注解
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//解析注解
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//此处会给有自定义注解的bean创建代理类返回
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
我们分析一下hasInstantiationAwareBeanPostProcessors方法，看看是如何走进来的，从方法名字可以看出，是否有InstantiationAwareBeanPostProcessors后置处理器，那我们本身并没有去填加这个类，那怎么就有了呢，原因就在我们引入aop包依赖后，有一个默认的自动配置AopAutoConfiguration，EnableAspectJAutoProxy注解中间引入了一个AspectJAutoProxyRegistrar类，实现这个registerBeanDefinitions方法后，引入了一个AnnotationAwareAspectJAutoProxyCreator类，这个类就是AspectJAutoProxyRegistrar的实现类，所以hasInstantiationAwareBeanPostProcessors方法走通了。
再看一下applyBeanPostProcessorsBeforeInstantiation方法解析注解流程。
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}//我们主要分析一下shouldSkip方法
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.
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
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;
}
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
// TODO: Consider optimization by caching the list of the aspect names
//主要这里获取了注解
List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor &&
((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
return true;
}
}
return super.shouldSkip(beanClass, beanName);
}
//此方法分为两步
protected List<Advisor> findCandidateAdvisors() {
// Add all the Spring advisors found according to superclass rules.
//第一步从bean工厂中找到所有Advisor的实现类
List<Advisor> advisors = super.findCandidateAdvisors();
// Build Advisors for all AspectJ aspects in the bean factory.
if (this.aspectJAdvisorsBuilder != null) {
//主要是第二步：从bean工厂中找到所有带有@aspect注解的类
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
return advisors;
}
我们直接看第二步即可
public List<Advisor> buildAspectJAdvisors() {
List<String> aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
synchronized (this) {
aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
List<Advisor> advisors = new ArrayList<>();
aspectNames = new ArrayList<>();
//获取所有类
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Object.class, true, false);
for (String beanName : beanNames) {
if (!isEligibleBean(beanName)) {
continue;
}
// We must be careful not to instantiate beans eagerly as in this case they
// would be cached by the Spring container but would not have been weaved.
Class<?> beanType = this.beanFactory.getType(beanName);
if (beanType == null) {
continue;
}
//改类是否是我们写的aspect注解类
if (this.advisorFactory.isAspect(beanType)) {
aspectNames.add(beanName);
AspectMetadata amd = new AspectMetadata(beanType, beanName);
if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
MetadataAwareAspectInstanceFactory factory =
new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
//开始在这里解析
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
if (this.beanFactory.isSingleton(beanName)) {
this.advisorsCache.put(beanName, classAdvisors);
}
else {
this.aspectFactoryCache.put(beanName, factory);
}
advisors.addAll(classAdvisors);
.......
return advisors;
}
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
//获取我们的注解类
Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
//获取名称
String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
validate(aspectClass);
// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
// so that it will only instantiate once.
MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
List<Advisor> advisors = new ArrayList<>();
//这里循环获取我们类的方法，找到除Pointcut注解外的注解方法
for (Method method : getAdvisorMethods(aspectClass)) {
//解析方法，如果找到Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class注解，则返回InstantiationModelAwarePointcutAdvisorImpl生成类
Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
if (advisor != null) {
advisors.add(advisor);
}
}
.......
return advisors;
}
自此，我们的注解就解析完成了，不过心细的同学发现了，直解析了除Pointcut注解外的注解，Pointcut直接没有解析啊，这个注解一般我们都配置在了Around等注解里面，会有解析类去解析这个方法的。我们看看实例化后的后置处理器逻辑再
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//遍历所有后置处理器，但是我们只看AbstractAutoProxyCreator类的
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
//调用此方法
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
//是否有注解
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//有则创建代理类返回
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
为了清晰逻辑，中间的环节代码就不看了，直接看一下返回的是啥。
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//config.isProxyTargetClass()这个默认时true，为什么走cglib代理呢？
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);
}
}
为什么spring默认走cglib代理呢？我们大家可能还知道一个注解是@EnableAspectJAutoProxy，其实这个才是控制的开关。如果我们写成false的话是走jdk代理的，但是为什么我们自己的配置类配置EnableAspectJAutoProxy注解了也是无效的呢？这时候就要看一下AopAutoConfiguration自动配置类了，为了防止大家看晕，博主也画了一张草图：
https://www.processon.com/view/link/6134bef3e401fd1fb6a91dc6
public class AopAutoConfiguration {
//jdk和cglib都有注解，但是默认只有一个生效了，就是CglibAutoProxyConfiguration，因为ConditionalOnProperty注解说明了一起
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
public static class JdkDynamicAutoProxyConfiguration {
}
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
public static class CglibAutoProxyConfiguration {
}
}
当我们不去在配置文件中明确标明spring.aop.proxy-target-class属性时，只有就是CglibAutoProxyConfiguration是生效的，怕有些小伙伴不知道ConditionalOnProperty注解的作用，博主就简单带带大家看一下，熟悉同学可以自行略过，在spring解析配置类时，就会解析该注解
//这是校验配置类的时候解析的，路径-》org.springframework.context.annotation.ConditionEvaluator#shouldSkip
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
//由于jdk和cglib类都有Conditional的子注解，所以都通过了
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
return false;
}
if (phase == null) {
if (metadata instanceof AnnotationMetadata &&
ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
}
return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}
List<Condition> conditions = new ArrayList<>();
//找到ConditionalOnProperty注解
for (String[] conditionClasses : getConditionClasses(metadata)) {
for (String conditionClass : conditionClasses) {
Condition condition = getCondition(conditionClass, this.context.getClassLoader());
conditions.add(condition);
}
}
AnnotationAwareOrderComparator.sort(conditions);
for (Condition condition : conditions) {
ConfigurationPhase requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
}
//开始检验是否匹配
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
return true;
}
}
return false;
}
public final boolean matches(ConditionContext context,
AnnotatedTypeMetadata metadata) {
String classOrMethodName = getClassOrMethodName(metadata);
try {
//走这里查看OnPropertyCondition匹配即可
ConditionOutcome outcome = getMatchOutcome(context, metadata);
logOutcome(classOrMethodName, outcome);
recordEvaluation(context, classOrMethodName, outcome);
return outcome.isMatch();
}
......
}
private void collectProperties(PropertyResolver resolver, List<String> missing,
List<String> nonMatching) {
for (String name : this.names) {
String key = this.prefix + name;
if (resolver.containsProperty(key)) {
if (!isMatch(resolver.getProperty(key), this.havingValue)) {
nonMatching.add(name);
}
}
else {
//直接查看关键代码，如果配置文件中没有该属性，查看是否注解中写了matchIfMissing属性，而我们的cglib是true，所以，不会missing，而是装配起来了，所以默认走cglib代理
if (!this.matchIfMissing) {
missing.add(name);
}
}
}
}
现在我们的注解不仅加载完了，而且被注解表明的也生成了代理类，我们看看切面注解是如何生效的，我们就以cglib举例了，jdk类似
//CglibAopProxy
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
TargetSource targetSource = this.advised.getTargetSource();
try {
.....
//获取是否有拦截链，并不是我们的请求拦截器，这里把切面认为是一种拦截器了
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// Check whether we only have one InvokerInterceptor: that is,
// no real advice, but just reflective invocation of the target.
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// We can skip creating a MethodInvocation: just invoke the target directly.
// Note that the final invoker must be an InvokerInterceptor, so we know
// it does nothing but a reflective operation on the target, and no hot
// swapping or fancy proxying.
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
else {
// We need to create a method invocation...
//主要就是走后面的.proceed()方法
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
.....
}
}
}
//这里就像走我们的请求过滤器一样，每个拦截器都走一遍，最后都调用proceed()再回到这个方法，直到++this.currentInterceptorIndex到头终止
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
//别的我们不看，就看我们自己定义的@around
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
调用反射的时候，就会发现我们的around中才会去解析pointcut方法，因为我们在around注解里面写了，具体设这个类PointcutParser#parsePointcutExpression去进行解析的，将pointcut的表达式放入到around中作为参数传递。
对此，Spring AOP就全部讲解完毕了，里面为了减少文章篇幅，去掉了一些中间的跳转代码，具体可以看一下，博主发的草图，草图中所以的逻辑都很清晰，也贴了一些关键性的逻辑代码。希望大家可以在深入了解了解。
