纯干货！Spring4 简单教程3

一、 Spring 对 JDBC 的支持

1.  JdbcTemplate 简介

• 为了使 JDBC 更加易于使用, Spring 在 JDBC API 上定义了一个抽象层, 以此建立一个 JDBC 存取框架.

• 作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低.

  
  

2.  JdbcTemplate主要提供以下五类方法：

• execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；

• update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；

• query方法及queryForXXX方法：用于执行查询相关语句；

• call方法：用于执行存储过程、函数相关语句

示例

applicationContext.xml:

<?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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
	<!-- 导入配置文件 -->
	<context:property-placeholder location="classpath:db.properties"/>
	
	<!-- 配置C3P0数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.user}"/>
		<property name="password" value="${jdbc.password}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="driverClass" value="${jdbc.driver}"/>
		<property name="initialPoolSize" value="${jdbc.initialPoolSize}"/>
		<property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>
	</bean>
	
	<!-- 配置Spring的JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>
</beans>

JDBCTest:

import java.util.ArrayList;
import java.util.List;

import me.ziry.model.User;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public class JDBCTest {

	private ApplicationContext ctx = null;
	private JdbcTemplate jdbcTemplate = null;
	
	{
		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		jdbcTemplate = (JdbcTemplate)ctx.getBean("jdbcTemplate");
	}

	/**
	 *  int org.springframework.jdbc.core.JdbcTemplate.update(String sql, Object... args) 
	 *  throws DataAccessException
	 *  方法用于执行新增、修改、删除等语句
	 */
	@Test
	public void testUpdate() {
		//新增
		String insert = "insert into user(name,age) values(?,?)";
		jdbcTemplate.update(insert, "ziry", 24);
		
		//修改
		String update = "update user set name=? where id=?";
		jdbcTemplate.update(update, "zirylee", 1);
		
		//删除
		String delete = "delete from user where id=?";
		jdbcTemplate.update(delete, 1);
	}
	
	/**
	 * int[] org.springframework.jdbc.core.JdbcTemplate.batchUpdate(String sql, List<Object[]> batchArgs)
	 * 方法用于执行批量的新增、修改、删除
	 */
	@Test
	public void testBatchUpdate() {
		String sql = "insert into user(name,age) values(?,?)";
		List<Object[]> batchArgs = new ArrayList<Object[]>();
		batchArgs.add( new Object[]{"aaa",25} );
		batchArgs.add( new Object[]{"bbb",12} );
		jdbcTemplate.batchUpdate(sql, batchArgs);
	}
	
	/**
	 * T org.springframework.jdbc.core.JdbcTemplate.queryForObject(String sql, RowMapper<T> rowMapper, Object... args) throws DataAccessException
	 * 从数据库中获取一条记录, 实际得到对应的一个对象
	 * 1. 其中的 RowMapper 指定如何去映射结果集的行, 常用的实现类为 BeanPropertyRowMapper
	 * 2. 使用 SQL 中列的别名完成列名和类的属性名的映射. 例如 last_name lastName
	 * 3. 不支持级联属性. JdbcTemplate 到底是一个 JDBC 的小工具, 而不是 ORM 框架
	 */
	@Test
	public void testQueryForObject() {
		String sql = "select * from user where id=?";			
		RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);
		System.out.println(jdbcTemplate.queryForObject(sql, rowMapper, 1));
	}
	
	/**
	 * List<T> org.springframework.jdbc.core.JdbcTemplate.query(String sql, RowMapper<T> rowMapper, Object... args) 
	 * throws DataAccessException
	 * 查到实体类的集合
	 * 注意调用的不是 queryForList 方法
	 */
	@Test
	public void testQueryForList() {
		String sql = "select * from user where id > ?";			
		RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);
		System.out.println(jdbcTemplate.query(sql, rowMapper, 1));
	}
	
	/**
	 * <T> Integer org.springframework.jdbc.core.JdbcTemplate.queryForObject(String sql, Class<T> requiredType) 
	 * throws DataAccessException
	 * 获取单个列的值, 或做统计查询
	 */
	@Test
	public void testCount() {
		String sql = "select count(id) from user";			
		System.out.println(jdbcTemplate.queryForObject(sql, Integer.class));
	}
	
}

