Spring事务管理的两种方式

于 2011-11-03 23:42:21 发布
阅读量1k 收藏
点赞数
分类专栏： spring 文章标签： spring user delete aop object encoding
 

原文链接: http://javacrazyer.iteye.com/blog/794748

目前项目开发过程中对于Spring的事务管理，主要就这么两种方式：XML配置方式和注解方式

在平时开发中，Spring团队建议使用注解的方式进行配置，这样配置文件显得精简，同时也会做到精确控制。

 

注解方式

必须包



 User.java

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">package com.javacrazyer.spring.bean;   
  2.   
  3. public class User   
  4. {   
  5.     private int id;   
  6.     private String username;   
  7.     public int getId()   
  8.     {   
  9.         return id;   
  10.     }   
  11.     public void setId(int id)   
  12.     {   
  13.         this.id = id;   
  14.     }   
  15.     public String getUsername()   
  16.     {   
  17.         return username;   
  18.     }   
  19.     public void setUsername(String username)   
  20.     {   
  21.         this.username = username;   
  22.     }   
  23. }   
  24. </SPAN>  
package com.javacrazyer.spring.bean;

public class User
{
	private int id;
	private String username;
	public int getId()
	{
		return id;
	}
	public void setId(int id)
	{
		this.id = id;
	}
	public String getUsername()
	{
		return username;
	}
	public void setUsername(String username)
	{
		this.username = username;
	}
}

 这个user在mysql中肯定是要创建的

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">create table users   
  2. (                      
  3.  id int(11) not null auto_increment,     
  4.  username varchar(20) not null,          
  5.  primary key (id)                      
  6. ) </SPAN>  
create table users
(                   
 id int(11) not null auto_increment,  
 username varchar(20) not null,       
 primary key (id)                   
)

 

    UserDAO.java类

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">package com.javacrazyer.spring.dao;   
  2.   
  3. import java.util.List;   
  4.   
  5. import com.javacrazyer.spring.bean.User;   
  6.   
  7. public interface UserDAO   
  8. {   
  9.     public void save(User user);   
  10.     public void update(User user);   
  11.     public User getUser(int id);   
  12.     public void delete(int id);   
  13.     public List<User> getAllUsers();   
  14. }   
  15. </SPAN>  
package com.javacrazyer.spring.dao;

import java.util.List;

import com.javacrazyer.spring.bean.User;

public interface UserDAO
{
	public void save(User user);
	public void update(User user);
	public User getUser(int id);
	public void delete(int id);
	public List<User> getAllUsers();
}

  UserRowMapper类

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">package com.javacrazyer.spring.dao.impl;   
  2.   
  3. import java.sql.ResultSet;   
  4. import java.sql.SQLException;   
  5.   
  6. import org.springframework.jdbc.core.RowMapper;   
  7.   
  8. import com.javacrazyer.spring.bean.User;   
  9.   
  10. public class UserRowMapper implements RowMapper {   
  11.   
  12.     public Object mapRow(ResultSet rs, int index) throws SQLException {   
  13.         User user = new User();   
  14.         user.setUsername(rs.getString("username"));   
  15.         user.setId(rs.getInt("id"));   
  16.         return user;   
  17.     }   
  18. }   
  19. </SPAN>  
package com.javacrazyer.spring.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

import com.javacrazyer.spring.bean.User;

public class UserRowMapper implements RowMapper {

	public Object mapRow(ResultSet rs, int index) throws SQLException {
		User user = new User();
		user.setUsername(rs.getString("username"));
		user.setId(rs.getInt("id"));
		return user;
	}
}

 

