2. 程式人生 > >Spring事務配置解惑

Spring事務配置解惑

阿新 • • 發佈：2018-12-23

一、專案中spring+mybaits xml配置解析

一般我們會在datasource.xml中進行如下配置，但是其中每個配置項原理和用途是什麼，並不是那麼清楚，如果不清楚的話，在使用時候就很有可能會遇到坑，所以下面對這些配置項進行一一解說

（1）配置資料來源
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"
 
 />
        <property name="url" value="${db_url}" />
        <property name="username" value="$db_user}" />
        <property name="password" value="${db_passwd}" />
        <property name="maxWait" value="${db_maxWait}" />
        <property name="maxActive" value="28"
 
 /> 
        <property name="initialSize" value="2" />
        <property name="minIdle" value="0" />
        <property name="timeBetweenEvictionRunsMillis" value="db_time" />
    </bean>

（2）建立sqlSessionFactory
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
 
>
        <property name="mapperLocations" value="classpath*:com/**/mapper/*Mapper*.xml" /> 
        <property name="dataSource" ref="dataSource" />
        <property name="typeAliasesPackage" value="com.test.***.dal" />
</bean>

（3）配置掃描器，掃描指定路徑的mapper生成資料庫操作代理類
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="annotationClass" value="javax.annotation.Resource"></property>
        <property name="basePackage" value="com.test.***.dal.***.mapper" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

（4）配置事務管理器
<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>

（5）宣告使用註解式事務
<tx:annotation-driven transaction-manager="transactionManager" />
（6）註冊各種beanfactory處理器
<context:annotation-config />    

（7）該配置建立了一個TransactionInterceptor的bean，作為事務切面的執行方法
 <tx:advice id="defaultTxAdvice">
    <tx:attributes>
        <tx:method name="*" rollback-for="Exception" />
    </tx:attributes>
</tx:advice>

（8）該配置建立了一個DefaultBeanFactoryPointcutAdvisor的bean，該bean是一個advisor,裡面包含了pointcut和advice.前者說明切面加在哪裡，後者是執行邏輯。此處可以配多個advisor
<aop:config>
    <aop:pointcut id="myCut" expression="(execution(* *..*BoImpl.*(..))) "/>
    <aop:advisor pointcut-ref="myCut" advice-ref="defaultTxAdvice" />
</aop:config>

1.1 資料來源配置

(1）是資料來源配置，這個沒啥好說的。

1.2 配置SqlSessionFactory

(2) 作用是根據配置建立一個SqlSessionFactory，看下SqlSessionFactoryBean的程式碼知道它實現了FactoryBean和InitializingBean類，由於實現了InitializingBean，所以自然它的afterPropertiesSet方法，由於實現了FactoryBean類，所以自然會有getObject方法。下面看下時序圖：

screenshot.png

從時序圖可知，SqlSessionFactoryBean類主要是通過屬性配置建立SqlSessionFactory例項，具體是解析配置中所有的mapper檔案放到configuration,然後作為建構函式引數例項化一個DefaultSqlSessionFactory作為SqlSessionFactory。

1.3 配置掃描器，掃描指定路徑的mapper生成資料庫操作代理類

MapperScannerConfigurer 實現了 BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware介面，所以會重寫一下方法：

1.3.1
//在bean註冊到ioc後建立例項前修改bean定義和新增bean註冊，這個是在context的refresh方法呼叫
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
1.3.2
//在bean註冊到ioc後建立例項前修改bean定義或者屬性值
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
1.3.3
//set屬性設定後呼叫
void afterPropertiesSet() throws Exception;
1.3.4
//獲取IOC容器上下文，在context的prepareBeanFactory中呼叫
void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
1.3.5
//獲取bean在ioc容器中名字，在context的prepareBeanFactory中呼叫
void setBeanName(String name);

先上個掃描mapper生成代理類並註冊到ioc時序圖：

screenshot.png

首先MapperScannerConfigurer實現的afterPropertiesSet方法用來確保屬性basePackage不為空

public void afterPropertiesSet() throws Exception {
    notNull(this.basePackage, "Property 'basePackage' is required");
  }

postProcessBeanFactory裡面啥都沒做，setBeanName獲取了bean的名字，setApplicationContext裡面獲取了ioc上下文。下面看重要的方法postProcessBeanDefinitionRegistry，由於mybais是執行時候才通過解析mapper檔案生成代理類注入到ioc，所以postProcessBeanDefinitionRegistry正好可以幹這個事情。

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }

    //構造一個ClassPathMapperScanner查詢mapper
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    //javax.annotation.Resource
    scanner.setAnnotationClass(this.annotationClass);
    scanner.setMarkerInterface(this.markerInterface);
    //引用sqlSessionFactory
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    //ioc上下文
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    scanner.registerFilters();
   //basePackage=com.alibaba.***.dal.***.mapper,com.alibaba.rock.auth.mapper,com.alibaba.rock.workflow.dal.workflow.mapper
    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

