spring 注解事务

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) {
        try {
            Document doc = doLoadDocument(inputSource, resource);
            return registerBeanDefinitions(doc, resource);
        }

doc  =  <beans >跟标签，
attributes = [default-autowire="default", default-lazy-init="true", default-merge="default", xmlns="http://www.springframework.org/schema/beans", xmlns:aop="http://www.springframework.org/schema/aop", xmlns:cache="http://www.springframework.org/s...... ....... ......ta/jpahema/cache/spring-cache.xsd"]
children =  [ [context:property-placeholder: null], [context:component-scan: null],  [bean: dataSource],  [bean: transactionManager], [aop:aspectj-autoproxy: null],  [bean: jdbcTemplate], [tx:annotation-driven: null],]

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root)) {
            NodeList nl = root.getChildNodes();   //解析<beans>根节点，
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (node instanceof Element) {
                    Element ele = (Element) node;
                    if (delegate.isDefaultNamespace(ele)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }

解析[context:property-placeholder: null]标签，

delegate.parseCustomElement(ele);   //ele  =  context:property-placeholder标签
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        String namespaceUri = getNamespaceURI(ele);  //http://www.springframework.org/schema/context，
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);   //ContextNamespaceHandler里面找到解析类PropertyPlaceholderBeanDefinitionParser，
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));   //名字是org.springframework.context.support.PropertySourcesPlaceholderConfigurer#0，内容是PropertySourcesPlaceholderConfigurer加入到spring的容器，解析的是core.properties里面的数据库的连接用户名密码地址信息。
locations = [classpath*:config/core/core.properties]，
ignoreResourceNotFound = false,
localOverride = fasle
ignoreUnresolvablePlaceholders = false.
    }

解析[context:component-scan: null]标签：（把扫描的bean的定义加到spring的容器）

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        String namespaceUri = getNamespaceURI(ele);//http://www.springframework.org/schema/context，
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);//ContextNamespaceHandler里面找到解析类ComponentScanBeanDefinitionParser，
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    }

public BeanDefinition parse(Element element, ParserContext parserContext) {
        String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE),
                ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);//[com.zhuguang.jack]
        ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
        Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);//ClassPathBeanDefinitionScanner，返回AnnotationServiceImpl的bean定义（并且已经加到容器中去了），
        registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
        return null;
    }

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
        XmlReaderContext readerContext = parserContext.getReaderContext();//XmlReaderContext
        boolean useDefaultFilters = true;
        if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
            useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));//true
        }
        ClassPathBeanDefinitionScanner scanner = createScanner(readerContext, useDefaultFilters);
        scanner.setResourceLoader(readerContext.getResourceLoader());//ClassPathXmlApplicationContext
        scanner.setEnvironment(parserContext.getDelegate().getEnvironment());
        scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
        scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
        if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
            scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
        }
        try {
            parseBeanNameGenerator(element, scanner);
        }
        try {
            parseScope(element, scanner);//解析context:component-scan标签的scope属性，
        }
        parseTypeFilters(element, scanner, readerContext, parserContext);//解析context:component-scan标签的TypeFilters属性，
        return scanner;
    }

protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
        return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters);   //里面有bean工厂，
    }

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
        for (String basePackage : basePackages) {
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            for (BeanDefinition candidate : candidates) {//AnnotationServiceImpl
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                if (checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    registerBeanDefinition(definitionHolder, this.registry);  //bean的定义注册到容器，
                }
            }
        }
        return beanDefinitions;
    }

public Set<BeanDefinition> findCandidateComponents(String basePackage) { 
        try {
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    resolveBasePackage(basePackage) + "/" + this.resourcePattern;  //classpath*:com/zhuguang/jack/**/*.class，
            Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);  //AnnotationServiceImpl.class，MyService.class，Test2.class
            for (Resource resource : resources) {
                if (resource.isReadable()) {
                    MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource); 
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                        if (isCandidateComponent(sbd)) {
                            candidates.add(sbd);
                        }
                    }
        }
        return candidates;//AnnotationServiceImpl
    }