UserDAOImpl.java具体实现类

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">package com.javacrazyer.spring.dao.impl;   
  2.   
  3. import java.util.List;   
  4.   
  5. import javax.sql.DataSource;   
  6.   
  7. import org.springframework.jdbc.core.JdbcTemplate;   
  8. import org.springframework.transaction.annotation.Propagation;   
  9. import org.springframework.transaction.annotation.Transactional;   
  10.   
  11. import com.javacrazyer.spring.bean.User;   
  12. import com.javacrazyer.spring.dao.UserDAO;   
  13.   
  14.   
  15. @Transactional  
  16. public class UserDAOImpl implements UserDAO   
  17. {   
  18.     //private DataSource dataSource;   
  19.     private JdbcTemplate jdbcTemplate;   
  20.     public void setDataSource(DataSource dataSource)   
  21.     {   
  22.         //this.dataSource = dataSource;   
  23.         this.jdbcTemplate=new JdbcTemplate(dataSource);   
  24.     }   
  25.   
  26.     public void delete(int id)   
  27.     {   
  28.         jdbcTemplate.update("delete from users where id=?", new Object[]{id},   
  29.                 new int[]{java.sql.Types.INTEGER});   
  30.         //jdbcTemplate.update("delete from users1 where id=10");   
  31.     }   
  32.   
  33.     public List<User> getAllUsers()   
  34.     {   
  35.         return (List<User>)jdbcTemplate.query("select * from users", new UserRowMapper());   
  36.     }   
  37.        
  38.     @Transactional(propagation=Propagation.NOT_SUPPORTED)     
  39.     public User getUser(int id)   
  40.     {   
  41.         return (User)jdbcTemplate.queryForObject("select * from users where id=?", new Object[]{id},    
  42.                 new int[]{java.sql.Types.INTEGER}, new UserRowMapper());   
  43.   
  44.     }   
  45.   
  46.     public void save(User user)   
  47.     {    
  48.         jdbcTemplate.update("insert into users(username) values(?)", new Object[]{user.getUsername()},   
  49.                 new int[]{java.sql.Types.VARCHAR});   
  50.   
  51.     }   
  52.   
  53.     public void update(User user)   
  54.     {   
  55.         jdbcTemplate.update("update users set username=? where id=?", new Object[]{user.getUsername(),user.getId()},   
  56.                 new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});   
  57.   
  58.     }   
  59.   
  60. }   
  61. </SPAN>  
package com.javacrazyer.spring.dao.impl;

import java.util.List;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.javacrazyer.spring.bean.User;
import com.javacrazyer.spring.dao.UserDAO;


@Transactional
public class UserDAOImpl implements UserDAO
{
	//private DataSource dataSource;
	private JdbcTemplate jdbcTemplate;
	public void setDataSource(DataSource dataSource)
	{
		//this.dataSource = dataSource;
		this.jdbcTemplate=new JdbcTemplate(dataSource);
	}

	public void delete(int id)
	{
		jdbcTemplate.update("delete from users where id=?", new Object[]{id},
				new int[]{java.sql.Types.INTEGER});
		//jdbcTemplate.update("delete from users1 where id=10");
	}

	public List<User> getAllUsers()
	{
		return (List<User>)jdbcTemplate.query("select * from users", new UserRowMapper());
	}
	
	@Transactional(propagation=Propagation.NOT_SUPPORTED)  
	public User getUser(int id)
	{
		return (User)jdbcTemplate.queryForObject("select * from users where id=?", new Object[]{id}, 
				new int[]{java.sql.Types.INTEGER}, new UserRowMapper());

	}

	public void save(User user)
	{ 
		jdbcTemplate.update("insert into users(username) values(?)", new Object[]{user.getUsername()},
				new int[]{java.sql.Types.VARCHAR});

	}

	public void update(User user)
	{
		jdbcTemplate.update("update users set username=? where id=?", new Object[]{user.getUsername(),user.getId()},
				new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});

	}

}

 