下面重點看下scan方法：

 public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //根據指定路徑去查詢對應mapper的介面類，並轉化為beandefination
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

    if (beanDefinitions.isEmpty()) {
      logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
    } else {
      //修改介面類bean的beandefination
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

其中super.doScan(basePackages);根據指定路徑查詢mapper介面類，並生成bean的定義物件，物件中包含beanclassname,beanclass屬性，最後註冊該bean到ioc容器。下面看下最重要的processBeanDefinitions方法對bean定義的改造。

 private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (GenericBeanDefinition) holder.getBeanDefinition();

      // 上面講的掃描後beanclass設定的為mapper介面類，但是這裡修改為MapperFactoryBean，MapperFactoryBean代理了mapper介面類,並且實際mapper介面類作為建構函式傳入了      definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); 
      definition.setBeanClass(this.mapperFactoryBean.getClass());
      definition.getPropertyValues().add("addToConfig", this.addToConfig);

      //設定屬性配置中的sqlSessionFactory
      boolean explicitFactoryUsed = false;
      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
        definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionFactory != null) {
        definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
        explicitFactoryUsed = true;
      }

      if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
        if (explicitFactoryUsed) {
          logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionTemplate != null) {
        if (explicitFactoryUsed) {
          logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
        explicitFactoryUsed = true;
      }

      if (!explicitFactoryUsed) {
        if (logger.isDebugEnabled()) {
          logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        }
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }
    }
  }

注：這裡修改了mapper介面類的beandefination中的beanclass為MapperFactoryBean，它則負責生產資料類操作代理類，實際mapper介面類作為建構函式傳入了 。由於只修改了beanclass,沒有修改beanname，所以我們從容器中獲取時候無感知的。

在上一個代理bean如何構造的時序圖：

screenshot.png

下面看下MapperFactoryBean是如何生成代理類的:
首先，上面程式碼設定了MapperFactoryBean的setSqlSessionFactory方法：

  public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
    if (!this.externalSqlSession) {
      this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
    }
  }

上面方法建立了sqlSession，由於MapperFactoryBean為工廠bean所以例項化時候會呼叫getObject方法：

 public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

其實是呼叫了SqlSessionTemplate->getMapper,其中mapperInterface就是建立MapperFactoryBean時候的建構函式引數。

public <T> T getMapper(Class<T> type) {
    return getConfiguration().getMapper(type, this);
  }

這裡呼叫getConfiguration().getMapper(type, this);實際是DefaultSqlSessionFactory裡面的configration的getMapper方法:

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
   //knownMappers是上面時序圖中步驟6設定進入的。
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }
 protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
   //代理回撥類為MapperProxy
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

在上一個實際執行sql時候呼叫代理類的序列圖：

screenshot.png

所以當呼叫實際的資料庫操作時候會呼叫MapperProxy的invoke方法：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

mapperMethod.execute(sqlSession, args);裡面實際是呼叫當前mapper對應的SqlSessionTemplate的資料庫操作，而它有委託給了代理類sqlSessionProxy，sqlSessionProxy是在SqlSessionTemplate的建構函式裡面建立的：

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
      PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
    notNull(executorType, "Property 'executorType' is required");

    this.sqlSessionFactory = sqlSessionFactory;
    this.executorType = executorType;
    this.exceptionTranslator = exceptionTranslator;
    this.sqlSessionProxy = (SqlSession) newProxyInstance(
        SqlSessionFactory.class.getClassLoader(),
        new Class[] { SqlSession.class },
        new SqlSessionInterceptor());
  }

所以最終資料庫操作有被代理SqlSessionInterceptor執行：

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      //有TransactionSynchronizationManager管理
      SqlSession sqlSession = getSqlSession(
          SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType,
          SqlSessionTemplate.this.exceptionTranslator);
      try {
        Object result = method.invoke(sqlSession, args);
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
          .....
      }
    }

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
    notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);

    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

    SqlSession session = sessionHolder(executorType, holder);
    if (session != null) {
      return session;
    }

    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug("Creating a new SqlSession");
    }
   //這裡看到了使用sessionfactory熟悉的打開了一個session
    session = sessionFactory.openSession(executorType);

    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

    return session;
  }