解析<bean id="dataSource">标签：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  //Bean definition with name 'dataSource' and aliases []: Generic bean: class [com.mchange.v2.c3p0.ComboPooledDataSource];
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());   //注册到spring容器，
            }
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        String id = ele.getAttribute(ID_ATTRIBUTE);  //dataSource
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); //返回GenericBeanDefinition，里面的class =  [com.mchange.v2.c3p0.ComboPooledDataSource]
        if (beanDefinition != null) {
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);   //beanDefinition  =   Generic bean: class [com.mchange.v2.c3p0.ComboPooledDataSource]，beanName  =  dataSource  ，  aliasesArray  =  []，
        }
    }

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
        String className = null;
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {  //class属性，
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();//com.mchange.v2.c3p0.ComboPooledDataSource
        }
        try {
            String parent = null;
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);  //返回GenericBeanDefinition，里面的class =  [com.mchange.v2.c3p0.ComboPooledDataSource]
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            return bd;
        }
    }

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, BeanDefinition containingBean, AbstractBeanDefinition bd) {
        String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
        if (DEFAULT_VALUE.equals(lazyInit)) {
            lazyInit = this.defaults.getLazyInit();
        }
        bd.setLazyInit(TRUE_VALUE.equals(lazyInit));  //true，
        return bd;
    }

解析<bean id="transactionManager">标签：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);   //beanDefinition  =  Generic bean: class [org.springframework.jdbc.datasource.DataSourceTransactionManager];  beanName = transactionManager，
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());   //注册到spring的容器，
            }
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        String id = ele.getAttribute(ID_ATTRIBUTE);   //transactionManager
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);   //Generic bean: class [org.springframework.jdbc.datasource.DataSourceTransactionManager];
        if (beanDefinition != null) {             
            }
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);   //beanDefinition  =  Generic bean: class [org.springframework.jdbc.datasource.DataSourceTransactionManager];  beanName = transactionManager，
        }
        return null;
    }

解析<aop:aspectj-autoproxy/>标签：

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        String namespaceUri = getNamespaceURI(ele);//http://www.springframework.org/schema/aop，
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);  //handler  =  AopNamespaceHandler，
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));  //AspectJAutoProxyBeanDefinitionParser
    }

public BeanDefinition parse(Element element, ParserContext parserContext) {
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);//注册AnnotationAwareAspectJAutoProxyCreator，名字叫做org.springframework.aop.config.internalAutoProxyCreator，内容是class [org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator];到spring容器。最后包装成BeanComponentDefinition，名字还是叫org.springframework.aop.config.internalAutoProxyCreator，BeanComponentDefinition里面有AnnotationAwareAspectJAutoProxyCreator。
        extendBeanDefinition(element, parserContext);
        return null;
    }

解析JdbcTemplate标签：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);   //'jdbcTemplate' and aliases []: Generic bean: class [org.springframework.jdbc.core.JdbcTemplate];
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());   //注册到spring容器，
            }
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }


public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        String id = ele.getAttribute(ID_ATTRIBUTE);   //jdbcTemplate
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);   //Generic bean: class [org.springframework.jdbc.core.JdbcTemplate];
        if (beanDefinition != null) {
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }
    }

解析[tx:annotation-driven: null]标签：

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        String namespaceUri = getNamespaceURI(ele);
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);  //TxNamespaceHandler
        return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));  //AnnotationDrivenBeanDefinitionParser
    }

public BeanDefinition parse(Element element, ParserContext parserContext) {
        String mode = element.getAttribute("mode");
        if ("aspectj".equals(mode)) {
        }
        else {
            AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
        }
        return null;
    }

public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
            AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);//增加注解事务的入口类InfrastructureAdvisorAutoProxyCreator到spring容器，

            String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;   //internalTransactionAdvisor，
            if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
                Object eleSource = parserContext.extractSource(element);  //null 
 
                RootBeanDefinition sourceDef = new RootBeanDefinition("org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");   //事务属性的bean定义，里面有SpringTransactionAnnotationParser，去注解里面拿到属性值。
                sourceDef.setSource(eleSource);
                sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
 
                RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
                interceptorDef.setSource(eleSource);
                interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                registerTransactionManager(element, interceptorDef);
                interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
                String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
 
                RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);   //里面new TransactionAttributeSourcePointcut
                advisorDef.setSource(eleSource);
                advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
                advisorDef.getPropertyValues().add("adviceBeanName", interceptorName); //TransactionInterceptor
                if (element.hasAttribute("order")) {
                    advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
                }
                parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);  //internalTransactionAdvisor，BeanFactoryTransactionAttributeSourceAdvisor

                CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
                compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));  //AnnotationTransactionAttributeSource，AnnotationTransactionAttributeSource#0
                compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));  //TransactionInterceptor，TransactionInterceptor#0
                compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));//BeanFactoryTransactionAttributeSourceAdvisor，internalTransactionAdvisor
                parserContext.registerComponent(compositeDef);
            }
        }

