村长kylin
村长kylin

spring事务管理

我们都知道spring提供两种管理事务的方式，一种是声明式事务，一种是编程式事务。
Spring的声明式事务管理，基于Spring的AOP，不再需要不停地写commit，rollback，（但Spring仍然没有放弃编程式的事务管理策略）。
Spring的编程式事务管理，为我们提供了一个TransactionTemplate，使用回调机制，将应用代码从样板式的资源获取和释放代码中解放出来，不再有大量的try/catch/finally/try/catch代码块。

 

这两种事务处理方式都非常地优雅，它不需要与任何特定的事务API耦合，并支持多种持久层方案。
（1）声明式事务：基于Spring AOP实现，几乎就是xml文件的配置
（2）编程式事务：统一的事务编码风格，几乎是一个模板化的。

 

以下将对这两种事务管理方式进行探讨：

首先探讨一下声明式事务：
我们知道Spring事务管理的核心接口是：
org.springframework.transaction.PlatformTransactionManager
它定义了三个待实现的方法：
（1）public TransactionStatus getTransaction(TransactionDefinition definition);
 //返回当前活动的事务或根据相应的行为创建一个新的事务（可以查阅API理解）
（2）public void commit(TransactionStatus status);//提交事务
（3）public void rollback(TransactionStatus status); //回滚事务

PlatformTransactionManager是一个与特定平台无关的事务操作接口，不同的底层事务平台应通过Spring的Ioc注入相应的事务操作实现类 (这些实现类也不需要我们去完成，Spring已经为我们提供了)。那么我们来看看针对不同的底层持久化平台，我们需要为PlatformTransactionManager接口注入何种实现类：

Xml代码
  1. （1）利用JDBC作为持久层的局部事务：   
  2. <?xml version="1.0" encoding="utf-8"?>  
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  7.   
  8. <!-- 定义数据源Bean，使用C3P0数据源 -->  
  9. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy- method="close">  
  10.     <!-- 指定连接数据库的驱动 -->  
  11.     <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  12.     <!-- 指定连接数据库的URL -->  
  13.     <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  14.     <!-- 指定连接数据库的用户名 -->  
  15.     <property name="user" value="root"/>  
  16.     <!-- 指定连接数据库的密码 -->  
  17.     <property name="password" value="123"/>  
  18.     <!-- 指定连接数据库连接池的最大连接数 -->  
  19.     <property name="maxPoolSize" value="40"/>  
  20.     <!-- 指定连接数据库连接池的最小连接数 -->  
  21.     <property name="minPoolSize" value="1"/>  
  22.     <!-- 指定连接数据库连接池的初始化连接数 -->  
  23.     <property name="initialPoolSize" value="1"/>  
  24.     <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  25.     <property name="maxIdleTime" value="20"/>  
  26. </bean>  
  27.   
  28. <!—定义JDBC数据源的局部事务管理器 -->  
  29. <!-- 使用DataSourceTransactionManager类，该类实现PlatformTransactionManager接口 ，是针对采用数据源连接的特定实现 -->  
  30. <bean id="transactionManager"    
  31.         class="org.springframework.jdbc.datasource.   
  32.         DataSourceTransactionManager">  
  33.         <!—DataSourceTransactionManager需要注入一个DataSource的引用-->  
  34.          <property name="dataSource" ref="dataSource"/>  
  35.     </bean>  
  36. </beans>  
  37.   
  38. （2）利用Hibernate作为持久层的局部事务：   
  39. <?xml version="1.0" encoding="utf-8"?>  
  40. <beans xmlns="http://www.springframework.org/schema/beans"  
  41.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  42.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  43.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  44.     <!-- 定义数据源Bean，使用C3P0数据源 -->  
  45.     <bean id="dataSource" class="com.mchange.v2.c3p0.    
  46.     ComboPooledDataSource" destroy-method="close">  
  47.         <!-- 指定连接数据库的驱动 -->  
  48.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  49.         <!-- 指定连接数据库的URL -->  
  50.         <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  51.         <!-- 指定连接数据库的用户名 -->  
  52.         <property name="user" value="root"/>  
  53.         <!-- 指定连接数据库的密码 -->  
  54.         <property name="password" value="123"/>  
  55.         <!-- 指定连接数据库连接池的最大连接数 -->  
  56.         <property name="maxPoolSize" value="40"/>  
  57.         <!-- 指定连接数据库连接池的最小连接数 -->  
  58.         <property name="minPoolSize" value="1"/>  
  59.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  60.         <property name="initialPoolSize" value="1"/>  
  61.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  62.         <property name="maxIdleTime" value="20"/>  
  63.     </bean>  
  64.   
  65.     <!-- 定义Hibernate的SessionFactory -->  
  66.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.    
  67.     LocalSessionFactoryBean">  
  68.         <!-- 注入SessionFactory所需的数据源 -->  
  69.         <property name="dataSource" ref="dataSource"/>  
  70.         <!--列出全部映射文件 -->  
  71.         <property name="mappingResources">  
  72.               <list>  
  73.                   <!--列出所有的PO映射文件 -->  
  74.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  75.               </list>  
  76.         </property>  
  77.           <!-- 定义Hibernate的SessionFactory属性 -->  
  78.         <property name="hibernateProperties">  
  79.             <props>  
  80.                 <!-- 指定Hibernate的连接方言 -->  
  81.                 <prop key="hibernate.dialect">org.hibernate.dialect.    
  82.                 MySQLDialect</prop>  
  83.         </property>  
  84.     </bean>  
  85.   
  86.     <!-- 配置Hibernate的局部事务管理器 -->  
  87.     <!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager   
  88.     接口，是针对采用Hibernate持久化连接的特定实现 -->  
  89.     <bean id="transactionManager"    
  90.       class="org.springframework.orm.hibernate3.    
  91.       HibernateTransactionManager">  
  92.             <!--注入一个SessionFactorybean的引用 -->  
  93.          <property name="sessionFactory" ref="sessionFactory"/>  
  94.      </bean>  
  95. </beans>  
  96.   
  97. （3）利用Hibernate作为持久层的全局事务：   
  98. <?xml version="1.0" encoding="utf-8"?>  
  99. <beans xmlns="http://www.springframework.org/schema/beans"  
  100.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  101.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  102.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  103.     <!—定义JNDI数据源Bean -->  
  104.     <bean id="dataSource" class="org.springframework.jndi.    
  105.     JndiObjectFactoryBean">  
  106.         <!--  容器管理数据源的JNDI -->  
  107.          <property name="jndiName" value="jdbc/jtest"/>  
  108.     </bean>  
  109.     <!--定义Hibernate的SessionFactory -->  
  110.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.    
  111.     LocalSessionFactoryBean">  
  112.         <!-- 注入SessionFactory所需的数据源-->  
  113.         <property name="dataSource" ref="dataSource"/>  
  114.         <!--列出全部映射文件 -->  
  115.         <property name="mappingResources">  
  116.               <list>  
  117.                   <!-- 列出所有的PO映射文件 -->  
  118.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  119.               </list>  
  120.         </property>  
  121.           <!-- 定义Hibernate的SessionFactory的属性 -->  
  122.         <property name="hibernateProperties">  
  123.              <props>  
  124.                 <!-- 指定Hibernate的连接方言 -->  
  125.                 <prop key="hibernate.dialect">org.hibernate.dialect.    
  126.                 MySQLDialect</prop>  
  127.          </property>  
  128.     </bean>  
  129.     <!-- 使用JtaTransactionManager类，该类实现PlatformTransactionManager接口-->  
  130.     <!-- JtaTransactionManager不需要知道数据源，或任何其他特定资源，   
  131.             因为使用容器的全局事务管理 -->  
  132.     <bean id="transactionManager"    
  133.            class="org.springframework.transaction.jta.   
  134.            JtaTransactionManager" />  
  135. </beans>  