注意：這裡3裡面配置的掃描檔案在4的掃描檔案裡面一定要有，因為3給每個掃描檔案生成了一個代理，如果4裡面多了一個mapper，那麼在4中將找不到。

1.4 配置事務管理器

事務管理器作用見名知意，是用來管理事務的。

1.5 advice配置

作用是建立了一個TransactionInterceptor的bean，作為事務切面的執行方法。標籤解析的流程圖：

screenshot.png

由於是tx標籤，自然要查詢TxNamespaceHandler，程式碼如下：

public class TxNamespaceHandler extends NamespaceHandlerSupport {

    static final String TRANSACTION_MANAGER_ATTRIBUTE = "transaction-manager";
    static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = "transactionManager";

    static String getTransactionManagerName(Element element) {
        return (element.hasAttribute(TRANSACTION_MANAGER_ATTRIBUTE) ?
                element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE) : DEFAULT_TRANSACTION_MANAGER_BEAN_NAME);
    }

    @Override
    public void init() {
        registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
        registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
        registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
    }

}

從init方法知道advice標籤需要TxAdviceBeanDefinitionParser這個解析類。
結合流程圖第一步設定了事務管理器的引用，我們看下引用的bean的名字：

static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = "transactionManager";

static String getTransactionManagerName(Element element) {
        return (element.hasAttribute(TRANSACTION_MANAGER_ATTRIBUTE) ?
                element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE) : DEFAULT_TRANSACTION_MANAGER_BEAN_NAME);
    }

可以知道如果沒有配置這個屬性，那麼預設查詢依賴beanname=transactionManager。
然後parseAttributeSource主要迴圈解析我們配置的method標籤，和設定的方法的事務屬性。
另外程式碼：

protected Class<?> getBeanClass(Element element) {
        return TransactionInterceptor.class;
    }

可以知道這個advice標籤實際是創了TransactionInterceptor物件，並且通過呼叫setTransactionManager設定了事務管理器，通過setTransactionAttributeSources設定了事務屬性。

1.6 設定advisor

標籤<aop:config>作用是建立了DefaultBeanFactoryPointcutAdvisor作為攔截器，把滿足切點的bean進行代理使用事務攔截器進行攔截。具體標籤邏輯先看流程圖：

screenshot.png

從標籤<aop:config>可知要查詢AopNamespaceHandler,程式碼如下：

public class AopNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }
}

可知config標籤是ConfigBeanDefinitionParser來解析的，根據流程圖知configureAutoProxyCreator註冊了AspectJAwareAdvisorAutoProxyCreator類，然後createAdvisorBeanDefinition建立了DefaultBeanFactoryPointcutAdvisor，它是個advisor,並且設定引用了advice,這個adivce就是上面1.5講解的，然後createPointcutDefinition建立了切點AspectJExpressionPointcut，最後把切點設定到了advisor。
DefaultBeanFactoryPointcutAdvisor作用就是對滿足pointcut表示式的類的方法進行代理，並且使用advice進行攔截處理，而advice就是事務攔截器。

1.7 設定註解式事務

上面介紹完後就可以使用事務切面了，但是有時候還需要在具體類或者方法上進行註解行事務，那麼這就需要加 <tx:annotation-driven transaction-manager=”transactionManager” />配置
先上時序圖：

screenshot.png

!
同理1.6 不同是這裡建立了advisor,設定了advice（事務攔截器），但是好像沒有設定pointcut，看下BeanFactoryTransactionAttributeSourceAdvisor原始碼知道：

public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {

    private TransactionAttributeSource transactionAttributeSource;

    private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
        @Override
        protected TransactionAttributeSource getTransactionAttributeSource() {
            return transactionAttributeSource;
        }
    };
}

直接內建了pointcut,只不過1.6是AspectJExpressionPointcut表示式的切點，這裡是註解。
那麼這個BeanFactoryTransactionAttributeSourceAdvisor什麼時候被用來增強註解事務的類那，那是InfrastructureAdvisorAutoProxyCreator所做的事情，InfrastructureAdvisorAutoProxyCreator是個BeanPostProcessor，會在bean建立初始化後時候呼叫postProcessAfterInitialization，就是這個方法。

另外注意如果配置了多個註解式標籤在datasource.xml裡面時候只有第一個生效