public static void registerAutoProxyCreatorIfNecessary( ParserContext parserContext, Element sourceElement) {
        BeanDefinition beanDefinition = AopConfigUtils.registerAutoProxyCreatorIfNecessary(parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        registerComponentIfNecessary(beanDefinition, parserContext);
    }

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) { 
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {  //internalAutoProxyCreator
            BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);  //AnnotationAwareAspectJAutoProxyCreator
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {//cls = InfrastructureAdvisorAutoProxyCreator，
                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;
    }

此时bean工厂里面有
[internalAutoProxyCreator, 
PropertySourcesPlaceholderConfigurer#0, 
annotationServiceImpl, 
internalConfigurationAnnotationProcessor, 
internalAutowiredAnnotationProcessor, 
internalRequiredAnnotationProcessor, 
internalCommonAnnotationProcessor, 
dataSource, 
transactionManager, 
jdbcTemplate, 
AnnotationTransactionAttributeSource#0, 
TransactionInterceptor#0,
 internalTransactionAdvisor，
ConfigurationClassPostProcessor.importAwareProcessor，
ConfigurationClassPostProcessor.enhancedConfigurationProcessor]

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        if (beanFactory instanceof BeanDefinitionRegistry) {
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);  //internalConfigurationAnnotationProcessor

            for (String ppName : postProcessorNames) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));//ConfigurationClassPostProcessor 
                }
            } 
            invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);//注册ImportAwareBeanPostProcessor，EnhancedConfigurationBeanPostProcessor到spring容器，

            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);  //internalConfigurationAnnotationProcessor   

            boolean reiterate = true;
            while (reiterate) {
                reiterate = false;
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);   //internalConfigurationAnnotationProcessor 
            }

            invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        }

        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);//PropertySourcesPlaceholderConfigurer  
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);  //PropertySourcesPlaceholderConfigurer，解析jdbc的用户名密码地址。  
    }

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);   //[internalAutoProxyCreator, internalAutowiredAnnotationProcessor, internalRequiredAnnotationProcessor, internalCommonAnnotationProcessor, ConfigurationClassPostProcessor.importAwareProcessor, ConfigurationClassPostProcessor.enhancedConfigurationProcessor]

        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);  //[ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@acdb094, ConfigurationClassPostProcessor$EnhancedConfigurationBeanPostProcessor@674bd420, CommonAnnotationBeanPostProcessor@2b0f373b, AutowiredAnnotationBeanPostProcessor@2ceb80a1, RequiredAnnotationBeanPostProcessor@4b45dcb8]

        List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
        for (String ppName : orderedPostProcessorNames) {   
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);//internalAutoProxyCreator（AnnotationAwareAspectJAutoProxyCreator），initializeBean方法里面的invokeAwareMethods方法设置this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory)，
            orderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } 
 
        registerBeanPostProcessors(beanFactory, internalPostProcessors);//[CommonAnnotationBeanPostProcessor@2b0f373b, AutowiredAnnotationBeanPostProcessor@2ceb80a1, RequiredAnnotationBeanPostProcessor@4b45dcb8]

        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    }

 getBean(beanName);  //internalAutoProxyCreator

getBean(AnnotationTransactionAttributeSource);解析AnnotationTransactionAttributeSource，createBeanInstance方法才会去调用构造函数，注册SpringTransactionAnnotationParser，JtaTransactionAnnotationParser，Ejb3TransactionAnnotationParser。findAdvisorBeans()方法会设置AnnotationAwareAspectJAutoProxyCreator的advisorRetrievalHelper 的cachedAdvisorBeanNames属性 =  internalTransactionAdvisor。（getbean(“”)的时候，会执行所有的BeanPostProcessors的postProcessAfterInitialization方法，然后会给这些所有的BeanPostProcessors设置一些属性值。同时也会给正在实例化的bean设置一些属性值。）然后getbean("internalTransactionAdvisor")，

getBean(TransactionInterceptor);解析TransactionInterceptor，

