//AbstractApplicationContext.refresh
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
       //调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识  
       prepareRefresh();
       //告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入从子类的refreshBeanFactory()方法启动
       ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
       //为BeanFactory配置容器特性，例如类加载器、事件处理器等
       prepareBeanFactory(beanFactory);
       try {
           //为容器的某些子类指定特殊的BeanPost事件处理器
           postProcessBeanFactory(beanFactory);
           //调用所有注册的BeanFactoryPostProcessor的Bean
           invokeBeanFactoryPostProcessors(beanFactory);
           //为BeanFactory注册BeanPost事件处理器。BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件  
           registerBeanPostProcessors(beanFactory);
           //初始化信息源，和国际化相关
           initMessageSource();
           //初始化容器事件传播器
           initApplicationEventMulticaster();
           //调用子类的某些特殊Bean初始化方法
           onRefresh();
           //为事件传播器注册事件监听器
           registerListeners();
           //初始化所有剩余的单例Bean
           finishBeanFactoryInitialization(beanFactory);
           //初始化容器的生命周期事件处理器，并发布容器的生命周期事件
           finishRefresh();
       }
       catch (BeansException ex) {
           //销毁以创建的单态Bean  
           destroyBeans();
           //取消refresh操作，重置容器的同步标识
           cancelRefresh(ex);
           throw ex;
       }
   }
}

//AbstractRefreshableApplicationContext.refreshBeanFactory
protected final void refreshBeanFactory() throws BeansException {
   if (hasBeanFactory()) {//如果已经有容器，销毁容器中的bean，关闭容器  
       destroyBeans();
       closeBeanFactory();
   }
   try {
        //创建IoC容器  
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
       //对IoC容器进行定制化，如设置启动参数，开启注解的自动装配等  
       customizeBeanFactory(beanFactory);
       //调用载入Bean定义的方法，主要这里又使用了一个委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器  
       loadBeanDefinitions(beanFactory);
       synchronized (this.beanFactoryMonitor) {
           this.beanFactory = beanFactory;
       }
   }
   catch (IOException ex) {
       throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

//BeanDefinitionReaderUtils.registerBeanDefinition：将解析的BeanDefinitionHolder注册到容器中 
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
    throws BeanDefinitionStoreException {
        //获取解析的BeanDefinition的名称
        String beanName = definitionHolder.getBeanName();
        //向IoC容器注册BeanDefinition 
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
        //如果解析的BeanDefinition有别名，向容器为其注册别名  
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String aliase : aliases) {
                registry.registerAlias(beanName, aliase);
            }
        }
}
//DefaultListableBeanFactory.registerBeanDefinition
public class DefaultListableBeanFactory 
    extends AbstractAutowireCapableBeanFactory 
    implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {
        //...
        this.beanDefinitionNames.add(beanName);
        //...
        this.beanDefinitionMap.put(beanName, beanDefinition);
        //...
    }
}

//BeanFactoryPostProcessor.postProcessBeanFactory：在 invokeBeanFactoryPostProcessors 方法中主要是获取实现 BeanFactoryPostProcessor 接口的子类的Bean实例。并调用它的 postProcessBeanFactory 方法
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}
//BeanPostProcessor.postProcessBeforeInitialization、BeanPostProcessor.postProcessAfterInitialization
//registerBeanPostProcessors 方法也是可以获取用户定义的实现了 BeanPostProcessor 接口的子类，并把它们注册到 BeanFactory 对象中的 beanPostProcessors 变量中。BeanPostProcessor 中声明了两个方法：postProcessBeforeInitialization、postProcessAfterInitialization 分别用于在 Bean 对象初始化时执行，其中可以定义用户自己的操作。
public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;
    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
}

//AbstractApplicationContext.finishBeanFactoryInitialization
//对单态模式Bean进行预实例化处理  
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   //这是Spring3以后新加的代码，为容器指定一个转换服务(ConversionService)在对某些Bean属性进行转换时使用  
   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
       beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
   }
   //为了类型匹配，停止使用临时的类加载器  
   beanFactory.setTempClassLoader(null);
   //缓存容器中所有注册的BeanDefinition元数据，以防被修改  
   beanFactory.freezeConfiguration();
   //对单态模式Bean进行预实例化处理  
   beanFactory.preInstantiateSingletons();
}
//DefaultListableBeanFactory.preInstantiateSingletons
//对单态模式Bean进行预实例化处理
public void preInstantiateSingletons() throws BeansException {
   //...
   //在对单态模式Bean进行预实例化处理过程中，必须多线程同步，以确保数据一致性  
   synchronized (this.beanDefinitionMap) {
       for (String beanName : this.beanDefinitionNames) {
           //获取指定名称的Bean定义  
           RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
           //Bean不是抽象的，是单态模式的，且lazy-init属性配置为false  
           if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
               //如果指定名称的bean是创建容器的Bean  
               if (isFactoryBean(beanName)) {
                   //...
               } else {
                   //调用getBean方法，触发容器对Bean实例化和依赖注入过程  
                   getBean(beanName);
               }
           }
       }
   }
}