public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
            AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);

            String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
            //如果配置了多個註解式標籤在datasource.xml裡面時候只有第一個生效
            if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
                Object eleSource = parserContext.extractSource(element);

                // Create the TransactionAttributeSource definition.
                RootBeanDefinition sourceDef = new RootBeanDefinition(
                        "org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
                sourceDef.setSource(eleSource);
                sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);

                // Create the TransactionInterceptor definition.
                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);

                // Create the TransactionAttributeSourceAdvisor definition.
                RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
                advisorDef.setSource(eleSource);
                advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
                advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
                if (element.hasAttribute("order")) {
                    advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
                }
                parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);

                CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
                compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
                compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
                compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
                parserContext.registerComponent(compositeDef);
            }
        }

1.8 註冊各種beanfactory處理器

當我們需要使用BeanPostProcessor時，最直接的使用方法是在Spring配置檔案中定義這些Bean。單這些會顯得比較笨拙，
例如：使用@Autowired註解，必須事先在Spring容器中宣告

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor "/>

使用 @Required註解，就必須宣告：

<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor"/>

通過標籤<context:annotation-config/> ，我們可以同時自動註冊這些常用的beanfactory處理器，避免了我們一個個配置的繁瑣步驟:

public class ContextNamespaceHandler extends NamespaceHandlerSupport {

                ...
        registerJava5DependentParser("annotation-config",
                "org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser");
        ....
}

public class AnnotationConfigBeanDefinitionParser implements BeanDefinitionParser {

    public BeanDefinition parse(Element element, ParserContext parserContext) {
                ...
        // Obtain bean definitions for all relevant BeanPostProcessors.
        Set<BeanDefinitionHolder> processorDefinitions =
                AnnotationConfigUtils.registerAnnotationConfigProcessors(parserContext.getRegistry(), source);

        // Register component for the surrounding <context:annotation-config> element.
        CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
        parserContext.pushContainingComponent(compDefinition);

        // Nest the concrete beans in the surrounding component.
        for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
            parserContext.registerComponent(new BeanComponentDefinition(processorDefinition));
        }

        // Finally register the composite component.
        parserContext.popAndRegisterContainingComponent();

        return null;
    }

}