MyService as = (MyService) context.getBean("annotationServiceImpl");

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {、
    Object bean = resolveBeforeInstantiation(beanName, mbd);

    Object beanInstance = doCreateBean(beanName, mbd, args);
    return beanInstance;
}

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
            }
        }
        return bean;
    }


protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
        }
        return null;
    }

AnnotationAwareAspectJAutoProxyCreator类：
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(beanClass, beanName);  //AnnotationServiceImpl_annotationServiceImpl，beanClass = class com.zhuguang.jack.service.AnnotationServiceImpl，
        if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {  //是否有Aspect注解，
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }
        if (beanName != null) {
            TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
            if (targetSource != null) {    //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;
    }

protected boolean shouldSkip(Class<?> beanClass, String beanName) {
        List<Advisor> candidateAdvisors = findCandidateAdvisors();   //[org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0']
    }

protected List<Advisor> findCandidateAdvisors() {
        List<Advisor> advisors = super.findCandidateAdvisors();
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        return advisors;
    }

public List<Advisor> findAdvisorBeans() {
        String[] advisorNames = null;
        synchronized (this) {
            advisorNames = this.cachedAdvisorBeanNames;//internalTransactionAdvisor，cachedAdvisorBeanNames是AnnotationAwareAspectJAutoProxyCreator的属性，在解析AnnotationTransactionAttributeSource时候设置的缓存。
        }

        List<Advisor> advisors = new LinkedList<Advisor>();
        for (String name : advisorNames) {
            if (isEligibleBean(name)) {
                else {
                    try {
                        advisors.add(this.beanFactory.getBean(name, Advisor.class));  //org.springframework.transaction.config.internalTransactionAdvisor，返回[org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0']
                    }
                }
            }
        }
        return advisors;
    }

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)  {
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessAfterInitialization(result, beanName);
        }
        return result;
    }

AnnotationAwareAspectJAutoProxyCreator类：
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);   // //BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0' = TransactionInterceptor@7a138fc5，
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));   //ProxyFactory: 1 interfaces [MyService]; 1 advisors [BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'TransactionInterceptor#0']; targetSource [[AnnotationServiceImpl@7c098bb3]]; 
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }
    }

protected boolean shouldSkip(Class<?> beanClass, String beanName) { 
        List<Advisor> candidateAdvisors = findCandidateAdvisors();   //BeanFactoryTransactionAttributeSourceAdvisor
        return super.shouldSkip(beanClass, beanName);  //false
    }

protected List<Advisor> findCandidateAdvisors() {
        List<Advisor> advisors = super.findCandidateAdvisors();
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        return advisors;
    }

protected List<Advisor> findCandidateAdvisors() {
        return this.advisorRetrievalHelper.findAdvisorBeans();
    }

public List<Advisor> findAdvisorBeans() {  
        synchronized (this) {
            advisorNames = this.cachedAdvisorBeanNames;  //internalTransactionAdvisor
        }
        for (String name : advisorNames) {
            advisors.add(this.beanFactory.getBean(name, Advisor.class));  //BeanFactoryTransactionAttributeSourceAdvisor
        }
        return advisors;
    }

protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
        List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
        return advisors.toArray();
    }

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        return eligibleAdvisors;  //BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0' = TransactionInterceptor@7a138fc5，
    }

protected Object createProxy(Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
        ProxyFactory proxyFactory = new ProxyFactory(); 
        proxyFactory.copyFrom(this);

        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);   //BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0'
        for (Advisor advisor : advisors) {
            proxyFactory.addAdvisor(advisor);
        }

        return proxyFactory.getProxy(this.proxyClassLoader);
    }

protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) { 
        Advisor[] commonInterceptors = resolveInterceptorNames();//[]

        List<Object> allInterceptors = new ArrayList<Object>();
        if (specificInterceptors != null) {
            allInterceptors.addAll(Arrays.asList(specificInterceptors));//BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0'
            if (commonInterceptors != null) {
                if (this.applyCommonInterceptorsFirst) {
                    allInterceptors.addAll(0, Arrays.asList(commonInterceptors));//BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0'
                }
            }
        } 

        Advisor[] advisors = new Advisor[allInterceptors.size()];  
        for (int i = 0; i < allInterceptors.size(); i++) {
            advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
        }
        return advisors;//BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0'
    }

