Spring AOP 大概原理

最新推荐文章于 2024-10-04 11:27:42 发布

_半桶水

最新推荐文章于 2024-10-04 11:27:42 发布

阅读量114

点赞数

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/weixin_45794310/article/details/127836767

版权

spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Spring AOP

Spring AOP到底是怎么实现的，是在哪里进行代理的呢，这篇文章就来初步了解一下吧

以注解的方式为例

先来以代码实现AOP代理

被代理的类

interface TargetInterface {
	void selectall();
}
// 这里使用了实现接口的方式，所以会走 jdk动态代理
public class Target implements TargetInterface {
   public void selectall(){
      System.out.println("方法被执行了");
   }
}

代理切面AOP

@Aspect
public class Aspect {
	/**
	 * 使用切入点表达式
	 */
	@Pointcut("execution(* selectall(..))")
	public void select(){}
     /**
     * 前置增强
	 */
	@Before("execution(* selectall(..))")
	public void beforeEnhance(JoinPoint joinpoint) {
		System.out.println("前置增强执行-------");
	}
    /**
     * 后置增强
	 */
    @AfterReturning("select()")
	public void afterReturnEnhance(JoinPoint joinPoint){
		System.out.println("后置增强执行------");
	}
}

启动类

@ComponentScan("com.aop")
@EnableAspectJAutoProxy
@Import({AopAspect.class})
public class AopApplication {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AopApplication.class);
        TargetInterface target = context.getBean("target", TargetInterface.class);
        target.selectall();
    }
    @Bean
    public TargetInterface target(){
        return new Target();
    }
}

代码解读

从上面代码中看到，我们使用了@EnableAspectJAutoProxy开启AOP,看看这个注解的作用@Import({AspectJAutoProxyRegistrar.class})

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    AspectJAutoProxyRegistrar() {
    }
    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);
            }
        }
    }
}

可以看出实现了ImportBeanDefinitionRegister，这个接口的作用就是可以手动的向BeanDefinitionRegistry注册一个bean定义信息

registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
///=======================
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls); // cls = AnnotationAwareAspectJAutoProxyCreator.class
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", -2147483648);
beanDefinition.setRole(2);
registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
return beanDefinition;

定义了一个名字org.springframework.aop.config.internalAutoProxyCreator的AnnotationAwareAspectJAutoProxyCreator.classbean

AnnotationAwareAspectJAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator 父类关系图

主要看看注册的这个bean是不是实现了BeanPostProcesor，所以会怎么样，当执行初始化方法的前后是不是会执行扩展处理，即postProcessBeforeInitialization()前置处理和postProcessAfterInitialization后置处理

我们在这个类中找是找不到这两个方法的，我们往父类上找，直到AbstractAutoProxyCreator才找到了postProcessAfterInitialization

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return this.wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
            Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
            if (specificInterceptors != DO_NOT_PROXY) {
                this.advisedBeans.put(cacheKey, Boolean.TRUE);
                Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            } else {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return bean;
            }
        } else {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    }
}

在wrapIfNecessary()进行代理如果需要的话。重点的看这行Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

这句话的语义也能看得出来，他就是去创建代理的，返回的也是一个代理类

最后调用到了 ProxyFactory 的getProxy()方法中去获取代理类

public class ProxyFactory extends ProxyCreatorSupport {
    public Object getProxy(@Nullable ClassLoader classLoader) {
        return this.createAopProxy().getProxy(classLoader);
    }
}

在createAopProxy()中去获取Aop代理时就已经判断需要什么样的类型 AopProxy

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    public DefaultAopProxyFactory() {
    }

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (NativeDetector.inNativeImage() || !config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            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.");
            } else {
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
    }
}