Spring的声明式事务----Annotation注解方式（1）

这里列一个小的demo工程，直接利用Spring的jdbcTemplate访问Mysql数据库。

工程结构：

数据库中的tbl_student表结构如下：

数据实体类Student.java代码如下：

1. package com.mysrc.entity;
2. import java.sql.Date;
3. public class Student {
4. private int id;
5. private String name;
6. private Date birth;
7. private float score;
8. public Student() {
9. }
10. public int getId() {
11. return id;
12. }
13. public void setId(int id) {
14. this.id = id;
15. }
16. public String getName() {
17. return name;
18. }
19. public void setName(String name) {
20. this.name = name;
21. }
22. public Date getBirth() {
23. return birth;
24. }
25. public void setBirth(Date birth) {
26. this.birth = birth;
27. }
28. public float getScore() {
29. return score;
30. }
31. public void setScore(float score) {
32. this.score = score;
33. }
34. @Override
35. public String toString() {
36. return "Student [id=" + id + ", name=" + name + ", birth=" + birth
37. + ", score=" + score + "]";
38. }
39. }

数据访问类StudentDao.java代码如下：

1. package com.mysrc.dao;
2. import java.util.List;
3. import org.springframework.jdbc.core.JdbcTemplate;
4. import com.mysrc.entity.Student;
5. import com.mysrc.entity.StudentRowMapper;
6. public class StudentDao {
7. private JdbcTemplate jdbcTemplate;
8. public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
9. this.jdbcTemplate = jdbcTemplate;
10. }
11. public Student getStudentById(int id) {
12. return jdbcTemplate.queryForObject(
13. "select * from tbl_student where id = ?", new Object[] { id },
14. new StudentRowMapper());
15. }
16. public List<Student> getAllStudent() {
17. return jdbcTemplate.query("select * from tbl_student",
18. new StudentRowMapper());
19. }
20. public int insertStudent(Student student) {
21. return jdbcTemplate.update(
22. "insert into tbl_student(name,birth,score) values(?,?,?)",
23. new Object[] { student.getName(), student.getBirth(),
24. student.getScore() });
25. }
26. public int deleteStudent(int id) {
27. return jdbcTemplate.update("delete from tbl_student where id = ? ",
28. new Object[] { id });
29. }
30. public int updateStudent(Student student) {
31. return jdbcTemplate.update(
32. " update tbl_student set name=?,birth=?,score=? where id=? ",
33. new Object[] { student.getName(), student.getBirth(),
34. student.getScore(), student.getId() });
35. }
36. }

服务类StudentService.java代码如下：

1. package com.mysrc.service;
2. import java.sql.Date;
3. import java.util.List;
4. import org.springframework.transaction.annotation.Isolation;
5. import org.springframework.transaction.annotation.Propagation;
6. import org.springframework.transaction.annotation.Transactional;
7. import com.mysrc.dao.StudentDao;
8. import com.mysrc.entity.Student;
9. public class StudentService {
10. private StudentDao dao;
11. public void setDao(StudentDao dao) {
12. this.dao = dao;
13. }
14. @Transactional(propagation = Propagation.NESTED, timeout = 1000, isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class, noRollbackFor = CustomRuntimeException.class)
15. public void doComplexLogic() {
16. // select
17. List<Student> list = dao.getAllStudent();
18. for (Student student : list) {
19. System.out.println(student);
20. }
21. // update
22. Student student = list.get(0);
23. student.setName("zhejiang");
24. dao.updateStudent(student);
25. System.out.println("did update temporarily...");
26. // int a = 9 / 0; // 遇到异常，整个事务回滚
27. // 如果try catch捕获这个异常，那整个事务会顺利执行，不会回滚
28. int b = 2;
29. if (b > 1) {
30. throw new CustomRuntimeException();
31. // 事务不会回滚，也就是上面的update操作会提交
32. }
33. // insert
34. student = new Student();
35. student.setName("hello");
36. student.setBirth(new Date(354778));
37. student.setScore(78.9f);
38. dao.insertStudent(student);
39. System.out.println("did insert...");
40. // delete
41. dao.deleteStudent(3);
42. System.out.println("did delete...");
43. }
44. class CustomRuntimeException extends RuntimeException {
45. public CustomRuntimeException() {
46. super();
47. }
48. public CustomRuntimeException(String msg) {
49. super(msg);
50. }
51. }
52. }

doComplexLogic()方法模拟一个复杂的数据库操作过程，方法上加上了@Transactional，其中的各个注解的属性后面再详细研究。网上有人说@Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能，这个未验证。

Spring的上下文配置文件applicationContext.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" xmlns:p="http://www.springframework.org/schema/p"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"
5. xmlns:tx="http://www.springframework.org/schema/tx">
6. <bean id="basicDataSource" class="org.apache.commons.dbcp.BasicDataSource">
7. <property name="url"
8. value="jdbc:mysql://127.0.0.1:3306/mytestdb?characterEncoding=utf8" />
9. <property name="driverClassName" value="com.mysql.jdbc.Driver" />
10. <property name="username" value="root" />
11. <property name="password" value="123456" />
12. <property name="maxActive" value="100" />
13. <property name="maxIdle" value="30" />
14. <property name="maxWait" value="1000" />
15. <property name="validationQuery" value="select 1" />
16. </bean>
17. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
18. <constructor-arg name="dataSource" ref="basicDataSource">
19. </constructor-arg>
20. </bean>
21. <bean id="transactionManager"
22. class="org.springframework.jdbc.datasource.DataSourceTransactionManager ">
23. <property name="dataSource">
24. <ref bean="basicDataSource" />
25. </property>
26. </bean>
27. <bean id="studentDao" class="com.mysrc.dao.StudentDao">
28. <property name="jdbcTemplate">
29. <ref bean="jdbcTemplate" />
30. </property>
31. </bean>
32. <bean id="studentService" class="com.mysrc.service.StudentService">
33. <property name="dao">
34. <ref bean="studentDao" />
35. </property>
36. </bean>
37. <tx:annotation-driven transaction-manager="transactionManager" />
38. <!--这句话的作用是注册事务注解处理器 -->
39. </beans>

测试类MyTester.java代码如下：

1. package com.mysrc.test;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.support.ClassPathXmlApplicationContext;
4. import com.mysrc.service.StudentService;
5. public class MyTester {
6. public static void main(String[] args) {
7. ApplicationContext context = new ClassPathXmlApplicationContext(
8. "applicationContext.xml");
9. StudentService studentService = (StudentService) context
10. .getBean("studentService");
11. studentService.doComplexLogic();
12. }
13. }

@Transactional 的所有可选属性如下

属性	类型	默认值	说明
propagation	Propagation枚举	REQUIRED	事务传播属性
isolation	isolation枚举	DEFAULT	事务隔离级别
readOnly	boolean	false	是否只读
timeout	int	-1	超时(秒)
rollbackFor	Class[]	{}	需要回滚的异常类
rollbackForClassName	String[]	{}	需要回滚的异常类名
noRollbackFor	Class[]	{}	不需要回滚的异常类
noRollbackForClassName	String[]	{}	不需要回滚的异常类名

整个eclipse工程代码文件下载地址：

http://dl.iteye.com/topics/download/6c63c292-88e0-33de-91bb-8b0f38d507e3