[xml]   view plain copy
  1. （1）利用JDBC作为持久层的局部事务：  
  2. <?xml version="1.0" encoding="utf-8"?>  
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  7.   
  8. <!-- 定义数据源Bean，使用C3P0数据源 -->  
  9. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy- method="close">  
  10.     <!-- 指定连接数据库的驱动 -->  
  11.     <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  12.     <!-- 指定连接数据库的URL -->  
  13.     <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  14.     <!-- 指定连接数据库的用户名 -->  
  15.     <property name="user" value="root"/>  
  16.     <!-- 指定连接数据库的密码 -->  
  17.     <property name="password" value="123"/>  
  18.     <!-- 指定连接数据库连接池的最大连接数 -->  
  19.     <property name="maxPoolSize" value="40"/>  
  20.     <!-- 指定连接数据库连接池的最小连接数 -->  
  21.     <property name="minPoolSize" value="1"/>  
  22.     <!-- 指定连接数据库连接池的初始化连接数 -->  
  23.     <property name="initialPoolSize" value="1"/>  
  24.     <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  25.     <property name="maxIdleTime" value="20"/>  
  26. </bean>  
  27.   
  28. <!—定义JDBC数据源的局部事务管理器 -->  
  29. <!-- 使用DataSourceTransactionManager类，该类实现PlatformTransactionManager接口 ，是针对采用数据源连接的特定实现 -->  
  30. <bean id="transactionManager"   
  31.         class="org.springframework.jdbc.datasource.  
  32.         DataSourceTransactionManager">  
  33.         <!—DataSourceTransactionManager需要注入一个DataSource的引用-->  
  34.          <property name="dataSource" ref="dataSource"/>  
  35.     </bean>  
  36. </beans>  
  37.   
  38. （2）利用Hibernate作为持久层的局部事务：  
  39. <?xml version="1.0" encoding="utf-8"?>  
  40. <beans xmlns="http://www.springframework.org/schema/beans"  
  41.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  42.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  43.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  44.     <!-- 定义数据源Bean，使用C3P0数据源 -->  
  45.     <bean id="dataSource" class="com.mchange.v2.c3p0.   
  46.     ComboPooledDataSource" destroy-method="close">  
  47.         <!-- 指定连接数据库的驱动 -->  
  48.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  49.         <!-- 指定连接数据库的URL -->  
  50.         <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  51.         <!-- 指定连接数据库的用户名 -->  
  52.         <property name="user" value="root"/>  
  53.         <!-- 指定连接数据库的密码 -->  
  54.         <property name="password" value="123"/>  
  55.         <!-- 指定连接数据库连接池的最大连接数 -->  
  56.         <property name="maxPoolSize" value="40"/>  
  57.         <!-- 指定连接数据库连接池的最小连接数 -->  
  58.         <property name="minPoolSize" value="1"/>  
  59.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  60.         <property name="initialPoolSize" value="1"/>  
  61.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  62.         <property name="maxIdleTime" value="20"/>  
  63.     </bean>  
  64.   
  65.     <!-- 定义Hibernate的SessionFactory -->  
  66.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.   
  67.     LocalSessionFactoryBean">  
  68.         <!-- 注入SessionFactory所需的数据源 -->  
  69.         <property name="dataSource" ref="dataSource"/>  
  70.         <!--列出全部映射文件 -->  
  71.         <property name="mappingResources">  
  72.               <list>  
  73.                   <!--列出所有的PO映射文件 -->  
  74.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  75.               </list>  
  76.         </property>  
  77.           <!-- 定义Hibernate的SessionFactory属性 -->  
  78.         <property name="hibernateProperties">  
  79.             <props>  
  80.                 <!-- 指定Hibernate的连接方言 -->  
  81.                 <prop key="hibernate.dialect">org.hibernate.dialect.   
  82.                 MySQLDialect</prop>  
  83.         </property>  
  84.     </bean>  
  85.   
  86.     <!-- 配置Hibernate的局部事务管理器 -->  
  87.     <!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager  
  88.     接口，是针对采用Hibernate持久化连接的特定实现 -->  
  89.     <bean id="transactionManager"   
  90.       class="org.springframework.orm.hibernate3.   
  91.       HibernateTransactionManager">  
  92.             <!--注入一个SessionFactorybean的引用 -->  
  93.          <property name="sessionFactory" ref="sessionFactory"/>  
  94.      </bean>  
  95. </beans>  
  96.   
  97. （3）利用Hibernate作为持久层的全局事务：  
  98. <?xml version="1.0" encoding="utf-8"?>  
  99. <beans xmlns="http://www.springframework.org/schema/beans"  
  100.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  101.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  102.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  103.     <!—定义JNDI数据源Bean -->  
  104.     <bean id="dataSource" class="org.springframework.jndi.   
  105.     JndiObjectFactoryBean">  
  106.         <!--  容器管理数据源的JNDI -->  
  107.          <property name="jndiName" value="jdbc/jtest"/>  
  108.     </bean>  
  109.     <!--定义Hibernate的SessionFactory -->  
  110.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.   
  111.     LocalSessionFactoryBean">  
  112.         <!-- 注入SessionFactory所需的数据源-->  
  113.         <property name="dataSource" ref="dataSource"/>  
  114.         <!--列出全部映射文件 -->  
  115.         <property name="mappingResources">  
  116.               <list>  
  117.                   <!-- 列出所有的PO映射文件 -->  
  118.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  119.               </list>  
  120.         </property>  
  121.           <!-- 定义Hibernate的SessionFactory的属性 -->  
  122.         <property name="hibernateProperties">  
  123.              <props>  
  124.                 <!-- 指定Hibernate的连接方言 -->  
  125.                 <prop key="hibernate.dialect">org.hibernate.dialect.   
  126.                 MySQLDialect</prop>  
  127.          </property>  
  128.     </bean>  
  129.     <!-- 使用JtaTransactionManager类，该类实现PlatformTransactionManager接口-->  
  130.     <!-- JtaTransactionManager不需要知道数据源，或任何其他特定资源，  
  131.             因为使用容器的全局事务管理 -->  
  132.     <bean id="transactionManager"   
  133.            class="org.springframework.transaction.jta.  
  134.            JtaTransactionManager" />  
  135. </beans>  

