目录
2.AnnotationAwareAspectJAutoProxyCreator是什么
4.AnnotationAwareAspectJAutoProxyCreator作为后置处理器做了什么
什么是AOP
AOP：（Aspect Oriented Programming）面向切面编程；
指在运行期间，将某段代码动态的切入到在指定方法的指定位置执行。
将业务逻辑与系统的其他功能(例如日志，事务，安全检查，权限控制等)进行松耦合
为什么不使用jdk内置动态代理
jdk默认的动态代理，如果目标对象没有实现任何接口，是无法为他创建代理对象的；
Spring实现了AOP功能；底层就是动态代理，可以利用Spring一句代码都不写的去创建动态代理；
术语
基于注解版的使用方法
1.编写业务逻辑类(被代理类：MathCalculator)
public class MathCalculator {
public int div(int i,int j){
return i/j;
}
}2.编写切面类，切面类中的方法需要动态的感知目标方法运行到哪里，并且将指定方法切入到切入点执行
@Aspect
public class LogAspects {
@Pointcut(value = "execution(public int org.song.aop.MathCalculator.div(..))")
public void pointcut(){};
//joinpoint必须放在参数列表的第一位
@Before("pointcut()")
public void logStart(JoinPoint joinPoint){
System.out.println("前置通知" + joinPoint.getSignature().getName() +"方法运行。。。参数列表是：" + Arrays.asList(joinPoint.getArgs()));
}
//无论方法正常结束还是异常结束都会执行
@After("pointcut()")
public void logEnd(JoinPoint joinPoint){
System.out.println("后置知"+joinPoint.getSignature().getName() + "除法结束");
}
@AfterReturning(value = "pointcut()",returning = "result")
public void logReturn(Object result){
System.out.println("除法正常返回。。。运行结果是:" + result);
}
@AfterThrowing(value = "pointcut()",throwing = "exception")
public void logException(Exception exception){
System.out.println("除法异常。。。异常信息是" + exception.getStackTrace().toString());
}
}
3.给配置类中加@EnableAspectJAutoProxy,开启基于注解的aop模式
@EnableAspectJAutoProxy
@Configuration
public class MainConfigAop {
@Bean
public MathCalculator mathCalculator(){
return new MathCalculator();
}
@Bean
public LogAspects logAspects(){
return new LogAspects();
}
}
源码解读
1.@EnableAspectJAutoProxy
要弄懂AOP原理，首先看@EnableAspectJAutoProxy究竟做了什么操作
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
//导入了一个组件
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
* to standard Java interface-based proxies. The default is {@code false}.
*/
boolean proxyTargetClass() default false;
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
boolean exposeProxy() default false;
}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.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
分析上面一段代码。实现了ImportBeanDefinitionRegistrar，重写了registerBeanDefinitions()方法，给Spring容器中注册了一个什么组件？？？、
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, 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
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;
}通过上述代码可知@EnableAspectJAutoProxy要给容器中注册了一个key为"internalAutoProxyCreator"，value为"AnnotationAwareAspectJAutoProxyCreator"的组件
2.AnnotationAwareAspectJAutoProxyCreator是什么
好了，我们已经知道要给容器中注册一个"AnnotationAwareAspectJAutoProxyCreator"的组件，那么这个组件究竟是什么呢，我们先来看看这个类的继承树。看看它究竟是个什么东西
首先可以看到它 implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware。说明它既是后置处理器也是一个Aware接口的实现类。那我们就来关注它作为后置处理器和Aware实现了那些功能。
3.后置处理器如何创建
们在AbstractAdvisorAutoProxyCreator类中的setBeanFactory()方法中打上断点，看看之前做了什么操作(不相干代码省略)
public void refresh() throws BeansException, IllegalStateException {
//注册bean的后置处理器来方便拦截bean的创建
registerBeanPostProcessors(beanFactory);
}protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//首先获得容器中所有的后置处理器，里面就有我们的internalAutoProxyCreator
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
//给容器中加spring自己的BeanPostProcessor
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
//定义集合用于存放实现了各个优先级的后置处理器，从继承树可知，我们是实现了Orderd接口的
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//首先注册实现了PriorityOrdered接口的后置处理器
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 然后注册实现了Orderd接口的后置处理器(我们的后置处理器在这里执行)
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
//这里创建了我们的后置处理器(internalAutoProxyCreator)
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
//将我们的后置处理器添加到beanFactory中
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
//最后注册未实现Orderd接口的后置处理器
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}看看后置处理器是如何创建的，进入getBean()->doGetBean()->getSingleton()->createBean()->doCreateBean()->initializeBean()
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
//执行对应的Aware接口的方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//应用后置处理的beanPostProcessorsBeforeInitialization()
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//执行后置处理器的beanPostProcessorsAfterInitialization()
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
//创建bean成功并返回
return wrappedBean;
}private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
//我们走这一条分支
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}//进入了之前的断点
public void setBeanFactory(BeanFactory beanFactory) {
super.setBeanFactory(beanFactory);
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalArgumentException(
"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
}
//看看这个方法干了什么
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}进入了类AnnotationAwareAspectJAutoProxyCreator的initBeanFactory()方法
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.initBeanFactory(beanFactory);
if (this.aspectJAdvisorFactory == null) {
//创建了一个反射的AspectJ增强器工厂
this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
}
//封装了增强器工厂和beanFactory
this.aspectJAdvisorsBuilder =
new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}上述整个流程下来后，AnnotationAwareAspectJAutoProxyCreator创建完成并且注册到beanFactory与一级缓存中。
4.AnnotationAwareAspectJAutoProxyCreator作为后置处理器做了什么
再看看继承树。AnnotationAwareAspectJAutoProxyCreator实现了InstantiationAwareBeanPostProcessor接口。看看该接口有什么
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException;
}
由上可知我们需要实现postProcessBeforeInstantiation(),postProcessAfterInstantiation(),postProcessPropertyValues()，以及postProcessBeforeInitialization(),postProcessAfterInitialization()。我们在这些实现方法上打上断点，看看执行了什么。
public void refresh() throws BeansException, IllegalStateException {
//初始化剩下的单实例bean。
finishBeanFactoryInitialization(beanFactory);
}protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//实例化剩下的单实例bean
beanFactory.preInstantiateSingletons();
}
getBean()->doGetBean()->getSingletone()->createBean()
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
//给后置处理器一个机会去生成当前bean的代理对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
//如果生成代理对象就直接返回
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//如果没有生成代理对象就去创建bean。
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//后置处理器尝试返回对象
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//如果返回对象，执行后置处理器的此方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
//获取所有的后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//如果后置处理器实现了InstantiationAwareBeanPostProcessor，则执行下面的方法
//刚好我们的后置处理器实现了该接口
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//执行此方法
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}顺带说一下：看了上述代码应该能明白，后置处理器也是分种类的。InstantiationAwareBeanPostProcessor会在Bean实例化前执行，BeanPostProcessor会在Bean初始化前后执行。
现在终于到了我们打断点的地方了。
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = getCacheKey(beanClass, beanName);
if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
//判断当前bean是否已经被增强了，我们的(mathCalculator)现在当然还没有增强
//advisedBeans保存了所有需要被增强的bean
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
//isInfrastructureClass判断当前bean是否是实现了Advice，Pointcut，Advisor，
//AopInfrastructureBean接口，或者是否是切面。我们当然不是。
//shouldSkip判断是否需要被跳过，首先拿到所有的增强器(通知方法)，判断是否是
//AspectJPointcutAdvisor类型，我们也不是
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
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;
}最终还是返回null，进入doCreateBean()创建对象，创建完成后进入initializeBean()方法
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//我们的后置处理器在此方法无落地实现
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//看看我们的后置处理器在此做了什么
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
//做了什么呢
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}ublic 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;
}protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (beanName != null && 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;
}
//获取当前bean的所有增强器(通知方法)，排序并返回
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
//将当前bean保存在advisedBeans中
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//创建当前bean的代理对象，我们看看是如何创建代理对象的
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;
}protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
//创建了一个代理工厂
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
//获取所有增强器
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
//将增强器保存到代理工厂中
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
//用代理工厂帮我们创建代理对象
return proxyFactory.getProxy(getProxyClassLoader());
}public Object getProxy(ClassLoader classLoader) {
//创建AOP代理
return createAopProxy().getProxy(classLoader);
}public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
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.");
}
//如果实现了接口就使用JDK动态代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
//如果没有实现接口就使用Cglib
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
到此为止，容器中获取的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；
5.从源码看目标方法的调用
直接进入CglibAopProxy的intercept()方法
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Class<?> targetClass = null;
Object target = null;
try {
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
target = getTarget();
if (target != null) {
targetClass = target.getClass();
}
//获取目标方法的拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
//如果没有拦截器链，直接执行目标方法
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
//如果有拦截器链，，把目标对象，目标方法，拦截器链等信息等传入，并调用proceed()
else {
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null) {
releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}那么如何获取拦截器链呢？
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
MethodCacheKey cacheKey = new MethodCacheKey(method);
List<Object> cached = this.methodCache.get(cacheKey);
if (cached == null) {
//此处获取拦截器链
cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this, method, targetClass);
this.methodCache.put(cacheKey, cached);
}
return cached;
}public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, Class<?> targetClass) {
//保存所有的拦截器，长度是增强器集合的长度
List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
//遍历所有增强器，将其转为MethodInterceptor[] interceptors并加入集合中
for (Advisor advisor : config.getAdvisors()) {
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
//将增强器转为MethodInterceptor类型
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
if (mm.isRuntime()) {
// Creating a new object instance in the getInterceptors() method
// isn't a problem as we normally cache created chains.
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {
interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
}
else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}从上述可知拦截器链就是“每个通知方法被封装为方法拦截器MethodInterceptor，将他们放入interceptorList 中”
拦截器链的触发过程，只需要查看CglibMethodInvocation的procced()方法即可
首先需要明确interceptorsAndDynamicMethodMatchers中拦截器的顺序是什么样的
0.ExposeInvocationInterceptor
1.AspectJAfterThrowingAdvice
2.AspectJAfterReturningAdvice
3.AspectJAfterAdvice
4.AspectJMethodBeforeAdvice
public Object proceed() throws Throwable {
//currentInterceptorIndex初始值为-1，两种情况，如果拦截器长度为0，也就是没有拦截器，那
//么直接执行目标方法，或者currentInterceptorIndex与拦截器的size-1相等，那么也执行目标
//方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
//利用反射执行目标方法
return invokeJoinpoint();
}
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
return proceed();
}
}
else {
//第一次进入此方法
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
递归第一次进入proceed方法:ExposeInvocationInterceptor
public Object invoke(MethodInvocation mi) throws Throwable {
MethodInvocation oldInvocation = invocation.get();
invocation.set(mi);
try {
//还是执行了proceed()方法，相当于与上一段代码进行了递归调用
return mi.proceed();
}
finally {
invocation.set(oldInvocation);
}
}
递归第二次进入proceed方法:AspectJAfterThrowingAdvice
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}
catch (Throwable ex) {
if (shouldInvokeOnThrowing(ex)) {
invokeAdviceMethod(getJoinPointMatch(), null, ex);
}
throw ex;
}
}递归第三次进入proceed方法：AspectJAfterReturningAdvice
public Object invoke(MethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
递归第四次进入proceed方法：AspectJAfterAdvice
public Object invoke(MethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}
finally {
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}递归第五次进入此方法：AspectJMethodBeforeAdvice
public Object invoke(MethodInvocation mi) throws Throwable {
//此时直接执行了前置通知
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
//随后才递归进入proceed()方法
return mi.proceed();
}
public Object proceed() throws Throwable {
//此时currentInterceptorIndex==this.interceptorsAndDynamicMethodMatchers.size() - 1为true，直接执行目标方法并返回
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
//利用反射执行目标方法
return invokeJoinpoint();
}
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
return proceed();
}
}
else {
//第一次进入此方法
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
4337
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
