spring源码阅读(四)-Spring AOP源码阅读

时序图

调试源码

因为springAOP 有很多种配置，我这里只阅读一种最常用的写法的源码

1.接口定义

public interface StudentService {
    public Integer  del(Long id);

    public boolean delAll();
}

2.实现类

public class StudentServiceImpl implements StudentService {

    @Override
    public Integer del(Long id) {
        System.out.println(String.format("执行删除id为:%s的数据",id));
        return 1;
    }

    @Override
    public boolean delAll() {
        System.out.println("删除所有数据");
        return true;
    }
}

3.拦截器

public class OperationInterceptor  implements MethodInterceptor {
    /**
     * 拦截的方法
     */
    List<String> refuseMethod= Arrays.asList("delAll");
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        if(refuseMethod.contains(invocation.getMethod().getName())){
            throw new Exception("无权访问");
        }
        return invocation.proceed();
    }
}

4.xml配置

    <bean name="studentServiceImpl"  class="org.springframework.lq.service.StudentServiceImpl"></bean>
    <!--配置Interceptor-->
    <bean name="operationInterceptor" class="org.springframework.lq.aspect.OperationInterceptor">
    </bean>
    <!--配置实现studentServiceImpl的代理-->
    <bean  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames" value="*ServiceImpl"></property>
        <!--配置拦截器 这里可以配置advice advisor interceptor-->
        <property name="interceptorNames">
            <list>
                <value>operationInterceptor</value>
            </list>
        </property>
    </bean>

前面说过Spring AOP 是运行时基于 JDK代理和CGLIB代理实现,是在IOC的基础上实现的，根据前面的IOC源码让我们猜猜在IOC中的代理时机。

根据IOC源码代理切入时机

时机1:ioc源码<23>处

如果实现了InstantiationAwareBeanPostProcessor的方法postProcessBeforeInstantiation 并返回对象将不走后续流程直接返回此对象，我们在这里可以创建代理对象。

但是有个问题，就是未走后面的初始化和Aware逻辑直接返回，所以我们的依赖注入和成员变量初始化就没有值显然不合理

  try {
            // 让 InstantiationAwareBeanPostProcessor 在这一步有机会替代对象。 此接口是BeanPostProcessor的子接口
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            //如果通过此扩展点创建了对象 则直接返回对象 不会执行下面createBean
            if (bean != null) {
                return bean;
            }
        }

时机2:ioc源码<27>处

注入的源码我还没有看,但是再@Autowrit我们是否可以搞点事情，注入之前在注入对象创建代理然后注入

但是有个问题,每次注入都会创建一个代理,在通过容器getBean的时候拿到的还是原有对象不可取

try {
            /**
             * 负责装配bean的属性 静态注入
             *<27> @Autowrit @Value动态注入 InstantiationAwareBeanPostProcessor
             *
             */
            populateBean(beanName, mbd, instanceWrapper);
            //<30>bean初始化完成后的各种回调
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }

时机3:ioc源码<30>处

调用实现了BeanPostProcessor 接口的postProcessBeforeInitialization方法有机会返回代理对象可以看到这里是合理的