3.  简化 JDBC 模板查询

• 每次使用都创建一个 JdbcTemplate 的新实例, 这种做法效率很低下.

• JdbcTemplate 类被设计成为线程安全的, 所以可以再 IOC 容器中声明它的单个实例, 并将这个实例注入到所有的 DAO 实例中.

• JdbcTemplate 也利用了 Java 1.5 的特定(自动装箱, 泛型, 可变长度等)来简化开发

• Spring JDBC 框架还提供了一个 JdbcDaoSupport 类来简化 DAO 实现. 该类声明了 jdbcTemplate 属性, 它可以从 IOC 容器中注入, 或者自动从数据源中创建.

实际应用示例UserDao:

import me.ziry.model.User;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
	
	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	public User getUserById(Integer id) {
		String sql = "select * from user where id = ?";
		RowMapper<User> rowMapper = new BeanPropertyRowMapper<User>(User.class);
		return jdbcTemplate.queryForObject(sql, rowMapper, id);
	}
	
}

4. 扩展 JdbcDaoSupport 示例代码（不推荐使用）

import javax.sql.DataSource;

import me.ziry.model.User;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao2 extends JdbcDaoSupport{
	
	@Autowired
	public void setDataSource2(DataSource dataSource){
		setDataSource(dataSource);
	}
	
	public User getUserById(Integer id) {
		String sql = "select * from user where id = ?";
		RowMapper<User> rowMapper = new BeanPropertyRowMapper<User>(User.class);
		return getJdbcTemplate().queryForObject(sql, rowMapper, id);
	}
	
}

5. 在 JDBC 模板中使用具名参数

• 在经典的 JDBC 用法中, SQL 参数是用占位符 ? 表示,并且受到位置的限制. 定位参数的问题在于, 一旦参数的顺序发生变化, 就必须改变参数绑定. 

• 在 Spring JDBC 框架中, 绑定 SQL 参数的另一种选择是使用具名参数(named parameter). 

• 具名参数: SQL 按名称(以冒号开头)而不是按位置进行指定. 具名参数更易于维护, 也提升了可读性. 具名参数由框架类在运行时用占位符取代

• 具名参数只在 NamedParameterJdbcTemplate 中得到支持 

• 在 SQL 语句中使用具名参数时, 可以在一个 Map 中提供参数值, 参数名为键

• 也可以使用 SqlParameterSource 参数

• 批量更新时可以提供 Map 或 SqlParameterSource 的数组

示例：

applicationContext.xml 增加：

<!-- 配置Spring的具名参数NamedParameterJdbcTemplate -->
<bean id="namedParameterJdbcTemplate" 
    class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
    <constructor-arg name="dataSource" ref="dataSource" />
</bean>

Test:

package me.ziry.test;

import java.util.HashMap;
import java.util.Map;

import me.ziry.model.User;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;

public class JDBCTest {

	private ApplicationContext ctx = null;
	private NamedParameterJdbcTemplate namedParameterJdbcTemplate = null;
	
	{
		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		namedParameterJdbcTemplate = ctx.getBean(NamedParameterJdbcTemplate.class);
	}
	
	
	/**
	 * 可以为参数起名字. 
	 * 1. 好处: 若有多个参数, 则不用再去对应位置, 直接对应参数名, 便于维护
	 * 2. 缺点: 较为麻烦. 
	 */
	@Test
	public void testNamedParameterJdbcTemplate() {
		String sql = "insert into user(name,age) values(:name,:age)";
		Map<String,Object> paramMap = new HashMap<String,Object>();
		paramMap.put("name", "LZR");
		paramMap.put("age", 12);
		namedParameterJdbcTemplate.update(sql, paramMap);
	}
	/**
	 * 使用具名参数时, 可以使用 update(String sql, SqlParameterSource paramSource) 方法进行更新操作
	 * 1. SQL 语句中的参数名和类的属性一致!
	 * 2. 使用 SqlParameterSource 的 BeanPropertySqlParameterSource 实现类作为参数. 
	 */
	@Test
	public void testNamedParameterJdbcTemplate2() {
		String sql = "insert into user(name,age) values(:name,:age)";
		User user = new User();
		user.setName("XYZ");
		user.setAge(33);
		SqlParameterSource paramSource = new BeanPropertySqlParameterSource(user);
		namedParameterJdbcTemplate.update(sql, paramSource);
	}

	
}