在上面的配置中，对于采用jdbc，hibernate等，我们只要提供相应的PlatformTransactionManager实现类即可。可见Spring对事务的操作仅仅修改一下配置文件，不需要修改任何实际的代码，就可以在不同的事务管理策略之间切换，非常地方便，Spring为我们提供了高度的解耦。

 

以上就是我们在spring中处理事务所需要的事务管理器的配置，那么在具体的业务处理bean中我们如何控制事务呢？
一般都推荐事务最好做在service层，底层的dao可以不考虑事务，有时设计得不好可能会出现事务的嵌套，增加程序复杂度。而且将事务的处理放在service层中进行，对于我们异常体系的设计也带来好处，service层抛出的异常可以在web捕获，并将异常信息在web页面给用户提示。所以接下来我们就将在service层开始事务，提交事务，回滚事务等。作为声明式事务管理，spring已经帮我们做好了这一切，基本上就是代理模式。

 

以下就是Spring提供的4种事务代理方式：
1.使用TransactionProxyFactoryBean为目标bean生成事务代理，此方式是最传统，也是配置文件最臃肿的一种方式。
2.使用bean继承的事务代理方式，此方式比较简洁，但依然是增量式配置，bean越多配置文件越臃肿。
3.使用BeanNameAutoProxyCreator，根据bean name自动生成事务代理的方式，这是直接利用Spring的AOP框架配置事务代理的方式，需要对Spring的AOP框架有所了解，但也不必成为AOP专家，这种方式避免了增量式配置，也是推荐的方式。
4.使用DefaultAdvisorAutoProxyCreator，这也是直接利用Spring的AOP框架配置事务代理的方式，只是这种配置方式的可读性不如第三种方式。

 

对于第一种：使用TransactionProxyFactoryBean为目标bean生成事务代理：
因为TransactionProxyFactoryBean产生的是代理Bean，所以我们在配置TransactionProxyFactoryBean时，需要指定目标Bean。每个TransactionProxyFactoryBean为一个目标Bean生成事务代理，事务代理的方法改写了目标Bean的方法，就是在目标Bean的方法执行之前加入开始事务，在目标Bean的方法正常结束之前提交事务，如果遇到特定异常则回滚事务。TransactionProxyFactoryBean创建事务代理时，需要了解当前事务所处的环境，该环境属性通过PlatformTransactionManager实例传入，而相关事务传入规则在TransactionProxyFactoryBean的定义中给出。

下面该方法的配置方式：