if (mbd == null || !mbd.isSynthetic()) {
            //<32> BeanPostProcessor 的 postProcessBeforeInitialization 回调
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

时机4:ios源码的<34>处

调用实现了BeanPostProcessor 接口的postProcessAfterInitialization方法有机会返回代理对象这里是对象完全初始化和各种回调完毕的回调，可以看到这里比时机3更合理

if (mbd == null || !mbd.isSynthetic()) {
            //<34>BeanPostProcessor 的 postProcessAfterInitialization 回调
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

类图

可以发现我们xml配置的BeanNameAutoProxyCreator

通过类图可以看出BeanNameAutoProxyCreator实现了 SmartInstantiationAwareBeanPostProcessor 间接实现BeanPostProcessor和InstantiationAwareBeanPostProcessor

时机1源码

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean

因为BeanNameAutoProxyCreator实现了InstantiationAwareBeanPostProcessor 我们先看这里是否有返回

结论:如果没有实现默认的TargetSource 这里不会生成代理类

  try {
            // <1>让 InstantiationAwareBeanPostProcessor 在这一步有机会替代对象。 此接口是BeanPostProcessor的子接口
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            //如果通过此扩展点创建了对象 则直接返回对象 不会执行下面createBean
            if (bean != null) {
                return bean;
            }
        }

<1>

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation

    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) {
                    //<2>
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    //如果自定义方法postProcessBeforeInstantiation创建了对象
                    if (bean != null) {
                        //调用当前BeanPostProcessor postProcessAfterInitialization方法
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }

<2>

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            //判断是否是InstantiationAwareBeanPostProcessor 类型 如果是则调用判断是否是InstantiationAwareBeanPostProcessor 的postProcessBeforeInstantiation
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                 //<3>
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

<3>

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInstantiation

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(beanClass, beanName);

        /**
         * 根据缓存判断是否有生成过TargetSource
         * 如果生成过则直接返回null
         */
        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;
            }
        }
        /**
         * 是否有自定义生成TargetSource 默认没有实现 所以未生成代理 这里返回的是null
         */
        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
        /**
         * 如果有生成根据TargetSource 生成代理
         */
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            // 返回匹配当前 bean 的所有的 advisor、advice、interceptor
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            //<4>创建代理对象
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        return null;
    }

<4>

org.springframework.aop.framework.autoproxy.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 proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        /**
         * //根据配置判断用哪种代理
         *    // proxy-target-class="true",这样不管有没有接口，都使用 CGLIB 来生成代理：
         *    //   <aop:config proxy-target-class="true">......</aop:config>
         */
        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        ///这个方法会返回匹配了当前 bean 的 advisors 数组
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        // 扩展点，支持子类对ProxyFactory扩展
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        //<5>创建代理对象
        return proxyFactory.getProxy(getProxyClassLoader());
    }

<5>

org.springframework.aop.framework.ProxyFactory#getProxy(java.lang.ClassLoader)

    public Object getProxy(@Nullable ClassLoader classLoader) {
        //<6>工厂模式 根据配置获取jdk或者是cglib工厂AopProxy 再调用对应处理累的getProxy生成代理对象
        return createAopProxy().getProxy(classLoader);
    }

<6>

org.springframework.aop.framework.ProxyCreatorSupport#createAopProxy

    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        //先获取Factory 默认为 默认为DefaultAopProxyFactory <7>跟配置获取对应的ProxyFactory
        return getAopProxyFactory().createAopProxy(this);
    }

<7>

org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {

        //根据配置判断是使用jdk 还是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);
        }
    }

时机3源码

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean

 if (mbd == null || !mbd.isSynthetic()) {
            //<8> BeanPostProcessor 的 postProcessBeforeInitialization 回调
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

<8>

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

@Override
    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            //<9>
            Object current = processor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

<9>

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInitialization

也没有代理直接原对象返回

@Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

时机4源码

if (mbd == null || !mbd.isSynthetic()) {
            //<10> BeanPostProcessor 的 postProcessAfterInitialization 回调
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

<10>

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

    @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        //获得实现了BeanPostProcessor的累的对象遍历调用postProcessAfterInitialization
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
               //<11> 时机由 InfrastructureAdvisorAutoProxCreator
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

<11>

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization

    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            //如果通过getEarlyObject方法创建了代理则返回
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                //<12>创建代理对象
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

<12>

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //如果通过targetSource创建了bean
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        ////无需增强 下面 advisedBeans 可能此时还没有含有 cacheKey, 所以 get 出 null
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //bean是为aop的基础设施类比如pointcut、advice、advisor类 || 增强类不需要创建代理
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // 查找bean的增强方法 advice advisor interceptor
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //<4>创建代理
            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;
    }

最终结论

spring aop是在时机四扩展

org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator

事务管理器由

org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor

posted @ 2020-11-17 16:40 意犹未尽阅读(130) 评论(0) 编辑收藏举报

刷新页面返回顶部

意犹未尽

只要在学习，则在进步。