as.saveTest1(111,111);   //  jdk动态代理，ProxyFactory: 1 interfaces [MyService]; 1 advisors [BeanFactoryTransactionAttributeSourceAdvisor: advice bean 'TransactionInterceptor#0']; targetSource [[AnnotationServiceImpl@7c098bb3]]; 

JdkDynamicAopProxy类：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            if (target != null) {
                targetClass = target.getClass();  //AnnotationServiceImpl
            }
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);  //advised = ProxyFactory，targetClass = AnnotationServiceImpl，method = saveTest1(int,int)。返回TransactionInterceptor@560cbf1a。

            else {
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                retVal = invocation.proceed();
            }
    }

public Object proceed() throws Throwable {   //  链式调用，
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }
        Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex); 
        else { 
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

TransactionInterceptor类：
public Object invoke(final MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);   //AnnotationServiceImpl
        return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
            @Override
            public Object proceedWithInvocation() throws Throwable {
                return invocation.proceed();//执行方法，又进到 链式调用，
            }
        });
    }

protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)  {
        final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);    //getTransactionAttributeSource()  =  AnnotationTransactionAttributeSource， 获取AnnotationServiceImpl类saveTest1(int,int)方法上的事务注解属性。返回PROPAGATION_REQUIRES_NEW,ISOLATION_READ_COMMITTED; ''，传播属性和隔离级别。
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);  //DataSourceTransactionManager@23a9ba52实例，
        final String joinpointIdentification = methodIdentification(method, targetClass);//saveTest1方法名字，

        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);    //开启事务txInfo，返回PROPAGATION_REQUIRES_NEW,ISOLATION_READ_COMMITTED; ''，
            Object retVal = null;
            try {
                retVal = invocation.proceedWithInvocation();   //执行方法，
            }
            catch (Throwable ex) {
                completeTransactionAfterThrowing(txInfo, ex);//回滚事务txInfo，
                throw ex;
            }
            finally {
                cleanupTransactionInfo(txInfo);
            }
            commitTransactionAfterReturning(txInfo);//提交事务txInfo，
            return retVal;
        }
    }

public TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {   //获取AnnotationServiceImpl类saveTest1(int,int)方法上的事务注解属性
        Object cacheKey = getCacheKey(method, targetClass);
        Object cached = this.attributeCache.get(cacheKey);
        if (cached != null) {
            else {
                return (TransactionAttribute) cached;   //PROPAGATION_REQUIRES_NEW,ISOLATION_READ_COMMITTED; ''，传播属性和隔离级别。
            }
        }
    }

protected TransactionInfo createTransactionIfNecessary(PlatformTransactionManager tm, TransactionAttribute txAttr, final String joinpointIdentification) {
        TransactionStatus status = null;
        if (txAttr != null) {
            if (tm != null) {
                status = tm.getTransaction(txAttr); //txAttr  =  PROPAGATION_REQUIRES_NEW,ISOLATION_READ_COMMITTED; ''，返回//DefaultTransactionStatus@10b892d5
            }
        }
        return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
    }

public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
        Object transaction = doGetTransaction();  //DataSourceTransactionManager$DataSourceTransactionObject@5aceec94，connectionHolder = null。
            SuspendedResourcesHolder suspendedResources = suspend(null);  //不挂起事务，因为没有事务，
            try {
                boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
                DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);    //DefaultTransactionStatus@10b892d5
                doBegin(transaction, definition);
                prepareSynchronization(status, definition);
                return status;//DefaultTransactionStatus@10b892d5
            } 
    }

protected Object doGetTransaction() {
        DataSourceTransactionObject txObject = new DataSourceTransactionObject();
        txObject.setSavepointAllowed(isNestedTransactionAllowed());
        ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());  //null，第一次没有事务返回null。
        txObject.setConnectionHolder(conHolder, false);
        return txObject;
    }

protected void doBegin(Object transaction, TransactionDefinition definition) {  //开启事务，
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;   //DataSourceTransactionManager$DataSourceTransactionObject@5aceec94
        Connection con = null;
        try {
            if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                Connection newCon = obtainDataSource().getConnection();
                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);
                con.setAutoCommit(false);
            }

            prepareTransactionalConnection(con, definition);
            txObject.getConnectionHolder().setTransactionActive(true);

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

protected void commitTransactionAfterReturning(TransactionInfo txInfo) {   //通过conn提交事务，
        if (txInfo != null && txInfo.hasTransaction()) { 
            txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
        }
    }