Xml代码
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  5.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  6.     <!-- 定义数据源Bean，使用C3P0数据源 -->  
  7.     <bean id="dataSource" class="com.mchange.v2.c3p0.    
  8.     ComboPooledDataSource" destroy-method="close">  
  9.         <!-- 指定连接数据库的驱动 -->  
  10.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  11.         <!-- 指定连接数据库的URL -->  
  12.         <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  13.         <!-- 指定连接数据库的用户名 -->  
  14.         <property name="user" value="root"/>  
  15.         <!-- 指定连接数据库的密码 -->  
  16.         <property name="password" value="123"/>  
  17.         <!-- 指定连接数据库连接池的最大连接数 -->  
  18.         <property name="maxPoolSize" value="40"/>  
  19.         <!-- 指定连接数据库连接池的最小连接数 -->  
  20.         <property name="minPoolSize" value="1"/>  
  21.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  22.         <property name="initialPoolSize" value="1"/>  
  23.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  24.         <property name="maxIdleTime" value="20"/>  
  25.     </bean>  
  26.   
  27.     <!-- 定义Hibernate的SessionFactory -->  
  28.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.    
  29.     LocalSessionFactoryBean">  
  30.         <!-- 注入SessionFactory所需的数据源-->  
  31.         <property name="dataSource" <refref="dataSource"/>  
  32.         <!--列出全部映射文件 -->  
  33.         <property name="mappingResources">  
  34.               <list>  
  35.                   <!--列出所有的PO映射文件 -->  
  36.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  37.               </list>  
  38.         </property>  
  39.           <!-- 定义Hibernate的SessionFactory属性 -->  
  40.         <property name="hibernateProperties">  
  41.              <props>  
  42.                 <!-- 指定Hibernate的连接方言 -->  
  43.                 <prop key="hibernate.dialect">org.hibernate.dialect.    
  44.                 MySQLDialect</prop>  
  45.              </props>  
  46.         </property>  
  47. </bean>  
  48. <!-- 配置DAO Bean -->  
  49.     <bean id="userDAO" class="org.hnylj.dao.impl.UserDaoImpl">     
  50.         <property name="sessionFactory">     
  51.             <ref bean="sessionFactory" />     
  52.         </property>     
  53.     </bean>     
  54.   
  55.     <!-- 配置Service Bean，该Bean将作为目标Bean使用 -->  
  56.     <bean id="userServiceTarget" class="org.hnylj.service.impl.UserServiceImpl">  
  57.         <!-- 依赖注入userDAO的引用 -->  
  58.         <property name="userDAO" ref="userDAO"/>  
  59.     </bean>  
  60.   
  61.     <!-- 配置Hibernate的事务管理器 -->  
  62.     <!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager   
  63.     接口，针对采用Hibernate持久化连接的特定实现 -->  
  64.     <bean id="transactionManager"    
  65.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  66.         <!-- HibernateTransactionManager Bean，它需要依赖注入一个SessionFactory   
  67.         Bean的引用 -->  
  68.         <property name="sessionFactory" ref="sessionFactory"/>  
  69.     </bean>  
  70.   
  71.     <!--  配置userServiceTarget Bean的事务代理 -->  
  72.     <bean id="userService"    
  73.         class="org.springframework.transaction.interceptor.    
  74.         TransactionProxyFactoryBean">  
  75.           <!-- 依赖注入PlatformTransactionManager的bean引用，此处使用   
  76.           Hibernate的bean -->  
  77.           <!-- 局部事务器，传入Hibernate事务管理器的引用 -->  
  78.           <property name="transactionManager" ref="transactionManager"/>  
  79.           <!-- 需要生成代理的目标bean -->  
  80.           <property name="target" ref="userServiceTarget"/>  
  81.           <!-- 指定事务属性 -->  
  82.           <property name="transactionAttributes">  
  83.               <props>  
  84.                   <!-- 以下部分为定义事务回滚规则 -->  
  85.                   <prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>  
  86.                   <prop key="update*">PROPAGATION_REQUIRED</prop>  
  87.                   <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>  
  88.               </props>  
  89.         </property>  
  90.     </bean>  
  91. </beans>  