最后的测试类

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">package com.javacrazyer.spring.test;   
  2.   
  3. import org.junit.Before;   
  4. import org.junit.Test;   
  5. import org.springframework.context.ApplicationContext;   
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  7. import org.springframework.transaction.annotation.Transactional;   
  8.   
  9. import com.javacrazyer.spring.bean.User;   
  10. import com.javacrazyer.spring.dao.UserDAO;   
  11.   
  12.   
  13. @Transactional  
  14. public class UserDAOImplTest   
  15. {   
  16.     UserDAO userDAO;   
  17.        
  18.     @Before  
  19.     public void init()   
  20.     {   
  21.         try {   
  22.             ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");   
  23.             userDAO= (UserDAO) cxt.getBean("userDAO");   
  24.         } catch (RuntimeException e) {   
  25.             e.printStackTrace();   
  26.         }   
  27.   
  28.     }   
  29.     @Test  
  30.     public void testDelete()   
  31.     {   
  32.         userDAO.delete(11);   
  33.     }   
  34.   
  35.     @Test  
  36.     public void testGetAllUsers()   
  37.     {   
  38.         for(User user : userDAO.getAllUsers()){   
  39.             System.out.println(user.getUsername());   
  40.         }   
  41.   
  42.     }   
  43.   
  44.     @Test  
  45.     public void testGetUser()   
  46.     {   
  47.         User user = userDAO.getUser(1);   
  48.         System.out.println(user.getUsername());   
  49.   
  50.     }   
  51.   
  52.     @Test  
  53.     public void testSave()   
  54.     {   
  55.         for(int i=0; i<5; i++)   
  56.         {   
  57.             User user=new User();   
  58.             user.setUsername("coolszy"+i);   
  59.             userDAO.save(user);   
  60.         }   
  61.     }   
  62.   
  63.     @Test  
  64.     public void testUpdate()   
  65.     {   
  66.         User user=userDAO.getUser(1);   
  67.         user.setUsername("kuka");   
  68.         userDAO.update(user);   
  69.   
  70.     }   
  71.   
  72. }   
  73. </SPAN>  
package com.javacrazyer.spring.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.transaction.annotation.Transactional;

import com.javacrazyer.spring.bean.User;
import com.javacrazyer.spring.dao.UserDAO;


@Transactional
public class UserDAOImplTest
{
	UserDAO userDAO;
	
	@Before
	public void init()
	{
		try {
			ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
			userDAO= (UserDAO) cxt.getBean("userDAO");
		} catch (RuntimeException e) {
			e.printStackTrace();
		}

	}
	@Test
	public void testDelete()
	{
		userDAO.delete(11);
	}

	@Test
	public void testGetAllUsers()
	{
		for(User user : userDAO.getAllUsers()){
			System.out.println(user.getUsername());
		}

	}

	@Test
	public void testGetUser()
	{
		User user = userDAO.getUser(1);
		System.out.println(user.getUsername());

	}

	@Test
	public void testSave()
	{
		for(int i=0; i<5; i++)
		{
			User user=new User();
			user.setUsername("coolszy"+i);
			userDAO.save(user);
		}
	}

	@Test
	public void testUpdate()
	{
		User user=userDAO.getUser(1);
		user.setUsername("kuka");
		userDAO.update(user);

	}

}

   Spring的applicationContext.xml的配置

Xml代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium"><?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" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  6.                 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
  7.                 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
  8.                 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  9. <!--这里占位符配置可以配置在一个占位符类bean，也可以全局配置一句话就行  -->  
  10.     <context:property-placeholder location="classpath:jdbc.properties" />  
  11. <!-- <bean id="propertyConfigurer"-->  
  12. <!--     class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">-->  
  13. <!--     <property name="location" value="/WEB-INF/jdbc.properties" />-->  
  14. <!-- </bean>-->  
  15.   
  16.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"  
  17.         destroy-method="close">  
  18.         <property name="driverClassName" value="${driverClassName}" />  
  19.         <property name="url" value="${url}" />  
  20.         <property name="username" value="${username}" />  
  21.         <property name="password" value="${password}" />  
  22.         <!-- 连接池启动时的初始值 -->  
  23.         <property name="initialSize" value="${initialSize}" />  
  24.         <!-- 连接池的最大值 -->  
  25.         <property name="maxActive" value="${maxActive}" />  
  26.         <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
  27.         <property name="maxIdle" value="${maxIdle}" />  
  28.         <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
  29.         <property name="minIdle" value="${minIdle}" />  
  30.     </bean>  
  31.        
  32.      <!--spring事务管理器 -->  
  33.     <bean id="txManager"  
  34.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  35.         <!-- 指定数据源 -->  
  36.         <property name="dataSource" ref="dataSource" />  
  37.     </bean>  
  38.      <!--开启对注解的支持    -->  
  39.     <tx:annotation-driven transaction-manager="txManager" />  
  40.   
  41.     <bean id="userDAO" class="com.szy.spring.dao.impl.UserDAOImpl">  
  42.         <property name="dataSource" ref="dataSource" />  
  43.     </bean>  
  44. </beans>  
  45. </SPAN>  