public final void commit(TransactionStatus status) throws TransactionException {
        processCommit(defStatus);
    }
private void processCommit(DefaultTransactionStatus status) throws TransactionException { 
        doCommit(status);  
    }
protected void doCommit(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        try {
            con.commit();
        }
    }

public class AnnotationServiceImpl implements MyService {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    @Override
    public void saveTest1(int param1,int param2) {
        String sql = "insert into aa(id,name) values (?,?)";
        int count = jdbcTemplate.update(sql, new Object[]{param1,param2});
        throw new RuntimeException("saveTest1 异常"); 
    }

protected void completeTransactionAfterThrowing(TransactionInfo txInfo, Throwable ex) {   //回滚事务，
        if (txInfo != null && txInfo.hasTransaction()) { 
            if (txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());   //DataSourceTransactionManager，DefaultTransactionStatus
                }   
            }
        }
    
public final void rollback(TransactionStatus status) throws TransactionException {
        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        processRollback(defStatus);
    }

private void processRollback(DefaultTransactionStatus status) {
        doRollback(status);
    }

protected void doRollback(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        con.rollback();
    }

@Service("annotationServiceImpl")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Lazy(false)
@Description("xx")
public class AnnotationServiceImpl implements MyService {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    @Override
    public void saveTest1(int param1,int param2) {
        String sql = "insert into aa(id,name) values (?,?)";
        int count = jdbcTemplate.update(sql, new Object[]{param1,param2});
//        saveTest2(param1,param2);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    @Override
    public void saveTest2(int   param1,int param2) {
        String sql = "insert into aa(id) values (?)";
        int count = jdbcTemplate.update(sql, new Object[]{param1,param2});
    }
}

public interface MyService {
    public void saveTest1(int param1,int para2);
    public void saveTest2(int param1,int para2);
}

public class Test2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:config" + "/spring/applicationContext-core.xml");
        MyService as = (MyService) context.getBean("annotationServiceImpl");
        as.saveTest1(111,111);
    }
}

core.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/upgrade?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.username=root
jdbc.password=123456

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd"
       default-lazy-init="true">
       
    <aop:aspectj-autoproxy/>

    <!-- 导入外部属性文件 -->
    <context:property-placeholder location="classpath*:config/core/core.properties" />
    
    <context:component-scan base-package="com.zhuguang.jack"
                            use-default-filters="true" annotation-config="true">
    </context:component-scan>
    
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!--Transation-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zhuguang.jack</groupId>
    <artifactId>spring-source-web</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring-source-web Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>4.0.3.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <!-- <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId>
            <version>${org.springframework.version}</version> </dependency> -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Jackson核心-->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
        <!--
          提供jackson核心支持
        -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.8.9</version>
        </dependency>
        <!-- Jackson注解-->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
        <!--
          Jackson数据绑定包使用的核心注释，用于值类型。该包提供Json注解支持
        -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>

        <!--Jackson数据绑定-->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <!--
          对象序列化支持
        -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-instrument</artifactId>
            <version>${spring.version}</version>
        </dependency>-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- c3p0新版本 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.4</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.45</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib-nodep</artifactId>
            <version>3.2.5</version>
        </dependency>

        <!-- 日志相关依赖 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.10</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.37</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb</artifactId>
            <version>1.9.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb-cross-store</artifactId>
            <version>1.9.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb-log4j</artifactId>
            <version>1.9.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.1.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.2.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.3.2</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--用于文件上传-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.23</version>
        </dependency>
        <!--velocity 模板-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>1.7</version>
        </dependency>
        <dependency>
            <groupId>velocity-tools</groupId>
            <artifactId>velocity-tools-generic</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>quartz</groupId>
            <artifactId>quartz</artifactId>
            <version>1.5.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>spring-source-web</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
          <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>aspectj-maven-plugin</artifactId>
                        <version>1.3</version>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-surefire-plugin</artifactId>
                        <version>2.4</version>
                        <configuration>
                            <forkMode>once</forkMode>
                            <argLine>
                                -javaagent:"${settings.localRepository}/org/springframework/spring-instrument/${spring.version}/spring-instrument-${spring.version}.jar"
                            </argLine>
                        </configuration>
                    </plugin>
                </plugins>   
                <defaultGoal>compile</defaultGoal>
    </build>
</project>