//初始容器创建的Bean实例对象，为其执行BeanPostProcessor后置处理器  
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
   //...
   Object wrappedBean = bean;
   //对BeanPostProcessor后置处理器的postProcessBeforeInitialization  
   //回调方法的调用，为Bean实例初始化前做一些处理  
   if (mbd == null || !mbd.isSynthetic()) {
       wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
   //调用Bean实例对象初始化的方法，这个初始化方法是在Spring Bean定义配置文件中通过init-method属性指定的  
   try {
       invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
       throw new BeanCreationException(
               (mbd != null ? mbd.getResourceDescription() : null),
               beanName, "Invocation of init method failed", ex);
   }
   //对BeanPostProcessor后置处理器的postProcessAfterInitialization回调方法的调用，为Bean实例初始化之后做一些处理  
   if (mbd == null || !mbd.isSynthetic()) {
       wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }
   return wrappedBean;
}
//调用BeanPostProcessor后置处理器实例对象初始化之前的处理方法  
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
       throws BeansException {
   Object result = existingBean;
   //遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器  
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
       //调用Bean实例所有的后置处理中的初始化前处理方法，为Bean实例对象在初始化之前做一些自定义的处理操作  
       result = beanProcessor.postProcessBeforeInitialization(result, beanName);
       if (result == null) {
           return result;
       }
   }
   return result;
}
//调用BeanPostProcessor后置处理器实例对象初始化之后的处理方法  
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
       throws BeansException {
   Object result = existingBean;
   //遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器  
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
       //调用Bean实例所有的后置处理中的初始化后处理方法，为Bean实例对象在初始化之后做一些自定义的处理操作  
       result = beanProcessor.postProcessAfterInitialization(result, beanName);
       if (result == null) {
           return result;
       }
   }
   return result;
}

@Aspect
@Component
public class AopInterceptor {

    @Pointcut("execution(public * com.ck.aopTest.dao.impl.*.get*(..))")
    private void aopTest() {

    }
    @Before("aopTest()")
    public void before() {
        System.out.println("调用dao方法前拦截" + new Date().getTime());
    }
    @After("aopTest()" + "&&args(user)")
    public void after(UserModel user) {
        System.out.println(user.getName());
        System.out.println("调用dao方法之后拦截" + new Date().getTime());
    }
    @Around("aopTest()")
    public void around(ProceedingJoinPoint pdj) {
        System.out.println("调用dao之前的环绕拦截" + new Date().getTime());
        try {
            pdj.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("调用dao之后的环绕拦截" + new Date().getTime());
    }
}

//ReflectiveMethodInvocation.proceed
//逐一执行拦截器链方法，执行完拦截器链后，最后执行连接点方法并返回值
protected final List<?> interceptorsAndDynamicMethodMatchers;
public Object proceed() throws Throwable {
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return this.invokeJoinpoint();
    } else {
        Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
            return dm.methodMatcher.matches(this.method, this.targetClass, this.arguments) ? dm.interceptor.invoke(this) : this.proceed();
        } else {
            return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);
        }
    }
}

