前言:
Spring作为java开发必用的开源框架之一,必然有它非常优秀的且不可替代的地方,其中springIOC和Aop就是设计的非常优秀的地方,今天一起来学习一下spring是如何实现AOP
AOP实现的思想:简单来讲就是使用了动态代理,对业务方法进行拦截增强(cglib或者jdk)
继续深入的思考一下如下问题:
- 如何创建动态代理
- 如何判断哪些类需要被代理增强,那些类不需要被增强
- 如何获取通知类
- ......
需要掌握的一些概念或技能:
- 动态代理
- 后置处理器
- Spring的注解的使用如@Import等
- 切面,通知、切点等aop相关的概念
- ......
下面开始跟大家一起学习SpringAOP
一、编写用于debug的aop的demo应用程序
1、业务类Calculator.java
@Component
public class Calculator {
public int div(int x,int y){
System.out.println("calculator div running...");
return x/y;
}
}
2、切面类LogAspects.java
@Aspect
@Component
public class LogAspects {
@Pointcut("execution(public int cap1.Calculator.*(..))")
public void pointCut(){}
@Before(value = "pointCut()")
public void logStart(JoinPoint joinPoint){
System.out.println("start...");
System.out.println(joinPoint.getSignature().getName());
for(Object obj : joinPoint.getArgs()){
System.out.println("----"+obj);
}
System.out.println(joinPoint.getTarget().toString());
}
@After(value = "pointCut()")
public void logEnd(){
System.out.println("end....");
}
@AfterReturning(value = "pointCut()",returning = "result")
public void logReturn(Object result){
System.out.println("return....");
System.out.println("result = "+result);
}
@AfterThrowing(value = "pointCut()",throwing = "exception")
public void logThrowing(Exception exception){
System.out.println("throwing");
}
@Around(value = "pointCut()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("around proceeding start....");
Object proceed = joinPoint.proceed();
System.out.println("around proceeding end");
return proceed;
}
}
3、配置类MainConfig.java
@Configuration
@ComponentScan
@EnableAspectJAutoProxy
public class MainConfig1 {
@Bean
public Person person(){
return new Person();
}
}
4、测试类Main1Test.java
public class Main1Test {
@Test
public void test(){
AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MainConfig1.class);
for (String name : app.getBeanDefinitionNames()){
System.out.println(name);
}
app.getBean(Calculator.class).div(4,2);
}
}
上面简单的程序就可以模拟springaop啦,下面开始分析springaop工作的原理
在分析之前先说一下springaop的核心的一个类:
BeanName:org.springframework.aop.config.internalAutoProxyCreator
Class:AnnotationAwareAspectJAutoProxyCreator
二、源码分析
1、准备工作---准备向springIOC容器中注入AnnotationAwareAspectJAutoProxyCreator
(1)从EnableAspectJAutoProxy开关开始
(2)@Import注解的使用
(3)AspectJAutoProxyRegistrar#registerBeanDefinitions()
@Override
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
......
}
(4)AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary()
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}
(5)AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary()
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
@Nullable Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
(6)AopConfigUtils#registerOrEscalateApcAsRequired()
@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;
}
上面的所有工作都是为了准备向IOC容器中注入AnnotationAwareAspectJAutoProxyCreator
2、向IOC容器中注入各种bean,包括后置处理器(beanpostProcessor)和业务bean,配置bean等所有的bean,这里注意下,向IOC容器中注入bean的时候是先注入后置处理器,然后再注入普通bean,其中后置处理器也是有注入的先后顺序。后置处理器的作用就是用于拦截bean的构建,可以在bean初始化的时候做一些拦截的动作。
下面开始分析代码
(1)AnnotationConfigApplicationContext#AnnotationConfigApplicationContext()
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
(2)AbstractApplicationContext#refresh()
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
(3)AbstractApplicationContext#registerBeanPostProcessors()先注入后置处理器
注入后置处理器和注入普通的bean的主要的流程差不多,就是时机比注入普通的bean的时机早,因为后置处理器注入成功后,所有的bean都需要经过已经注入的后置处理器进行拦截,同时后置处理器也分先后顺序,实现PriorityOrdered优先注入,其次实现Ordered,最后什么都没有实现的,这是因为实现PriorityOrdered的后置处理器优先级比较高,这种后置处理器可能需要拦截实现Ordered的后置处理器、什么都没实现的后置处理器,以及普通的bean,简单来说就是实例化任何bean都需要被已经实例化出来的后置处理器进行前后拦截。
等下会拿出和AOP相关的两个后置处理器出来分别介绍,他们分别是AnnotationAwareAspectJAutoProxyCreator和EventListenerMethodProcessor前者实现了Orderd接口,后者什么都没实现,所以再实例化EventListenerMethodProcessor时会被AnnotationAwareAspectJAutoProxyCreator进行拦截
PostProcessorRegistrationDelefate#registerBeanPostProcessors()
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
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);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
(4)AbstractBeanFactory#getBean()
@Override
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
(5)AbstractBeanFactory#doGetBean()
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//......
//前面是一些校验、检查、标记、依赖注入等操作
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
//......
}
(6)AbstractAutowireCapableBeanFactory#createBean()
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
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);
}
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
这里有一个需要注意的地方:Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
这一行代码比较容易忽略,这里面就有后置处理器的拦截工作,但是当注入AnnotationAwareAspectJAutoProxyCreator时,基本上拦截的后置处理器不做任何事情,感兴趣的可以debug看一下,但是当AnnotationAwareAspectJAutoProxyCreator已经初始化好的话,注入在AnnotationAwareAspectJAutoProxyCreator后的bean会被AnnotationAwareAspectJAutoProxyCreator拦截(前置拦截),这里介绍一下EventListenerMethodProcessor,为什么要介绍它,因为该后置处理器会实例化所有的通知类Adviser。仔细看一下...
(7)AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation()
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
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;
}
重点看 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)前置处理,其实就是遍历所有已经实例化好的后置处理器进行拦截,除了AnnotationAwareAspectJAutoProxyCreator,其他的一般不做任何处理,debug可以详细查看
(8)AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation()
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
(9)AbstractAutoProxyCreator#postProcessBeforeInstantiation()
这里是看被AnnotationAwareAspectJAutoProxyCreator拦截处理的逻辑
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;
}
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;
}
这里比较重要:
①会先将后面的每个bean进行标记,this.advisedBeans.put(cacheKey, Boolean.FALSE);在后面后置处理的时候如果是false就直接返回,不进行代理。
②会实例化Advisor,逻辑在shouldSkip中,看一下
(10)AspectJAutowareAdvisorAutoProxyCreator#shouldSkip()
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);
}
(11)AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors()
@Override
protected List<Advisor> findCandidateAdvisors() {
// Add all the Spring advisors found according to superclass rules.
List<Advisor> advisors = super.findCandidateAdvisors();
// Build Advisors for all AspectJ aspects in the bean factory.
if (this.aspectJAdvisorsBuilder != null) {
advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
}
return advisors;
}
(12)BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors()
public List<Advisor> buildAspectJAdvisors() {
List<String> aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
synchronized (this) {
aspectNames = this.aspectBeanNames;
if (aspectNames == null) {
List<Advisor> advisors = new LinkedList<>();
aspectNames = new LinkedList<>();
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;
}
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);
}
else {
// Per target or per this.
if (this.beanFactory.isSingleton(beanName)) {
throw new IllegalArgumentException("Bean with name '" + beanName +
"' is a singleton, but aspect instantiation model is not singleton");
}
MetadataAwareAspectInstanceFactory factory =
new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
this.aspectFactoryCache.put(beanName, factory);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
}
this.aspectBeanNames = aspectNames;
return advisors;
}
}
}
if (aspectNames.isEmpty()) {
return Collections.emptyList();
}
List<Advisor> advisors = new LinkedList<>();
for (String aspectName : aspectNames) {
List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
if (cachedAdvisors != null) {
advisors.addAll(cachedAdvisors);
}
else {
MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
advisors.addAll(this.advisorFactory.getAdvisors(factory));
}
}
return advisors;
}
这里就是实例化Advisor的详细的逻辑了,看上去很多,但是逻辑也比较简单,意思就是拿到所有的bean的定义信息,然后遍历,判断类型是否是切面类(也就是我们使用了@Aspect注释的类),然后再拿到里面所有的方法进行解析(@Before、@After、@AfterReturning、@AfterThrowing、@Around),后面就不再继续了,这个时候Advisor已经全部放到集合中了。到这里Object bean = resolveBeforeInstantiation(beanName, mbdToUse);就解析完了,我们接着AbstractAutowireCapableBeanFactory#createBean后面的逻辑讲,看到Object beanInstance = doCreateBean(beanName, mbdToUse, args);
(13)AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//.......
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
//......
return exposedObject;
}
重点看初始化bean,初始化就是给bean进行初始化,同样在初始化前后进行拦截增强
(14)AbstractAutowireCapableBeanFactory#initializeBean()
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
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;
}
invokerInitMethods()这是初始化的方法给bean属性赋值
applyBeanPostProcessorsBeforeInitialization()初始化之前进行拦截增强
applyBeanPostProcessorsAfterInitialization()初始化之后进行拦截
为了节省篇幅,这里就直接介绍相应的业务类的初始化拦截了(Calulator),其实所有的bean的初始化的逻辑流程都是一样的,只是部分细节不一样比如上面分析EventListenerMethodProcessor的时候做了初始化Advisor的工作,后面的操作和普通的bean没什么区别,现在主要介绍差异的部分,当初始化Calculator的时候,这个时候会调用
AnnotationAwareAspectJAutoProxyCreator后置处理器进行增强,生成一个Calculator的动态代理类,这是AOP的核心,一起看看如何生成的
(15)AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization()
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
这里也会被所有的已经实例化的后置处理器进行拦截,我们重点看AnnotationAwareAspectJAutoProxyCreator,这个时候被拦截的类是Calculator
(16)AbstractAutoProxyCreator#postProcessAfterInitialization()
@Override
public Object postProcessAfterInitialization(@Nullable 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;
}
wrapIfNecessary()所有被AnnotationAwareAspectJAutoProxyCreator拦截的类都会调用该方法,如果需要对bean进行增强的话,会在这里增强,如果不需要增强的话,会直接返回,看详细逻辑
(17)AbstractAutoProxyCreator#wrapIfNecessay()
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;
}
前面两个部分,在第一次前置处理器的时候已经标记过了,所以不符合需要代理的逻辑,直接return了,而calculator走后面的逻辑,create proxy if we hava advice,如果有advisor则进行代理增强,如果没有,则不进行代理增强,前面分析显然是由advisor,所以就会走createProxy的逻辑
(18)AbstractAutoProxyCreator#createProxy()
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable 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());
}
(19)ProxyFactory#getProxy()
public Object getProxy(@Nullable ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
(20)DefaultAopProxyFactory#createAopProxy()
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.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
到这里基本就结束了,会通过cglib或者jdk生成calculator的动态代理,这个时候calculator的div方法就进行了增强了
AOP介绍暂时分享到这里,如有错误欢迎指正,后面有时间再跟大家一起学习,调用calculator的div方法如何调用动态代理的方法,以及拦截连的调用和顺序等