[xml]   view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  5.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  6.     <!-- 定义数据源Bean，使用C3P0数据源 -->  
  7.     <bean id="dataSource" class="com.mchange.v2.c3p0.   
  8.     ComboPooledDataSource" destroy-method="close">  
  9.         <!-- 指定连接数据库的驱动 -->  
  10.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  11.         <!-- 指定连接数据库的URL -->  
  12.         <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  13.         <!-- 指定连接数据库的用户名 -->  
  14.         <property name="user" value="root"/>  
  15.         <!-- 指定连接数据库的密码 -->  
  16.         <property name="password" value="123"/>  
  17.         <!-- 指定连接数据库连接池的最大连接数 -->  
  18.         <property name="maxPoolSize" value="40"/>  
  19.         <!-- 指定连接数据库连接池的最小连接数 -->  
  20.         <property name="minPoolSize" value="1"/>  
  21.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  22.         <property name="initialPoolSize" value="1"/>  
  23.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  24.         <property name="maxIdleTime" value="20"/>  
  25.     </bean>  
  26.   
  27.     <!-- 定义Hibernate的SessionFactory -->  
  28.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.   
  29.     LocalSessionFactoryBean">  
  30.         <!-- 注入SessionFactory所需的数据源-->  
  31.         <property name="dataSource" <refref="dataSource"/>  
  32.         <!--列出全部映射文件 -->  
  33.         <property name="mappingResources">  
  34.               <list>  
  35.                   <!--列出所有的PO映射文件 -->  
  36.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  37.               </list>  
  38.         </property>  
  39.           <!-- 定义Hibernate的SessionFactory属性 -->  
  40.         <property name="hibernateProperties">  
  41.              <props>  
  42.                 <!-- 指定Hibernate的连接方言 -->  
  43.                 <prop key="hibernate.dialect">org.hibernate.dialect.   
  44.                 MySQLDialect</prop>  
  45.              </props>  
  46.         </property>  
  47. </bean>  
  48. <!-- 配置DAO Bean -->  
  49.     <bean id="userDAO" class="org.hnylj.dao.impl.UserDaoImpl">    
  50.         <property name="sessionFactory">    
  51.             <ref bean="sessionFactory" />    
  52.         </property>    
  53.     </bean>    
  54.   
  55.     <!-- 配置Service Bean，该Bean将作为目标Bean使用 -->  
  56.     <bean id="userServiceTarget" class="org.hnylj.service.impl.UserServiceImpl">  
  57.         <!-- 依赖注入userDAO的引用 -->  
  58.         <property name="userDAO" ref="userDAO"/>  
  59.     </bean>  
  60.   
  61.     <!-- 配置Hibernate的事务管理器 -->  
  62.     <!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager  
  63.     接口，针对采用Hibernate持久化连接的特定实现 -->  
  64.     <bean id="transactionManager"   
  65.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  66.         <!-- HibernateTransactionManager Bean，它需要依赖注入一个SessionFactory  
  67.         Bean的引用 -->  
  68.         <property name="sessionFactory" ref="sessionFactory"/>  
  69.     </bean>  
  70.   
  71.     <!--  配置userServiceTarget Bean的事务代理 -->  
  72.     <bean id="userService"   
  73.         class="org.springframework.transaction.interceptor.   
  74.         TransactionProxyFactoryBean">  
  75.           <!-- 依赖注入PlatformTransactionManager的bean引用，此处使用  
  76.           Hibernate的bean -->  
  77.           <!-- 局部事务器，传入Hibernate事务管理器的引用 -->  
  78.           <property name="transactionManager" ref="transactionManager"/>  
  79.           <!-- 需要生成代理的目标bean -->  
  80.           <property name="target" ref="userServiceTarget"/>  
  81.           <!-- 指定事务属性 -->  
  82.           <property name="transactionAttributes">  
  83.               <props>  
  84.                   <!-- 以下部分为定义事务回滚规则 -->  
  85.                   <prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>  
  86.                   <prop key="update*">PROPAGATION_REQUIRED</prop>  
  87.                   <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>  
  88.               </props>  
  89.         </property>  
  90.     </bean>  
  91. </beans>  

关于以上配置文件的几个事务传播规则可以查阅相应的API

程序面向UserServiceImpl类所实现的接口编程，事务处理由Spring为UserServiceImpl类所实现的接口IUserService生成的代理bean来完成。（Spring不仅支持对接口的代理，Spring结合CGLIB还可以为具体类生成代理，在此不做讨论）

 

对于第二种：采用bean继承的事务代理
仔细观察第一种配置方式，我们可以发现，如果配置文件中有多个这样的事务代理Bean，配置文件将变得非常臃肿。所以可以使用Bean继承来简化事务代理的配置。考虑到所有事务代理Bean中，事务代理Bean所使用的事务管理器和事务传播规则大致是相同的,所以我们可以定义一个事务代理bean的模板。
即：

Xml代码
  1. <!-- 定义所有事务代理Bean的模板 -->  
  2. <bean id="txProxyTemplate" abstract="true"  
  3.         class="org.springframework.transaction.interceptor.   
  4.         TransactionProxyFactoryBean">  
  5.     <!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->  
  6.     <property name="transactionManager" ref="transactionManager"/>  
  7.         <!-- 定义生成事务代理通用的事务属性 -->  
  8.         <property name="transactionAttributes">  
  9.             <props>  
  10.                 <!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->  
  11.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  12.             </props>  
  13.     </property>  
  14. </bean>   
[xml]   view plain copy
  1. <!-- 定义所有事务代理Bean的模板 -->  
  2. <bean id="txProxyTemplate" abstract="true"  
  3.         class="org.springframework.transaction.interceptor.  
  4.         TransactionProxyFactoryBean">  
  5.     <!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->  
  6.     <property name="transactionManager" ref="transactionManager"/>  
  7.         <!-- 定义生成事务代理通用的事务属性 -->  
  8.         <property name="transactionAttributes">  
  9.             <props>  
  10.                 <!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->  
  11.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  12.             </props>  
  13.     </property>  
  14. </bean>   

接下来让真正的事务代理Bean继承上面的事务模板Bean

Xml代码
  1. <!-- 让事务代理Bean继承模板Bean -->  
  2. <bean id="userService" parent="txProxyTemplate">  
  3.     <!-- 这里是嵌套Bean的配置方式 -->  
  4.     <property name="target">  
  5.         <bean class="org.hnylj.service.impl.userServiceImpl"/>  
  6.     </property>  
  7. </bean>  
[xml]   view plain copy
  1. <!-- 让事务代理Bean继承模板Bean -->  
  2. <bean id="userService" parent="txProxyTemplate">  
  3.     <!-- 这里是嵌套Bean的配置方式 -->  
  4.     <property name="target">  
  5.         <bean class="org.hnylj.service.impl.userServiceImpl"/>  
  6.     </property>  
  7. </bean>  

我们知道,继承中子类可以复写父类的方法，这里也一样，子Bean重新定义事务属性将覆盖事务代理模板里的事务属性定义：
即：

Xml代码   <!-- 让事务代理bean继承模板Bean -->  
  1. <bean id="userService" parent="txProxyTemplate">  
  2.     <!-- 这里引用已存在的bean的方式来定义目标Bean -->  
  3.     <property name="target" ref ="userServiceTarget"/>  
  4.     <!-- 覆盖事务代理模板bean中的事务属性定义 -->  
  5.     <property name="transactionAttributes">  
  6.         <props>  
  7.             <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
  8.             <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  9.             <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
  10.          </props>  
  11.     </property>  
  12. </bean>  