<?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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<!--这里占位符配置可以配置在一个占位符类bean，也可以全局配置一句话就行	-->
	<context:property-placeholder location="classpath:jdbc.properties" />
<!--	<bean id="propertyConfigurer"-->
<!--		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">-->
<!--		<property name="location" value="/WEB-INF/jdbc.properties" />-->
<!--	</bean>-->

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
		<!-- 连接池启动时的初始值 -->
		<property name="initialSize" value="${initialSize}" />
		<!-- 连接池的最大值 -->
		<property name="maxActive" value="${maxActive}" />
		<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		<property name="maxIdle" value="${maxIdle}" />
		<!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		<property name="minIdle" value="${minIdle}" />
	</bean>
	
     <!--spring事务管理器	-->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 指定数据源 -->
		<property name="dataSource" ref="dataSource" />
	</bean>
     <!--开启对注解的支持	-->
	<tx:annotation-driven transaction-manager="txManager" />

	<bean id="userDAO" class="com.szy.spring.dao.impl.UserDAOImpl">
		<property name="dataSource" ref="dataSource" />
	</bean>
</beans>

 jdbc.properties

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">driverClassName=com.mysql.jdbc.Driver   
  2. url=jdbc:mysql://127.0.0.1:3306/test   
  3. username=root   
  4. password=root   
  5. initialSize=1  
  6. maxActive=100  
  7. maxIdle=2  
  8. minIdle=1  
  9. </SPAN>  
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/test
username=root
password=root
initialSize=1
maxActive=100
maxIdle=2
minIdle=1

在注解方式编写测试代码，代码运行正常。

在我们实现的每个方法中如delete()方法，如果delete方法是这样

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">public void delete(int id)   
  2.     {   
  3.         jdbcTemplate.update("delete from users where id=?", new Object[]{id},   
  4.                 new int[]{java.sql.Types.INTEGER});   
  5. jdbcTemplate.update("delete from users where id=?", new Object[]{id},   
  6.                 new int[]{java.sql.Types.INTEGER});   
  7.   
  8.     }   
  9.     </SPAN>  
public void delete(int id)
	{
		jdbcTemplate.update("delete from users where id=?", new Object[]{id},
				new int[]{java.sql.Types.INTEGER});
jdbcTemplate.update("delete from users where id=?", new Object[]{id},
				new int[]{java.sql.Types.INTEGER});

	}

 

 这样每条语句都会在各自的事务中执行，并不能保证在同一使用中执行，为了保证在同一事务中执行，我们应使用Spring容器提供的声明事务，我们在UserDAOImpl 类上加入@Transactional，表示该类受Spring事务管理。如果该类中每个方法不需要事务管理，如getUser方法，则在该方法前加入

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">@Transactional(propagation=Propagation.NOT_SUPPORTED)</SPAN>  
@Transactional(propagation=Propagation.NOT_SUPPORTED)

  

XML配置方式

 必须包



 这里就UserDAOImpl.java，applicationContext.xml与上边不同

 UserDAOImpl.java就是去掉了所有@Transactional的注解

 applictionContext.xml有稍微大些的变化