//TransactionInterceptor.invoke
//事务处理的AOP Interceptor
public Object invoke(final MethodInvocation invocation) throws Throwable {
    Class<?> targetClass = invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null;
    return this.invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
        public Object proceedWithInvocation() throws Throwable {
            return invocation.proceed();
        }
    });
}
//TransactionAspectSupport.invokeWithinTransaction
//事务处理的核心代码
public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
    //事务状态对象ThreadLocal容器
    private static final ThreadLocal<TransactionAspectSupport.TransactionInfo> transactionInfoHolder = new NamedThreadLocal("Current aspect-driven transaction");
    protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final TransactionAspectSupport.InvocationCallback invocation) throws Throwable {
        final TransactionAttribute txAttr = this.getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
        final PlatformTransactionManager tm = this.determineTransactionManager(txAttr);
        final String joinpointIdentification = this.methodIdentification(method, targetClass);
        if (txAttr != null && tm instanceof CallbackPreferringPlatformTransactionManager) {
            //...
        } else {
            //创建并开始事务
            TransactionAspectSupport.TransactionInfo txInfo = this.createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
    
            try {
                retVal = invocation.proceedWithInvocation();
            } catch (Throwable var15) {
                this.completeTransactionAfterThrowing(txInfo, var15);
                throw var15;
            } finally {
                this.cleanupTransactionInfo(txInfo);
            }
            //提交事务
            this.commitTransactionAfterReturning(txInfo);
            return retVal;
        }
    }
}
//TransactionAspectSupport.createTransactionIfNecessary
//首先根据配置的事务传播特性取得(创建或获取)一个事务
protected TransactionAspectSupport.TransactionInfo createTransactionIfNecessary(PlatformTransactionManager tm, TransactionAttribute txAttr, final String joinpointIdentification) {
    if (txAttr != null && ((TransactionAttribute)txAttr).getName() == null) {
        txAttr = new DelegatingTransactionAttribute((TransactionAttribute)txAttr) {
            public String getName() {
                return joinpointIdentification;
            }
        };
    }

    TransactionStatus status = null;
    if (txAttr != null) {
        if (tm != null) {
            status = tm.getTransaction((TransactionDefinition)txAttr);
        } else if (this.logger.isDebugEnabled()) {
            this.logger.debug("Skipping transactional joinpoint [" + joinpointIdentification + "] because no transaction manager has been configured");
        }
    }

    return this.prepareTransactionInfo(tm, (TransactionAttribute)txAttr, joinpointIdentification, status);
}
//AbstractPlatformTransactionManager.getTransaction
public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
    //获取事务对象
    Object transaction = this.doGetTransaction();
    boolean debugEnabled = this.logger.isDebugEnabled();
    if (definition == null) {
        definition = new DefaultTransactionDefinition();
    }

    if (this.isExistingTransaction(transaction)) {
        return this.handleExistingTransaction((TransactionDefinition)definition, transaction, debugEnabled);
    } else if (((TransactionDefinition)definition).getTimeout() < -1) {
        throw new InvalidTimeoutException("Invalid transaction timeout", ((TransactionDefinition)definition).getTimeout());
    } else if (((TransactionDefinition)definition).getPropagationBehavior() == 2) {
        throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");
    } else if (((TransactionDefinition)definition).getPropagationBehavior() != 0 && ((TransactionDefinition)definition).getPropagationBehavior() != 3 && ((TransactionDefinition)definition).getPropagationBehavior() != 6) {
        if (((TransactionDefinition)definition).getIsolationLevel() != -1 && this.logger.isWarnEnabled()) {
            this.logger.warn("Custom isolation level specified but no actual transaction initiated; isolation level will effectively be ignored: " + definition);
        }

        boolean newSynchronization = this.getTransactionSynchronization() == 0;
        return this.prepareTransactionStatus((TransactionDefinition)definition, (Object)null, true, newSynchronization, debugEnabled, (Object)null);
    } else {
        AbstractPlatformTransactionManager.SuspendedResourcesHolder suspendedResources = this.suspend((Object)null);
        if (debugEnabled) {
            this.logger.debug("Creating new transaction with name [" + ((TransactionDefinition)definition).getName() + "]: " + definition);
        }

        try {
            boolean newSynchronization = this.getTransactionSynchronization() != 2;
            DefaultTransactionStatus status = this.newTransactionStatus((TransactionDefinition)definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
            //开始事务
            this.doBegin(transaction, (TransactionDefinition)definition);
            this.prepareSynchronization(status, (TransactionDefinition)definition);
            return status;
        } catch (RuntimeException var7) {
            this.resume((Object)null, suspendedResources);
            throw var7;
        } catch (Error var8) {
            this.resume((Object)null, suspendedResources);
            throw var8;
        }
    }
}
//DataSourceTransactionManager.doGetTransaction
//获取事务状态对象
protected Object doGetTransaction() {
    DataSourceTransactionManager.DataSourceTransactionObject txObject = new DataSourceTransactionManager.DataSourceTransactionObject();
    txObject.setSavepointAllowed(this.isNestedTransactionAllowed());
    ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.dataSource);
    txObject.setConnectionHolder(conHolder, false);
    return txObject;
}
//DataSourceTransactionManager.doBegin
//开始事务
protected void doBegin(Object transaction, TransactionDefinition definition) {
    DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)transaction;
    Connection con = null;

    try {
        if (txObject.getConnectionHolder() == null || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
            Connection newCon = this.dataSource.getConnection();
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
            }

            txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
        }

        txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
        con = txObject.getConnectionHolder().getConnection();
        Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
        txObject.setPreviousIsolationLevel(previousIsolationLevel);
        if (con.getAutoCommit()) {
            txObject.setMustRestoreAutoCommit(true);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
            }

            con.setAutoCommit(false);
        }

        txObject.getConnectionHolder().setTransactionActive(true);
        int timeout = this.determineTimeout(definition);
        if (timeout != -1) {
            txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
        }

        if (txObject.isNewConnectionHolder()) {
            TransactionSynchronizationManager.bindResource(this.getDataSource(), txObject.getConnectionHolder());
        }

    } catch (Throwable var7) {
        if (txObject.isNewConnectionHolder()) {
            DataSourceUtils.releaseConnection(con, this.dataSource);
            txObject.setConnectionHolder((ConnectionHolder)null, false);
        }

        throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", var7);
    }
}
//TransactionAspectSupport.commitTransactionAfterReturning
//提交事务
protected void commitTransactionAfterReturning(TransactionAspectSupport.TransactionInfo txInfo) {
    if (txInfo != null && txInfo.hasTransaction()) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
        }

        txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
    }
}
//DataSourceTransactionManager.doCommit
protected void doCommit(DefaultTransactionStatus status) {
    DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)status.getTransaction();
    Connection con = txObject.getConnectionHolder().getConnection();
    if (status.isDebug()) {
        this.logger.debug("Committing JDBC transaction on Connection [" + con + "]");
    }

    try {
        con.commit();
    } catch (SQLException var5) {
        throw new TransactionSystemException("Could not commit JDBC transaction", var5);
    }
}