[xml]   view plain copy
  1. <!-- 让事务代理bean继承模板Bean -->  
  2. <bean id="userService" parent="txProxyTemplate">  
  3.     <!-- 这里引用已存在的bean的方式来定义目标Bean -->  
  4.     <property name="target" ref ="userServiceTarget"/>  
  5.     <!-- 覆盖事务代理模板bean中的事务属性定义 -->  
  6.     <property name="transactionAttributes">  
  7.         <props>  
  8.             <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
  9.             <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  10.             <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
  11.          </props>  
  12.     </property>  
  13. </bean>  

可见，采用Bean继承方式定义事务代理的方式，可以很好地简化事务代理的配置，可以避免配置事务代理Bean时的冗余配置。

 

对于第三种：使用BeanNameAutoProxyCreator
使用BeanNameAutoProxyCreator来创建代理时，并不一定是创建事务代理，关键在于传入的拦截器，如果传入事务拦截器，将可自动生成事务代理。

下面是使用BeanNameAutoProxyCreator自动生成事务代理的配置方式：

[xml]   view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->  
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans          
  6. http://www.springframework.org/schema/beans/spring-beans.xsd">  
  7.     <!-- 定义数据源Bean，使用C3P0数据源实现 -->  
  8.     <bean id="dataSource" class="com.mchange.v2.c3p0.   
  9.     ComboPooledDataSource" destroy-method="close">  
  10.         <!-- 指定连接数据库的驱动 -->  
  11.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  12.         <!-- 指定连接数据库的URL -->  
  13.         <property name="jdbcUrl" value="jdbc:mysql:3306/127.0.0.1/ssh"/>  
  14.         <!-- 指定连接数据库的用户名 -->  
  15.         <property name="user" value="root"/>  
  16.         <!-- 指定连接数据库的密码 -->  
  17.         <property name="password" value="123"/>  
  18.         <!-- 指定连接数据库连接池的最大连接数 -->  
  19.         <property name="maxPoolSize" value="40"/>  
  20.         <!-- 指定连接数据库连接池的最小连接数 -->  
  21.         <property name="minPoolSize" value="1"/>  
  22.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  23.         <property name="initialPoolSize" value="1"/>  
  24.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  25.         <property name="maxIdleTime" value="20"/>  
  26.     </bean>  
  27.     <!-- 使用JDBC的局部事务策略 -->  
  28.     <bean id="transactionManager"  
  29.         class="org.springframework.jdbc.datasource.DataSource-  
  30.         TransactionManager">  
  31.         <!-- 为事务管理器注入所需的数据源Bean -->  
  32.         <property name="dataSource" ref="dataSource"/>  
  33.     </bean>  
  34.     <!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->  
  35.     <bean id="userBean" class="org.hnylj.service.impl.UserServiceImpl">  
  36.         <!-- 依赖注入目标Bean所必需的数据源Bean -->  
  37.         <property name="userDAO">    
  38.             <ref bean="userDAO" />    
  39.         </property>    
  40.     </bean>  
  41.   
  42.     <!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->  
  43.     <bean id="personBean" class="org.hnylj.service.impl.PersonServiceImpl">  
  44.         <!-- 依赖注入目标Bean所必需的数据源Bean -->  
  45.         <property name="personDAO">    
  46.             <ref bean="personDAO" />    
  47.         </property>    
  48.     </bean>  
  49.   
  50.     <!-- 配置事务拦截器Bean -->  
  51.     <bean id="transactionInterceptor"  
  52.         class="org.springframework.transaction.interceptor.   
  53.         TransactionInterceptor">  
  54.         <!-- 事务拦截器bean需要依赖注入一个事务管理器 -->  
  55.         <property name="transactionManager" ref="transactionManager"/>  
  56.         <property name="transactionAttributes">  
  57.             <!-- 下面定义事务传播属性 -->  
  58.             <props>  
  59.                 <prop key="insert*">PROPAGATION_REQUIRED</prop>  
  60.                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  61.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  62.             </props>  
  63.         </property>  
  64.     </bean>  
  65.   
  66.     <!-- 定义BeanNameAutoProxyCreator的Bean后处理器 -->  
  67.     <bean class="org.springframework.aop.framework.autoproxy.   
  68.     BeanNameAutoProxyCreator">  
  69.     <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->  
  70.         <property name="beanNames">  
  71.             <!-- 下面是所有需要自动创建事务代理的Bean -->  
  72.             <list>  
  73.                 <value>userBean</value>  
  74.                 <value>personBean</value>  
  75.             </list>  
  76.             <!-- 此处可增加其他需要自动创建事务代理的Bean -->  
  77.         </property>  
  78.         <!-- 下面定义BeanNameAutoProxyCreator所需的拦截器 -->  
  79.         <property name="interceptorNames">  
  80.             <list>  
  81.                 <value>transactionInterceptor</value>   
  82.                 <!-- 此处可增加其他新的Interceptor -->  
  83.             </list>  
  84.         </property>  
  85.     </bean>  
  86. </beans>  

如果配置文件中仅有两个目标Bean，可能不能很清楚地看出这种自动创建代理配置方式的优势，但如果有更多目标Bean需要自动创建事务代理，则可以很好地体会到这种配置方式的优势：配置文件只需要简单地配置目标Bean，然后在BeanNameAutoProxyCreator配置中增加一行即可。

 