Xml代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium"><?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.     xmlns:context="http://www.springframework.org/schema/context"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  8.                 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
  9.                 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
  10.                 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  11.         <context:property-placeholder location="classpath:jdbc.properties"/>  
  12.         <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  13.             <property name="driverClassName" value="${driverClassName}"/>  
  14.             <property name="url" value="${url}"/>  
  15.             <property name="username" value="${username}"/>  
  16.             <property name="password" value="${password}"/>  
  17.             <!-- 连接池启动时的初始值 -->  
  18.             <property name="initialSize" value="${initialSize}"/>  
  19.             <!-- 连接池的最大值 -->  
  20.             <property name="maxActive" value="${maxActive}"/>  
  21.             <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
  22.             <property name="maxIdle" value="${maxIdle}"/>  
  23.             <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
  24.             <property name="minIdle" value="${minIdle}"/>  
  25.         </bean>  
  26.            
  27.         <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  28.             <!-- 指定数据源 -->  
  29.             <property name="dataSource" ref="dataSource"/>  
  30.         </bean>  
  31.            
  32.         <aop:config>  
  33.             <aop:pointcut id="transactionPointcut" expression="execution(* com.szy.spring.dao.impl..*.*(..))"/>  
  34.             <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>  
  35.         </aop:config>    
  36.         <tx:advice id="txAdvice" transaction-manager="txManager">  
  37.               <tx:attributes>  
  38.                 <!-- 如果方法是以get开头，能不进行事务管理 -->  
  39.                 <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>  
  40.                 <tx:method name="*"/>  
  41.               </tx:attributes>  
  42.         </tx:advice>  
  43.            
  44.            
  45.         <bean id="userDAO" class="com.szy.spring.dao.impl.UserDAOImpl">  
  46.             <property name="dataSource" ref="dataSource"/>  
  47.         </bean>  
  48. </beans>  
  49. </SPAN>  
<?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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
		<context:property-placeholder location="classpath:jdbc.properties"/>
		<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		    <property name="driverClassName" value="${driverClassName}"/>
		    <property name="url" value="${url}"/>
		    <property name="username" value="${username}"/>
		    <property name="password" value="${password}"/>
			<!-- 连接池启动时的初始值 -->
			<property name="initialSize" value="${initialSize}"/>
			<!-- 连接池的最大值 -->
			<property name="maxActive" value="${maxActive}"/>
			<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
			<property name="maxIdle" value="${maxIdle}"/>
			<!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
			<property name="minIdle" value="${minIdle}"/>
	 	</bean>
	 	
	 	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  	   		<!-- 指定数据源 -->
  	   		<property name="dataSource" ref="dataSource"/>
    	</bean>
    	
		<aop:config>
		 	<aop:pointcut id="transactionPointcut" expression="execution(* com.szy.spring.dao.impl..*.*(..))"/>
		 	<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
		</aop:config> 
		<tx:advice id="txAdvice" transaction-manager="txManager">
			  <tx:attributes>
			  	<!-- 如果方法是以get开头，能不进行事务管理 -->
			    <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
			    <tx:method name="*"/>
			  </tx:attributes>
		</tx:advice>
		
		
		<bean id="userDAO" class="com.szy.spring.dao.impl.UserDAOImpl">
			<property name="dataSource" ref="dataSource"/>
		</bean>
</beans>

 

这里没有了注解支持，而是配成了tx标签开头的声明式事务管理方式，基于aspectJ的配置

 

下面我们测试下数据库操作是否在同一事务中执行。

假设我们的delete方法如下：

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">public void delete(int id)   
  2.  {   
  3.   jdbcTemplate.update("delete from users where id=?", new Object[]{id},   
  4.     new int[]{java.sql.Types.INTEGER});   
  5.   jdbcTemplate.update("delete from users1 where id=10");   
  6.  }</SPAN>  
public void delete(int id)
 {
  jdbcTemplate.update("delete from users where id=?", new Object[]{id},
    new int[]{java.sql.Types.INTEGER});
  jdbcTemplate.update("delete from users1 where id=10");
 }

 

在第二条删除语句中，users1表是不存在的，如果两次update语句是在两个事务中执行，则第一条能成功执行，并且数据库中该id的记录已经被删除，而第二条由于不存在该表不能正常删除。如果在同一事务中执行，由于第二条update出错，数据库中不能删除任何记录。

   测试代码

Java代码 复制代码  收藏代码
  1. <SPAN style="FONT-SIZE: medium">@Test  
  2.  public void testDelete()   
  3.  {   
  4.   userDAO.delete(5);   
  5.  }</SPAN>  
@Test
 public void testDelete()
 {
  userDAO.delete(5);
 }

 

程序报错，同时id=5的记录没有被删除。如果我们把配置文件中关于事务配置的信息给注释掉，再次测试，程序同样报错，但是id=5的记录被成功删除掉，这说明这两条update语句是在两个不同的事务中运行。

    所以配置事务就是保证，无论方法中有多少条更新语句，那么我只要保证整个方法在同一个事务中执行就OK

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值