二、Spring中的事务管理

1. 事务简介

• 事务管理是企业级应用程序开发中必不可少的技术,  用来确保数据的完整性和一致性. 

• 事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用

• 事务的四个关键属性(ACID)

  a)原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.

  b)一致性(consistency): 一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.

  c)隔离性(isolation): 可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.

  d)持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.

2. 事务管理的问题

• 必须为不同的方法重写类似的样板代码

• 这段代码是特定于 JDBC 的, 一旦选择类其它数据库存取技术, 代码需要作出相应的修改

示例：

public void transactionTemplate() {
    Connection conn = null;
        try {
		//得到链接
		conn = dataSource.getConnection();
		//取消自动提交事务
		conn.setAutoCommit(false);
			
		//...业务代码
			
		//提交
		conn.commit();
	} catch (SQLException e) {
		e.printStackTrace();
		if(conn != null) {
			try {
				//回滚事务
				conn.rollback();
			} catch(SQLException E1) {
				E1.printStackTrace();
			}
		}
		hrow new RuntimeException(e);
	} finally {
		if(conn != null) {
			try {
				//关闭链接
				conn.close();
			} catch(SQLException e) {
				e.printStackTrace();
			}
		}
	}
}

3. Spring 中的事务管理

• 作为企业级应用程序框架, Spring 在不同的事务管理 API 之上定义了一个抽象层. 而应用程序开发人员不必了解底层的事务管理 API, 就可以使用 Spring 的事务管理机制.

• Spring 既支持编程式事务管理, 也支持声明式的事务管理. 

• 编程式事务管理: 将事务管理代码嵌入到业务方法中来控制事务的提交和回滚. 在编程式管理事务时, 必须在每个事务操作中包含额外的事务管理代码. 

• 声明式事务管理: 大多数情况下比编程式事务管理更好用. 它将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理. 事务管理作为一种横切关注点, 可以通过 AOP 方法模块化. Spring 通过 Spring AOP 框架支持声明式事务管理.

4. Spring 中的事务管理器

• Spring 从不同的事务管理 API 中抽象了一整套的事务机制. 开发人员不必了解底层的事务 API, 就可以利用这些事务机制. 有了这些事务机制, 事务管理代码就能独立于特定的事务技术了.

• Spring 的核心事务管理抽象是org.springframework.transaction Interface PlatformTransactionManager它为事务管理封装了一组独立于技术的方法. 无论使用 Spring 的哪种事务管理策略(编程式或声明式), 事务管理器都是必须的.

5. Spring 中的事务管理器的不同实现

• org.springframework.jdbc.datasource Class DataSourceTransactionManager:在应用程序中只需要处理一个数据源, 而且通过 JDBC 存取

• org.springframework.transaction.jta Class JtaTransactionManager: 在 JavaEE 应用服务器上用 JTA(Java Transaction API) 进行事务管理

• org.springframework.orm.hibernate3 Class HibernateTransactionManager：用 Hibernate 框架存取数据库

• ……

• 事务管理器以普通的 Bean 形式声明在 Spring IOC 容器中

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
	<property name="dataSource" ref="dataSource" />
</bean>

6. 用事务通知声明式地管理事务

• 事务管理是一种横切关注点

• 为了在 Spring 2.x 中启用声明式事务管理, 可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知, 为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去.