public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, Object source) {

        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>(4);

        // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
        if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition();
            try {
                ClassLoader cl = AnnotationConfigUtils.class.getClassLoader();
                def.setBeanClass(cl.loadClass(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME));
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
            }
            def.setSource(source);
            def.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            beanDefinitions.add(registerBeanPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
        if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            def.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            beanDefinitions.add(registerBeanPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            def.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            beanDefinitions.add(registerBeanPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            def.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            beanDefinitions.add(registerBeanPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        return beanDefinitions;
    }

主要註冊常用的：
RequiredAnnotationBeanPostProcessor
AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
平時我們使用autowired或者required之所以能生效，就是因為這個自動注入ioc已經。


加多

加多

高階 Java 攻城獅 at 阿里巴巴加多，目前就職於阿里巴巴，熱衷併發程式設計、ClassLoader,Spring等開源框架,分散式RPC框架dubbo，springcloud等；愛好音樂，運動。微信公眾號：技術原始積累。知識星球賬號：技術原始積累

相關推薦

Spring事務配置解惑

一、專案中spring+mybaits xml配置解析 一般我們會在datasource.xml中進行如下配置，但是其中每個配置項原理和用途是什麼，並不是那麼清楚，如果不清楚的話，在使用時候就很有可能會遇到坑，所以下面對這些配置項進行一一解說 （1）配置資料來源 <bean id=

導致spring事務配置不起作用的一種原因

red something 事務配置 nbsp oid -s color con bsp @Component public class AnalyticsApplication { @Autowired private InitializationAc

Spring 事務配置實戰（一）：過濾無需事務處理的查詢之類操作

log pla ssi pan spl tail gif aop img <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes

SSH深度歷險（六） 深入淺出----- Spring事務配置的五種方式

配置 處理 數據 data easy ont get 添加 由於 這對時間在學習SSH中Spring架構，Spring的事務配置做了具體總結。在此之間對Spring的事務配置僅僅是停留在聽說的階段，總結一下。總體把控。通過這次的學習發覺Spring的事務

記一次 Spring 事務配置踩坑記

pub lock loaded 查詢條件 setprop ins 能夠 get 數據 記一次 Spring 事務配置踩坑記 問題描述：（SpringBoot + MyBatisPlus） 業務邏輯偽代碼如下。理論上，插入數據 t1 後，xxService.getXxx(

Spring事務配置（配置檔案的形式）

     聲明瞭事務通知後, 就需要將它與切入點關聯起來. 由於事務通知是在 <aop:config> 元素外部宣告的, 所以它無法直接與切入點產生關聯. 所以必須在 <aop:config> 元素中宣告一個增強器通知與切入點關聯起來. 由於

Atitit Spring事務配置不起作用可能出現的問題： .是否是資料庫引擎設定不對造成的【筆者就遇到了這個問題，由於筆者使用的是mysql資料，但是在建立表的時候引擎預設（mysql中引擎預設為

Atitit Spring事務配置不起作用可能出現的問題：   .是否是資料庫引擎設定不對造成的【筆者就遇到了這個問題，由於筆者使用的是mysql資料，但是在建立表的時候引擎預設（mysql中引擎預設為MyISAM，是不支援事務操作的），需要修改為InnoDB，就可以支援事務操作了

spring事務配置的兩種方式

spring所有的事務管理策略類都繼承自org.springframework.transaction.PlatformTransactionManager介面。   <!-- 事務管理器配置,單資料來源事務 --> <bean id="transactionMan

Spring事務配置-註解篇

事務註解，可以作用在類或者public方法上，寫在類上的時候，對該類下的所有的public的方法有用。假如方法上加了final修飾，將會導致事務不可用。 具體參考：https://blog.csdn.net/bao19901210/article/details/41724355 舉例說明：

解決osgi spring 事務配置問題

前久看了一篇文章， http://www.javaeye.com/topic/315257 裡面說 由於目前還無法解決 osgi 環境下的 aspectj 問題 , 所以 , 處理事務無法使用 tx:advice 和 aop:config, 改用 DataSourceT

Spring事務配置的五種方式及事務傳播相關(不看後悔，一看必懂！)

原文:http://blog.csdn.net/hjm4702192/article/details/17277669 前段時間對Spring的事務配置做了比較深入的研究，在此之間對Spring的事務配置雖說也配置過，但是一直沒有一個清楚的認識。通過這次的學習發覺Sprin

spring事務配置方法（BeanNameAutoProxyCreator）

採用這種配置策略，完全可以避免增量式配置，所有的事務代理由系統自動建立。容器中的目標bean自動消失，避免需要使用巢狀bean來保證目標bean不可被訪問。 這種配置方式依賴於Spring提供的bean後處理器，該後處理器用於為每個bean自動建立代理，此處的代理不僅可以是

Spring事務配置檔案方式

<!-- 配置事務屬性 --> <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManage

spring事務配置的五種方式

資料庫提供了四種事務隔離級別, 不同的隔離級別採用不同的鎖類開來實現. 在四種隔離級別中, Serializable的級別最高, Read Uncommited級別最低. 大多數資料庫的預設隔離級別為: Read Commited,如Sql Server , Oracle. 少數資料庫預設的隔離級別為Repe

關於Spring事務配置不起作用問題總結

實際開發環境中經常會遇到Spring框架配置事物失敗或不起作用問題，而且無法直觀的在程式碼中追根溯源。工程師們絞盡腦汁，檢查各項配置引數、檢視日誌、反向推理等等手段去排除問題所在。本文就將出現最為頻繁的常見問題總結分析： 目錄 資料庫非事務支援引擎

spring事務配置方式之mybatis

spring支援程式設計式事務管理和宣告式事務管理兩種方式。        程式設計式事務管理使用TransactionTemplate或者直接使用底層的PlatformTransactionManag

spring學習筆記(22)聲明式事務配置，readOnly無效寫無異常

lin top post 處理 ast cannot pro ever 也不會 在上一節內容中。我們使用了編程式方法來配置事務，這種優點是我們對每一個方法的控制性非常強。比方我須要用到什麽事務，在什麽位置假設出現異常須要回滾等。能夠進行非常細粒度的配置。

spring、mybatis事務配置和控制

數據庫 one ons str size 連接池 action b2c drive springmybatis.xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:x

spring事務管理，xml配置aop事務和註解配置aop事務

mov ref itcast template password nds eth poi ntc xml配置和註解配合共同代碼 AccountService.java public interface AccountService { //轉賬方法

spring 事務管理的簡單配置

ger string oot code nal chan 價格 nts 每次 1：事務的優點 　　事務管理對平時的業務邏輯的健壯性幫助很大，它保證了一個動作的原子性 　　本例中主要體現在，購票或者購書中，業務邏輯如下： 　　　　1：根據商品的ID查詢該商品的價格，