查找注解处理方法_Shiro权限注解与Aop冲突问题探究

// {}表示同上
.
├── DispatcherServlet.doService
│ ├── DispatcherServlet.doDispatch
│ ├── DispatcherServlet.getHandler
│ ├── AbstractHandlerMapping.getHandler
│ ├── RequestMappingInfoHandlerMapping.getHandlerInternal
│ └── AbstractHandlerMethodMapping.lookupHandlerMethod

@RestController
public class IndexController {
@GetMapping
@RequiresPermissions("admin")
public String empty() {
return "hello";
}
}

.
├── AbstractAutowireCapableBeanFactory.invokeInitMethods
│ ├── RequestMappingHandlerMapping.afterPropertiesSet
│ ├── AbstractHandlerMethodMapping.afterPropertiesSet
│ ├── AbstractHandlerMethodMapping.initHandlerMethods
│ ├── AbstractHandlerMethodMapping.processCandidateBean
│ └── AbstractHandlerMethodMapping.detectHandlerMethods

.
├── AnnotatedElementUtils.hasAnnotation
│ ├── TypeMappedAnnotations.isPresent
│ ├── TypeMappedAnnotations.scan
│ ├── AnnotationsScanner.scan
│ ├── AnnotationsScanner.scan
│ ├── AnnotationsScanner.process
│ ├── AnnotationsScanner.processClass
| └── AnnotationsScanner.processClassHierarchy

/**
* 按层次执行类查找
*
* @param context 需要寻找的注解
* @param aggregateIndex
* @param source 类对象
* @param processor 注解处理器
* @param classFilter 类过滤(判断是否要忽略某些类查找)
* @param includeInterfaces 是否包含接口
* @param includeEnclosing 是否包含匿名内部类
* @param 此处为Boolean
* @return 匹配成功返回true 否则返回false或者null
*/
private static R processClassHierarchy(C context, int[] aggregateIndex, Class source, AnnotationsProcessor processor, @Nullable BiPredicate> classFilter, boolean includeInterfaces, boolean includeEnclosing) {
try {
R result = processor.doWithAggregate(context, aggregateIndex[0]);
if (result != null) {
return result;
}
// 是否仅有普通的java注解
if (hasPlainJavaAnnotationsOnly(source)) {
return null;
}
// 判断类本身是否存在注解
Annotation[] annotatiOns= getDeclaredAnnotations(context, source, classFilter, false);
result = processor.doWithAnnotations(context, aggregateIndex[0], source, annotations);
if (result != null) {
return result;
}
aggregateIndex[0]++;
// 如果存在实现接口则遍历接口执行查找 判断接口上是否存在该注解
if (includeInterfaces) {
for (Class interfaceType : source.getInterfaces()) {
R interfacesResult = processClassHierarchy(context, aggregateIndex,
interfaceType, processor, classFilter, true, includeEnclosing);
if (interfacesResult != null) {
return interfacesResult;
}
}
}
// 向上查找所有父类
Class superclass = source.getSuperclass();
if (superclass != Object.class && superclass != null) {
R superclassResult = processClassHierarchy(context, aggregateIndex,
superclass, processor, classFilter, includeInterfaces, includeEnclosing);
if (superclassResult != null) {
return superclassResult;
}
}
// 查找内部类
if (includeEnclosing) {
// Since merely attempting to load the enclosing class may result in
// automatic loading of sibling nested classes that in turn results
// in an exception such as NoClassDefFoundError, we wrap the following
// in its own dedicated try-catch block in order not to preemptively
// halt the annotation scanning process.
try {
Class enclosingClass = source.getEnclosingClass();
if (enclosingClass != null) {
R enclosingResult = processClassHierarchy(context, aggregateIndex, enclosingClass, processor, classFilter, includeInterfaces, true);
if (enclosingResult != null) {
return enclosingResult;
}
}
}
catch (Throwable ex) {
AnnotationUtils.handleIntrospectionFailure(source, ex);
}
}
}
catch (Throwable ex) {
AnnotationUtils.handleIntrospectionFailure(source, ex);
}
return null;
}

.
├── AbstractAutowireCapableBeanFactory.doCreateBean
│ ├── {}.initializeBean
│ ├── {}.applyBeanPostProcessorsAfterInitialization
│ ├── AbstractAutoProxyCreator.postProcessAfterInitialization
│ ├── AbstractAutoProxyCreator.wrapIfNecessary
│ ├── {}.createProxy
│ ├── AnnotationsScanner.processClass
| └── AnnotationsScanner.processClassHierarchy

.
├── AspectJAutoProxyRegistrar.registerBeanDefinitions
│ ├── AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary
│ └── {}.registerOrEscalateApcAsRequired

/**
* 按需包装(代理)bean
*
* @param bean bean
* @param beanName bean名称
* @param cacheKey 缓存key 用以标记该bean是否需要被通知
* @return 包装(代理)后的bean
*/
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// this.advisedBeans在postProcessBeforeInstantiation即前置操作中初始化过一次
// 这里是跳过已经预先知道不需要被通知的bean
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// 在bean的前置处理时其实已经做过类似的判断
// isInfrastructureClass是判断是否为aop的基础设施类 诸如Advice，Pointcut，Advisor等
// shouldSkip是由bean名称判断是否为原始示例 如果为是（名称为bean类名+.ORIGINAL）则跳过
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 获取所有的通知bean 存在则进行代理操作
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;
}

/**
* 评估接口是否适合代理
*
* @param beanClass bean类对象
* @param proxyFactory 代理工厂
*/
protected void evaluateProxyInterfaces(Class beanClass, ProxyFactory proxyFactory) {
// 获取所有实现接口
Class[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
boolean hasReasOnableProxyInterface= false;
for (Class ifc : targetInterfaces) {
// isConfigurationCallbackInterface判断接口是否配置回调接口 例如：InitializingBean，Closeable等
// isInternalLanguageInterface判断接口是否内部语言接口 例如：GroovyObject，cglib代理工厂接口等
if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
ifc.getMethods().length > 0) {
hasReasOnableProxyInterface= true;
break;
}
}
if (hasReasonableProxyInterface) {
// Must allow for introductions; can't just set interfaces to the target's interfaces only.
for (Class ifc : targetInterfaces) {
proxyFactory.addInterface(ifc);
}
} else {
// 没有合适的实现接口则也设置为true
proxyFactory.setProxyTargetClass(true);
}
}

.
├── AbstractAutoProxyCreator.wrapIfNecessary
│ ├── {}.createProxy
│ ├── ProxyFactory.getProxy
| └── CglibAopProxy.getProxy

.
├── AbstractAutoProxyCreator.wrapIfNecessary
│ ├── {}.getAdvicesAndAdvisorsForBean
│ ├── AbstractAdvisorAutoProxyCreator.findEligibleAdvisors
│ ├── {}.findCandidateAdvisors
│ └── BeanFactoryAdvisorRetrievalHelper.findAdvisorBeans