对于第四种：DefaultAdvisorAutoProxyCreator：
这种配置方式与BeanNameAutoProxyCreator自动创建代理的方式非常相似，都是使用bean后处理器为目标bean生成事务代理，区别是前者使用事务拦截器创建代理，后者需要使用Advisor创建事务代理。事实上，采用DefaultAdvisorAutoProxyCreator的事务代理配置方式更加简洁，这个代理生成器自动搜索Spring容器中的Advisor，并为容器中所有的bean创建代理。相对前一种方式，这种方式的可读性不如前一种直观。
使用DefaultAdvisorAutoProxyCreator的配置方式：

[xml]   view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->  
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans          
  6. http://www.springframework.org/schema/beans/spring-beans.xsd">  
  7. <!-- 定义数据源Bean，使用C3P0数据源实现 -->  
  8.     <bean id="dataSource" class="com.mchange.v2.c3p0.   
  9.     ComboPooledDataSource" destroy-method="close">  
  10.         <!-- 指定连接数据库的驱动 -->  
  11.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  12.         <!-- 指定连接数据库的URL -->  
  13.         <property name="jdbcUrl" value="jdbc:mysql:3306/127.0.0.1/ssh"/>  
  14.         <!-- 指定连接数据库的用户名 -->  
  15.         <property name="user" value="root"/>  
  16.         <!-- 指定连接数据库的密码 -->  
  17.         <property name="password" value="123"/>  
  18.         <!-- 指定连接数据库连接池的最大连接数 -->  
  19.         <property name="maxPoolSize" value="40"/>  
  20.         <!-- 指定连接数据库连接池的最小连接数 -->  
  21.         <property name="minPoolSize" value="1"/>  
  22.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  23.         <property name="initialPoolSize" value="1"/>  
  24.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  25.         <property name="maxIdleTime" value="20"/>  
  26.     </bean>  
  27.     <!--定义一个hibernate的SessionFactory-->  
  28. <bean id="sessionFactory"  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  29.         <!--   定义SessionFactory必须注入DataSource-->  
  30.             <property name="dataSource"><ref local="dataSource"/></property>  
  31.             <property name="mappingResources">  
  32.             <list>  
  33.                 <!--列出所有的PO映射文件-->  
  34.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  35.             </list>  
  36.             </property>  
  37.             <property name="hibernateProperties">  
  38.             <props>  
  39. <!--定义hibernate的SessionFactory的属性-->  
  40.             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
  41.             </props>  
  42.         </property>  
  43.     </bean>  
  44.     <!-- 定义hibernate的局部事务管理器-->  
  45. <bean id="transactionManager"  
  46.          class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  47.             <!-- 注入SessionFactory bean的引用-->  
  48.             <property name="sessionFactory"><ref local="sessionFactory"/></property>  
  49. </bean>  
  50.     <!--   配置事务拦截器-->  
  51. <bean id="transactionInterceptor"  
  52. class="org.springframework.transaction.interceptor.TransactionInterceptor">  
  53.         <!--   事务拦截器bean需要依赖注入一个事务管理器 -->  
  54.         <property name="transactionManager" ref="transactionManager"/>  
  55.         <property name="transactionAttributes">  
  56.             <!--   下面定义事务传播属性-->  
  57.             <props>  
  58.                 <prop key="insert*">PROPAGATION_REQUIRED</prop>  
  59.                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  60.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  61.             </props>  
  62.         </property>  
  63. </bean>  
  64.     <!-- 定义事务Advisor-->  
  65. <bean  class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">  
  66.         <!--   定义advisor时，必须传入Interceptor-->  
  67.             <property name="transactionInterceptor" ref="transactionInterceptor"/>  
  68.     </bean>  
  69.     <!-- DefaultAdvisorAutoProxyCreator搜索容器中的 advisor,并为每个bean创建代理 -->  
  70. <bean  class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>  
  71. <!--定义DAO Bean ,由BeanNameAutoProxyCreator自动生成事务代理-->  
  72.     <bean id="userService" class="org.hnylj.service.impl.UserServiceImpl">  
  73.         <property name="userDAO"><ref local="userDAO"/></property>  
  74. </bean>  
  75. </beans>    