• 声明了事务通知后, 就需要将它与切入点关联起来. 由于事务通知是在 <aop:config> 元素外部声明的, 所以它无法直接与切入点产生关联. 所以必须在 <aop:config> 元素中声明一个增强器通知与切入点关联起来.

• 由于 Spring AOP 是基于代理的方法, 所以只能增强公共方法. 因此, 只有公有方法才能通过 Spring AOP 进行事务管理.

7. 用 @Transactional 注解声明式地管理事务

• 除了在带有切入点, 通知和增强器的 Bean 配置文件中声明事务外, Spring 还允许简单地用 @Transactional 注解来标注事务方法. 

• 为了将方法定义为支持事务处理的, 可以为方法添加 @Transactional 注解. 根据 Spring AOP 基于代理机制, 只能标注公有方法.

• 可以在方法或者类级别上添加 @Transactional 注解. 当把这个注解应用到类上时, 这个类中的所有公共方法都会被定义成支持事务处理的. 

• 在 Bean 配置文件中只需要启用 <tx:annotation-driven> 元素, 并为之指定事务管理器就可以了. 

• 如果事务处理器的名称是 transactionManager, 就可以在<tx:annotation-driven> 元素中省略 transaction-manager 属性. 这个元素会自动检测该名称的事务处理器.

<!-- 扫描组件 -->
<context:component-scan base-package="me.ziry"></context:component-scan>
	
<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

8.事务传播属性

• 当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.

• 事务的传播行为可以由传播属性指定. Spring 定义了 7  种类传播行为.

Spring 支持的事务传播行为

• REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。(常用)