你可能感兴趣的:(spring事务管理)

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java开发语言
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
  • spring mvc @RequestBody String类型参数 zoyation spring-mvcspringmvc
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
  • Java -jar 如何在后台运行项目 vincent_hahaha
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
  • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架 叶准鑫Natalie
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台 网顺技术团队 成品程序项目javavue.js汽车课程设计springboot
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
  • 分布式锁和spring事务管理 暴躁的鱼 锁及事务分布式springjava
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
  • Java面试笔记记录6 今天背八股了吗 java面试笔记
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
  • Sentinel 眼泪落在琴弦 springcloudjavajava
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
  • Spring @Async 深度解读：默认线程池执行器的配置与优化 小码快撩 springjava前端
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
  • Sentinel实时监控不展示问题 朱杰jjj sentinelsentinel
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？ 这孩子叫逆 Mybatis笔记mybatis数据库
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算 码踏云端 springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
  • Spring Security静态资源过滤（11） 小黑屋说YYDS spring
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
  • Spring Security定义多个过滤器链（10） 小黑屋说YYDS spring
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
  • java 技术 架构 相关文档 圣心 java架构开发语言
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
  • SpringSecurity初学总结 weixin_66442229 spring
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式 花儿街参考
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
  • SpringBoot 设置传入参数非必要 loveLifeLoveCoding springbootspringbootjavaspring
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
  • SpringBoot 获取 ApplicationContext loveLifeLoveCoding springbootspringbootjavaspring
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
  • java打印标签（机型TOSHIBA条码打印机B-EX4T）  嘘  JAVAjava
    java打印标签实现方式标签效果代码获取更多相关资料实现rfid写入功能实现方式打印机设置网络ipjava获取socket连接，调用TPCL指令标签效果代码packageorg.jeecg.modules.invinfo.util;importorg.jeecg.modules.invinfo.vo.BatKcInventoryDetailVo;importorg.springframework.
  • Linux的Initrd机制 被触发 linux
    Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
  • maven本地仓库路径修改 bitcarter maven
    默认maven本地仓库路径：C:\Users\Administrator\.m2 修改maven本地仓库路径方法：     1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml     2.找到        
  • XSD和XML中的命名空间 darrenzhu xmlxsdschemanamespace命名空间
    http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml http://blog.csdn.net/wanghuan203/article/details/9203621 http://blog.csdn.net/wanghuan203/article/details/9204337 http://www.cn
  • Java 求素数运算 周凡杨 java算法素数
    网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。 第一种：   原理: 6N(+-)1法         任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)   
  • java 单例模式 g21121 java
    想必单例模式大家都不会陌生，有如下两种方式来实现单例模式：   class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; }
  • Linux下Mysql源码安装 510888780 mysql
    1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz (1)创建mysql的安装目录及数据库存放目录       解压缩下载的源码包，目录结构，特殊指定的目录除外：           
  • 32位和64位操作系统 墙头上一根草 32位和64位操作系统
    32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
  • 我的spring学习笔记10-轻量级_Spring框架 aijuans Spring 3
    一、问题提问：     → 请简单介绍一下什么是轻量级？     轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。  
  • mongodb 环境搭建及简单CURD antlove WebInstallcurdNoSQLmongo
    一 搭建mongodb环境 1. 在mongo官网下载mongodb 2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
  • 数据字典和动态视图 百合不是茶 oracle数据字典动态视图系统和对象权限
    数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含   数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 数据库为一
  • 多线程编程一般规则 bijian1013 javathread多线程java多线程
           如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。        不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。
  • 将文件或目录拷贝到另一个Linux系统的命令scp bijian1013 linuxunixscp
    一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
  • 【持久化框架MyBatis3五】MyBatis3一对多关联查询 bit1129 Mybatis3
    以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。   示例数据：   地址表：   CREATE TABLE ADDRESSES ( ADDR_ID INT(11) NOT NULL AUTO_INCREMENT, STREET VAR
  • cookie状态判断引发的查找问题 bitcarter formcgi
    先说一下我们的业务背景： 1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 2.form中action是一个cgi服务 3.后台cgi服务同时供PC，H5，APP 4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 问题：（折腾两天。。。。） 1.PC端cgi服务正常调用，cookie判断没
  • 通过Nginx,Tomcat访问日志(access log)记录请求耗时 ronin47
    一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 nginx.conf使用配置方式： log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
  • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 bylijinnan java
    public class ProbabilityOfDice { /** * Q67 n个骰子的点数 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 * 在以下求解过程中，我们把骰子看作是有序的。 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况 */ private stati
  • 看别人的博客，觉得心情很好 Cb123456 博客心情
       以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客:    职业规划:    http://www.iteye.com/blogs/subjects/zhiyeguihua      android学习:    1.http://byandby.i
  • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析 comsci 工作流
        我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误      在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
  • JS常用的事件及方法 cwqcwqmax9 js
    事件 描述 onactivate 当对象设置为活动元素时触发。 onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 onbeforeactivate 对象要被设置为当前元素前立即触发。 onbeforecut 当选中区从文档中删除之前在源对象触发。 onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
  • 正则表达式验证日期格式 dashuaifu 正则表达式IT其它java其它
    正则表达式验证日期格式 function isDate(d){ var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i); if(!v) { this.focus(); return false; } } <input value="2000-8-8" onblu
  • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证 dcj3sjt126com yii
    public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation
  • UITextAttributeTextColor = deprecated in iOS 7.0 dcj3sjt126com ios
    In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." Ins
  • 判断一个数是质数的几种方法 EmmaZhao Mathpython
    质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 判断一个数是质数的最简单的方法如下： def isPrime1(n): for i in range(2, n): if n % i == 0: return False return True 但是在上面的方法中有一些冗余的计算，所以
  • SpringSecurity工作原理小解读 坏我一锅粥 SpringSecurity
      SecurityContextPersistenceFilter   ConcurrentSessionFilter   WebAsyncManagerIntegrationFilter   HeaderWriterFilter   CsrfFilter   LogoutFilter   Use
  • JS实现自适应宽度的Tag切换 ini JavaScripthtmlWebcsshtml5
    效果体验：http://hovertree.com/texiao/js/3.htm   该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 HTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"
  • Hbase Rest API : 数据查询 kane_xie RESThbase
    hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。   启动命令：./bin/hbase rest s
  • JQuery实现鼠标拖动元素移动位置（源码+注释） 明子健 jqueryjs源码拖动鼠标
    欢迎讨论指正！   print.html代码： <!DOCTYPE html> <html> <head> <meta http-equiv=Content-Type content="text/html;charset=utf-8"> <title>发票打印</title> &l
  • Postgresql 连表更新字段语法 update qifeifei PostgreSQL
    下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： UPDATE tops_visa.visa_order SET op_audit_abort_pass_date = now() FROM tops_visa.visa_order as t1 INNER JOIN tops_visa.visa_visitor as t2 ON t1.
  • 将redis,memcache结合使用的方案? tcrct rediscache
    公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
  • 开发中遇到的诡异的bug wudixiaotie bug
    今天我们服务器组遇到个问题： 我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他