//默认
@Transactional(propagation=Propagation.REQUIRES)
public void test(String username, String bookname) {
....//省略

• REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。 (常用)

@Transactional(propagation=Propagation.REQUIRES_NEW)
public void test(String username, String bookname) {
....//省略

• SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。 

• MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。 

• NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 

• NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

9. 并发事务所导致的问题

• 当同一个应用程序或者不同应用程序中的多个事务在同一个数据集上并发执行时, 可能会出现许多意外的问题

• 并发事务所导致的问题可以分为下面三种类型:

--脏读: 对于两个事物 T1, T2, T1  读取了已经被 T2 更新但 还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是临时且无效的.

--不可重复读:对于两个事物 T1, T2, T1  读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了.

--幻读:对于两个事物 T1, T2, T1  从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 如果 T1 再次读取同一个表, 就会多出几行.

10. 事务的隔离级别

• 从理论上来说, 事务应该彼此完全隔离, 以避免并发事务所导致的问题. 然而, 那样会对性能产生极大的影响, 因为事务必须按顺序运行. 

• 在实际开发中, 为了提升性能, 事务会以较低的隔离级别运行.

• 事务的隔离级别可以通过隔离事务属性指定

11. Spring 支持的事务隔离级别

• DEFAULT:

      使用底层数据库的默认隔离级别，对于大多数数据库来说，默认隔离级别都是READ_COMMITED
  
  

• READ_UNCOMMTTED: 

      允许事务读取未被其他事务提交的变更。脏读，不可重复读和幻读的问题都会出现
  
  

• READ_COMMITED： 

      只允许事务读取已经被其他事务提交的变更。可以避免脏读，但不可重复读和幻读问题仍然可能出现
  
  

• REPEATABLE_READ: 

      确保事务可以多次从一个字段中读取相同的值。在这个事务持续期间，禁止其他事务对这个字段进行更新。可以避免脏读和不可重复读，但幻读的问题仍然存在。
  
  

• SERIALIZABLE: 

      确保事务可以从一个表中读取相同的行。在这个事务持续期间，禁止其他事务对该表执行插入，更新和删除操作，所有并发问题都可以避免，但性能十分低下。

·事务的隔离级别要得到底层数据库引擎的支持, 而不是应用程序或者框架的支持.

·Oracle 支持的 2 种事务隔离级别：READ_COMMITED , SERIALIZABLE

·Mysql 支持 4 中事务隔离级别.

12. 设置隔离事务属性

用 @Transactional 注解声明式地管理事务时可以在 @Transactional 的 isolation 属性中设置隔离级别.

@Transactional(propagation=Propagation.REQUIRES_NEW,
		isolation=Isolation.READ_COMMITTED)
public void test(String username, String bookname) {
....//省略

13. 设置回滚事务属性

• 默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚. 而受检查异常不会.

• 事务的回滚规则可以通过 @Transactional 注解的 rollbackFor 和 noRollbackFor 属性来定义. 这两个属性被声明为 Class[] 类型的, 因此可以为这两个属性指定多个异常类.

--rollbackFor:  遇到时必须进行回滚

--noRollbackFor: 一组异常类，遇到时必须不回滚

@Transactional(propagation=Propagation.REQUIRES_NEW,
		isolation=Isolation.READ_COMMITTED，
		rollbackFor={IOException.class, SQLException.class},
		noRollbackFor=ArithmeticException.class)
public void test(String username, String bookname) {
....//省略

14. 超时和只读属性

• 由于事务可以在行和表上获得锁,  因此长事务会占用资源, 并对整体性能产生影响. 

• 如果一个事物只读取数据但不做修改, 数据库引擎可以对这个事务进行优化.

• 超时事务属性: 事务在强制回滚之前可以保持多久. 这样可以防止长期运行的事务占用资源.

• 只读事务属性: 表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务.

//设置超时和只读事务属性
@Transactional(propagation=Propagation.REQUIRES_NEW,
			isolation=Isolation.READ_COMMITTED,
			readOnly=false,
			timeout=3)
public void test(String username, String bookname) {
....//省略

15. 通过XML方式配置事务

<?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:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
<context:component-scan base-package="me.ziry.spring"></context:component-scan>
	
<!-- 导入资源文件 -->
<context:property-placeholder location="classpath:db.properties"/>
	
<!-- 配置 C3P0 数据源 -->
<bean id="dataSource"
	class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="user" value="${jdbc.user}" />
	<property name="password" value="${jdbc.password}" />
	<property name="jdbcUrl" value="${jdbc.jdbcUrl}" />
	<property name="driverClass" value="${jdbc.driverClass}" />
	<property name="initialPoolSize" value="${jdbc.initPoolSize}" />
	<property name="maxPoolSize" value="${jdbc.maxPoolSize}" />
</bean>
	
<!-- 配置 Spirng 的 JdbcTemplate -->
<bean id="jdbcTemplate" 
	class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"></property>
</bean>
	
<!-- 配置 bean -->
<bean id="bookShopDao" class="me.ziry.spring.BookShopDaoImpl">
	<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
.....
		
<!-- 1. 配置事务管理器 -->
<bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>
	
<!-- 2. 配置事务属性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<tx:attributes>
		<!-- 根据方法名指定事务的属性 -->
		<tx:method name="tset" 
			propagation="REQUIRES_NEW"
			isolation="READ_COMMITTED"
			rollback-for="java.io.IOException,java.sql.SQLException"
			no-rollback-for="java.lang.ArithmeticException"
			imeout="30"
			read-only="true"
			/>
		<tx:method name="get*" read-only="true"/>
		<tx:method name="find*" read-only="true"/>
		<tx:method name="*"/>
	</tx:attributes>
</tx:advice>
	
<!-- 3. 配置事务切入点, 以及把事务切入点和事务属性关联起来 -->
<aop:config>
	<aop:pointcut expression="execution(* com.atguigu.spring.tx.xml.service.*.*(..))" 
			id="txPointCut"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>	
</aop:config>

</beans>

纯干货！Spring4 简单教程 共 4 篇 分别：

• 纯干货！Spring4 简单教程 1

• 纯干货！Spring4 简单教程 2

• 纯干货！Spring4 简单教程 3

• 纯干货！Spring4 简单教程 4

注意：转载请注明出处，谢谢!

注意：本文归作者所有，未经作者允许，不得转载