您的位置：360文档中心› Spring 事务设置

Spring 事务设置

Spring 事务设置
Spring 事务设置

spring2.5的事物管理，分为两种方式，一是基于注解方式的，而是基于配置文件方式的

一。基于注解方式

Java代码

1.import java.util.List;

2.

3.import javax.sql.DataSource;

4.

5.import org.springframework.jdbc.core.JdbcTemplate;

6.import org.springframework.transaction.annotation.Propagation;

7.import org.springframework.transaction.annotation.Transactional;

8.

9.import com.mingbai.bean.StudentBean;

10.import com.mingbai.service.StudentService;

11.

12.//将此业务类交由spring的事务管理，这时此方法的某个方法在执行前就开启事务，结束后提

交事务

13.@Transactional

14.public class StudentServiceImpl implements StudentService {

15.private JdbcTemplate jdbcTemplate;

16.

17.public void setDataSource(DataSource dataSource) {

18.this.jdbcTemplate = new JdbcTemplate(dataSource);

19. }

20.

21./* public void delete(Integer sid) {

22. jdbcTemplate.update("delete from student where id=?",

23. new Object[]{sid}, new int[]{java.sql.Types.INTEGE

R});

24. throw new RuntimeException("我是异常");

25. }*/

26./* @Transactional(rollbackFor=Exception.class)

27. public void delete(Integer sid) throws Exception {

28. jdbcTemplate.update("delete from student where id=?",

29. new Object[]{sid}, new int[]{java.sql.Types.INTEGE

R});

30. throw new Exception("我是异常");

31. }*/

32.@Transactional(noRollbackFor=RuntimeException.class)

33.public void delete(Integer sid) throws Exception {

34. jdbcTemplate.update("delete from student where id=?",

35.new Object[]{sid}, new int[]{java.sql.Types.INTEGER});

36.throw new RuntimeException("我是运行期异常");//运行期例外（uncheck

ed exception）事务默认回滚

37. }

38.

39.@Transactional(propagation=Propagation.NOT_SUPPORTED)

40.public List getAllStudent() {

41.return jdbcTemplate.query("select * from student", new Student

RowMapper());

42. }

43.

44.public StudentBean getStudent(Integer sid) {

45. StudentBean sb = (StudentBean)jdbcTemplate.queryForObject("sel

ect * from student where id=?", new Object[]{sid}, new int[]{java.sql.

Types.INTEGER}, new StudentRowMapper());

46.return sb;

47. }

48.

49.public void save(StudentBean student) {

50. jdbcTemplate.update("insert into student(name,password) values

(?,?)",

51.new Object[]{student.getName(),student.getPassword

()}, new int[]{java.sql.Types.VARCHAR,java.sql.Types.VARCHAR});

52. }

53.

54.public void update(StudentBean student) {

55. jdbcTemplate.update("update student set name=? where id=?

",

56.new Object[]{student.getName(),5}, new int[]{java.sql.

Types.VARCHAR,java.sql.Types.INTEGER});

57. }

58.

59.}

60.

61.数据库链接信息放在类路径的文件jdbc.properties中

62.

63.

driverClassName=org.gjt.mm.mysql.Driver
64.url=jdbc\:mysql\://localhost\:3306/test
https://www.360docs.net/doc/953681606.html,ername=root
66.password=
67.initialSize=1
68.maxActive=500
69.maxIdle=2
70.minIdle=1

71.

72.
此时的配置文件需要注明采用注解方式

73.

74.

75.
76. xmlns:xsi="https://www.360docs.net/doc/953681606.html,/2001/XMLSchema-instance"
77. xmlns:context="https://www.360docs.net/doc/953681606.html,/schema/context
"
78. xmlns:aop="https://www.360docs.net/doc/953681606.html,/schema/aop"
79. xmlns:tx="https://www.360docs.net/doc/953681606.html,/schema/tx"
80. xsi:schemaLocation="https://www.360docs.net/doc/953681606.html,/schema/bean
s
81. https://www.360docs.net/doc/953681606.html,/schema/beans/spring-beans-2.
5.xsd
82. https://www.360docs.net/doc/953681606.html,/schema/context http://www.sp
https://www.360docs.net/doc/953681606.html,/schema/context/spring-context-2.5.xsd
83. https://www.360docs.net/doc/953681606.html,/schema/aop http://www.spring
https://www.360docs.net/doc/953681606.html,/schema/aop/spring-aop-2.5.xsd
84. https://www.360docs.net/doc/953681606.html,/schema/tx http://www.springf
https://www.360docs.net/doc/953681606.html,/schema/tx/spring-tx-2.5.xsd">
85.
86.
87. 
88. 
89. 
90. 
91. 
92. 
93. 
94. 
95. 
96. 
97. 
98. 
99. 
100. 
101. 
102.
103.
104. 
116. 
117. 
118. 
119. 
120. 
121. 
122.  123. 
124.

125.

Java代码

1.import java.util.List;

2.

3.import javax.sql.DataSource;

4.

5.import org.springframework.jdbc.core.JdbcTemplate;

6.import org.springframework.transaction.annotation.Propagation;

7.import org.springframework.transaction.annotation.Transactional;

8.

9.import com.mingbai.bean.StudentBean;

10.import com.mingbai.service.StudentService;

11.

12.//将此业务类交由spring的事务管理，这时此方法的某个方法在执行前就开启事务，结束后提

交事务

13.@Transactional

14.public class StudentServiceImpl implements StudentService {

15.private JdbcTemplate jdbcTemplate;

16.

17.public void setDataSource(DataSource dataSource) {

18.this.jdbcTemplate = new JdbcTemplate(dataSource);

19. }

20.

21./* public void delete(Integer sid) {

22. jdbcTemplate.update("delete from student where id=?",

23. new Object[]{sid}, new int[]{java.sql.Types.INTEGE

R});

24. throw new RuntimeException("我是异常");

25. }*/

26./* @Transactional(rollbackFor=Exception.class)

27. public void delete(Integer sid) throws Exception {

28. jdbcTemplate.update("delete from student where id=?",

29. new Object[]{sid}, new int[]{java.sql.Types.INTEGE

R});

30. throw new Exception("我是异常");

31. }*/

32.@Transactional(noRollbackFor=RuntimeException.class)

33.public void delete(Integer sid) throws Exception {

34. jdbcTemplate.update("delete from student where id=?",

35.new Object[]{sid}, new int[]{java.sql.Types.INTEGE

R});

36.throw new RuntimeException("我是运行期异常");//运行期例外（uncheck

ed exception）事务默认回滚

37. }

38.

39.@Transactional(propagation=Propagation.NOT_SUPPORTED)

40.public List getAllStudent() {

41.return jdbcTemplate.query("select * from student", new Student

RowMapper());

42. }

43.

44.public StudentBean getStudent(Integer sid) {

45. StudentBean sb = (StudentBean)jdbcTemplate.queryForObject("sel

ect * from student where id=?", new Object[]{sid}, new int[]{java.sql.

Types.INTEGER}, new StudentRowMapper());

46.return sb;

47. }

48.

49.public void save(StudentBean student) {

50. jdbcTemplate.update("insert into student(name,password) values

(?,?)",

51.new Object[]{student.getName(),student.getPassword

()}, new int[]{java.sql.Types.VARCHAR,java.sql.Types.VARCHAR});

52. }

53.

54.public void update(StudentBean student) {

55. jdbcTemplate.update("update student set name=? where id=?",

56.new Object[]{student.getName(),5}, new int[]{java.sql.

Types.VARCHAR,java.sql.Types.INTEGER});

57. }

58.

59.}

60.

61.数据库链接信息放在类路径的文件jdbc.properties中

62.

63.

64.

Java代码 复制代码

65.

66.

    67.

  1. driverClassName=org.gjt.mm.mysql.Driver

    n>

    2. 68.

  2. 69.url=jdbc\:mysql\://localhost\:3306/test

    70.

    3. 71.

  3. username=root

    4. 72.

  4. password=

    5. 73.

  5. 74.initialSize=1

    75.

    6. 76.

  6. 77.maxActive=500

    78.

    7. 79.

  7. 80.maxIdle=2

    81.

    8. 82.

  8. 83.minIdle=1

    84.

    9. 85.

86.

driverClassName=org.gjt.mm.mysql.D
river
87.url=jdbc\:mysql\://localhost\:3306/test
https://www.360docs.net/doc/953681606.html,ername=root
89.password=
90.initialSize=1
91.maxActive=500
92.maxIdle=2
93.minIdle=1

94.

此时的配置文件需要注明采用注解方式

95.

96.

97.

Java代码 复制代码

98.

99.

100.

    101.

  1. "1.0" encoding="UTF-8"?>

    2. 102.

  2. 103."https://www.360docs.net/doc/953681606.html,/schema/beans"

    104.

    3. 105.

  3. 106. xmlns:xsi="https://www.360docs.net/doc/953681606.html,/2001/XMLSchema-instance"

    107.

    4. 108.

  4. 109. xmlns:context="https://www.360docs.net/doc/953681606.html,/schema/context"

    110.

    5. 111.

  5. 112. xmlns:aop="https://www.360docs.net/doc/953681606.html,/schema/aop"

    113.

    6. 114.

  6. 115. xmlns:tx="https://www.360docs.net/doc/953681606.html,/schema/tx"< span>

    116.

    7. 117.

  7. 118. xsi:schemaLocation="http:< span style="color: #008200;">//https://www.360docs.net/doc/953681606.html,/schema/beans

    119.

    8. 120.

  8. 121. http://https://www.360docs.net/doc/953681606.html,/schema/beans/spring-beans-2.5.x sd

    122.

    9. 123.

  9. 124. http://https://www.360docs.net/doc/953681606.html,/schema/context http://www.sprin https://www.360docs.net/doc/953681606.html,/schema/context/spring-context-2.5.xsd

    125.

    10. 126.

  10. 127. http://https://www.360docs.net/doc/953681606.html,/schema/aop http://www.springfra https://www.360docs.net/doc/953681606.html,/schema/aop/spring-aop-2.5.xsd

    128.

    11. 129.

  11. 130. http://https://www.360docs.net/doc/953681606.html,/schema/tx http://www.springfram https://www.360docs.net/doc/953681606.html,/schema/tx/spring-tx-2.5.xsd">

    131.

    12. 132.

    13. 133.

    14. 134.

  14. 135. "classpath:jdbc.properties"/>

    136.

    15. 137.

  15. 138. "dataSource" class="or

    https://www.360docs.net/doc/953681606.html,mons.dbcp.BasicDataSource" destroy-met

    hod="close"< /span>>

    139.

    16. 140.

  16. 141. "driverClassName" value= "${driverClassName} "/>

    142.

    17. 143.

  17. 144. "url" value="${url}"/ >

    145.

    18. 146.

  18. 147. "username" value="${username}"/>

    148.

    19. 149.

  19. 150. "password" value="${password}"/>

    151.

    20. 152.

    21. 153.

  21. 154. "initialSize" value="${initialSize}"/>

    155.

    22. 156.

    23. 157.

  23. 158. "maxActive" value="${maxActive}"/>

    159.

    24. 160.

    25. 162. "maxIdle" value="${maxIdle}" />

    163.

    164.

    26. 165.

  26. 166. "minIdle" value="${minIdle}" />

    167.

    27. 168.

    28. 169.

    29. 170.

    30. 171.

  30. 184.

  31. 185. "password" value=""/ >

    186.

    32. 187.

  32. 188. "initialSize" value="1"/>

    189.

    33. 190.

  33. 191. "maxActive" value="500"/>

    192.

    34. 193.

  34. 194. "maxIdle" value="1"/ >

    195.

    35. 196.

  35. 197. "minIdle" value="1"/ >

    198.

    36. 199.

    37. 200.

  37. -->

    38. 201.

  38. 202. "txManager" class="org.spri ngframework.jdbc.datasource.DataSourceTransactionManager">

    203.

    39. 204.

  39. 205. "dataSource" ref=

    ass="string">"dataSource"< span>/>

    206.

    40. 207.

    41. 208.

    42. 209.

  42. 210. "txManager"/>

    211.

    43. 212.

  43. 213. "studentService" class= "com.mingbai.service.impl.StudentServiceImpl"> < /span>

    214.

    44. 215.

  44. 216. "dataSource" ref="dataSource" >

    217.

    45. 218.

    46. 219.

    47. 220.

221.

222.

>
223.
224. xmlns:xsi="https://www.360docs.net/doc/953681606.html,/2001/XMLSchema-instance"
225. xmlns:context="https://www.360docs.net/doc/953681606.html,/schema/context "
226. xmlns:aop="https://www.360docs.net/doc/953681606.html,/schema/aop"
227. xmlns:tx="https://www.360docs.net/doc/953681606.html,/schema/tx"
228. xsi:schemaLocation="https://www.360docs.net/doc/953681606.html,/schema/bea ns
229. https://www.360docs.net/doc/953681606.html,/schema/beans/spring-beans-
2.5.xsd
230. https://www.360docs.net/doc/953681606.html,/schema/context http://www.
https://www.360docs.net/doc/953681606.html,/schema/context/spring-context-2.5.xsd
231. https://www.360docs.net/doc/953681606.html,/schema/aop http://www.spri https://www.360docs.net/doc/953681606.html,/schema/aop/spring-aop-2.5.xsd
232. https://www.360docs.net/doc/953681606.html,/schema/tx http://www.sprin https://www.360docs.net/doc/953681606.html,/schema/tx/spring-tx-2.5.xsd">
233.
234.
235. 
236. 
237. 
238. 
239. 
240. 
241. 
242.  243. 
244. 
245. 
246. 
247. 
248. 
249. 
250.
251.
252. 
264. 
265. 
266. 
267. 
268. 
269. 
270.  271. 
272.

273.

一。基于xml配置方式

Java代码

1.import java.util.List;

2.

3.import javax.sql.DataSource;

4.

5.import org.springframework.jdbc.core.JdbcTemplate;

6.

7.import com.mingbai.bean.StudentBean;

8.import com.mingbai.service.StudentService;

9.

10.

11.public class StudentServiceImpl2 implements StudentService {

12.private JdbcTemplate jdbcTemplate;

13.

14.public void setDataSource(DataSource dataSource) {

15.this.jdbcTemplate = new JdbcTemplate(dataSource);

16. }

17.

18.

19.public void delete(Integer sid) throws Exception {

20. jdbcTemplate.update("delete from student where id=?",

21.new Object[]{sid}, new int[]{java.sql.Types.INTEGER});

22.throw new RuntimeException("我是运行期异常");//运行期例外（uncheck

ed exception）事务默认回滚

23. }

24.

25.public List getAllStudent() {

26.return jdbcTemplate.query("select * from student", new Student

RowMapper());

27. }

28.

29.public StudentBean getStudent(Integer sid) {

30. StudentBean sb = (StudentBean)jdbcTemplate.queryForObject("sel

ect * from student where id=?", new Object[]{sid}, new int[]{java.sql.

Types.INTEGER}, new StudentRowMapper());

31.return sb;

32. }

33.

34.public void save(StudentBean student) {

35. jdbcTemplate.update("insert into student(name,password) values

(?,?)",

36.new Object[]{student.getName(),student.getPassword

()}, new int[]{java.sql.Types.VARCHAR,java.sql.Types.VARCHAR});

37. }

38.

39.public void update(StudentBean student) {

40. jdbcTemplate.update("update student set name=? where id=?

",

41.new Object[]{student.getName(),5}, new int[]{java.sql.

Types.VARCHAR,java.sql.Types.INTEGER});

42. }

43.

44.}

Java代码

1.import java.util.List;

2.

3.import javax.sql.DataSource;

4.

5.import org.springframework.jdbc.core.JdbcTemplate;

6.

7.import com.mingbai.bean.StudentBean;

8.import com.mingbai.service.StudentService;

9.

10.

11.public class StudentServiceImpl2 implements StudentService {

12.private JdbcTemplate jdbcTemplate;

13.

14.public void setDataSource(DataSource dataSource) {

15.this.jdbcTemplate = new JdbcTemplate(dataSource);

16. }

17.

18.

19.public void delete(Integer sid) throws Exception {

20. jdbcTemplate.update("delete from student where id=?",

21.new Object[]{sid}, new int[]{java.sql.Types.INTEGE

R});

22.throw new RuntimeException("我是运行期异常");//运行期例外（uncheck

ed exception）事务默认回滚

23. }

24.

25.public List getAllStudent() {

26.return jdbcTemplate.query("select * from student", new Student

RowMapper());

27. }

28.

29.public StudentBean getStudent(Integer sid) {

30. StudentBean sb = (StudentBean)jdbcTemplate.queryForObject("sel

ect * from student where id=?", new Object[]{sid}, new int[]{java.sql.

Types.INTEGER}, new StudentRowMapper());

31.return sb;

32. }

33.

34.public void save(StudentBean student) {

35. jdbcTemplate.update("insert into student(name,password) values

(?,?)",

36.new Object[]{student.getName(),student.getPassword

()}, new int[]{java.sql.Types.VARCHAR,java.sql.Types.VARCHAR});

37. }

38.

39.public void update(StudentBean student) {

40. jdbcTemplate.update("update student set name=? where id=?",

41.new Object[]{student.getName(),5}, new int[]{java.sql.

Types.VARCHAR,java.sql.Types.INTEGER});

42. }

43.

44.}

配置文件

Java代码

1.

2.

3. xmlns:xsi="https://www.360docs.net/doc/953681606.html,/2001/XMLSchema-instance"

4. xmlns:context="https://www.360docs.net/doc/953681606.html,/schema/context

"

5. xmlns:aop="https://www.360docs.net/doc/953681606.html,/schema/aop"

6. xmlns:tx="https://www.360docs.net/doc/953681606.html,/schema/tx"

7. xsi:schemaLocation="https://www.360docs.net/doc/953681606.html,/schema/bean

s

8. https://www.360docs.net/doc/953681606.html,/schema/beans/spring-beans-2.

5.xsd

9. https://www.360docs.net/doc/953681606.html,/schema/context http://www.sp

https://www.360docs.net/doc/953681606.html,/schema/context/spring-context-2.5.xsd

10. https://www.360docs.net/doc/953681606.html,/schema/aop http://www.spring

https://www.360docs.net/doc/953681606.html,/schema/aop/spring-aop-2.5.xsd

11. https://www.360docs.net/doc/953681606.html,/schema/tx http://www.springf

https://www.360docs.net/doc/953681606.html,/schema/tx/spring-tx-2.5.xsd">

12.

13.

14.

15.

16.

17.

18.

>

19.

20.

21.

22.

23.

24.

25.

26.

27.

28.

29.

30.

31.

32.

33.

34.

35.

36.

37.

38.

39.

40.

41.

42.

43.

44.

45.

46.

spring事务的属性

1?关于事务默认的回滚

一．事务碰到unchecked Exception ，默认情况下自动回滚，如果想取消自动回滚可以指定属性@Transactional(noRollbackFor=RuntimeException.class)

二．事务碰到checked Exception，默认情况下事务不回滚，如果想回滚可以用属性指定@Transactional(rollbackFor=Exception.class)

三．当然事务属性中的另外一个也是可以的不过要指定的是类名noRollbackForClassName

2?事务的开启与关闭（默认情况下spring是开启事务的）

@Transactional(propagation=Propagation.NOT_SUPPORTED)

public List getAllStudent() {

return jdbcTemplate.query("select * from student", new StudentRowMapper());

}

3?@Transactional(readOnly=true)

只读事务，就是不用控制，可以提高效率

下面是事物的其它属性

4?@Transactional(timeout=1000)

事务时间

5·事务的传播属性

@Transactional(propagation=Propagation.NOT_SUPPORTED)

REQUIRED: 业务方法需要在一个事务中运行。如果方法运行时，已经在一个事务中，哪么加到该事务，否则为自己创建一个新的事务。Spring默认的事务传播属性设置@Transactional(propagation=Propagation.REQUIRED)

NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。

REQUERESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有的事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。

MANDATORY:该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出异常。

SUPPORTS:这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行

NEVER:：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务范围内执行，则容器抛出异常，只有业务方法没有关联到任何事务，才能正常执行。

NESTED:如果一个事务存在，则运行在一个嵌套的事务中，如果没有活动事务，则按REQUIRED属性执行，它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionalmaManager事务管理器起效。

比如：一个get方法是不需要事务的，加上事务会影响效率的，这时我们可以加上这个属性设置：@Transactional(propagation=Propagation.NOT_SUPPORTED)。这时此方法就不会有事务控制了。

像save、update等业务方法默认都是要事务控制的

@Transactional(propagation=Propagation.REQUEIRED)---这个是默认的，可以省写

6·属性isolation—事务的隔离级别

@Transactional(isolation=Isolation.READ_UNCOMMITTED)

数据库系统提供了四种事务隔离级别（隔离级别是当数据库并行访问操作时，安全策略的实现）

数据库系统提供了四种事务隔离级别供用户选中。不同的隔离及、别采用不认同的锁类型来实现（共享锁、更新锁、排它锁），在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited，如sql server，当然也有少数部分数据库默认的隔离级别为Repeatable Read，如mysql

Read Uncommited：读未提交数据（会出现脏读，不可重复读和幻读）

Read Commited：读已提交数据（会出现不可重复读和幻读）

Repeatable Read：可重复读（会出现幻读）

Serializable：串行化

脏读：一个事物读到另一个事务未提交的更新数据

不可重复读：在同一个事务中，多次读取同一数据返回的结果有所不同。换句话就是，后续读可以读到另一个事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能道道另一个事务已提交的更新数据

幻读：一个事务读取到另一个事务已提交的insert数据

混淆事务模型与事务策略是一个常见的错误。本系列关于事务策略的第二篇文章将概述Java? 平台支持的三种事务模型，并介绍使用这些模型的四种主要事务策略。通过使用Spring Framework 和Enterprise JavaBeans (EJB) 3.0 规范中的示例，Mark Richards 将解释事务模型的运行原理以及它们如何形成开发各种事务策略（从基本的事务处理到高速事务处理系统）的基础。

开发人员、设计人员和架构师经常会混淆事务模型与事务策略。我经常会让与客户接触的架构师和技术总监描述他们项目的事务策略。我通常会获得三种回应。有时，他们会说“我们实际上并未在应用程序中使用事务。”另一些时候，我会听到迷惑的回答：“我不明白你的意思。”但是，我也会遇到非常自信的回答：“我们使用声明式事务。”在本文中，术语声明式事务描述的是一个事务模型，但它绝不是一种事务策略。

Java 平台支持的三种事务模型包括：

?Local Transaction 模型

?Programmatic Transaction 模型

?Declarative Transaction 模型

这些模型描述事务在 Java 平台中的基本运行方式，以及它们是如何实现的。但是，它们仅提供了事务处理的规则和语义。如何应用事务模型则完全由您决定。举例来说，应该如何在REQUIRED和MANDATORY事务属性之间做出选择？您应该在何时何种情况下指定事务回滚指令？您应该在何时考虑 Programmatic Transaction 模型与 Declarative

Transaction 模型的优劣？您应该如何优化高性能系统的事务？事务模型本身无法回答这些问题。您必须通过开发自己的事务策略或采用本文介绍的四种主要事务策略之一来解决它们。

如本系列的第一篇文章所述，许多常见的事务陷阱都会影响到事务行为，并且由此会降低数据的完整性和一致性。同样，缺乏有效的（或任何）事务策略将对您数据的完整性和一致性造成负面影响。本文所描述的事务模型是开发有效事务策略的基本元素。理解这些模型之间的差异以及它们的运行方式对于理解使用它们的事务策略非常重要。在介绍完三种事务模型之后，我将讨论适用于大多数业务应用程序（从简单的 Web 应用程序到大型的高速事务处理系统）的四种事务策略。事务策略系列的后续文章将详细讨论这些策略。

spring配置文件各个属性详解

spring配置文件各个属性详解 分类：spring 2012-08-09 11:25 9316人阅读评论(2) 收藏举报springaophibernateattributesxhtmlwebsphere 目录(?)[+]一、引用外部属性文件 classpath:mail.properties classpath:jdbc.properties 我们定义了一个PropertyPlaceholderConfigurer类的实例，并将其位置属性设置为我们的属性文件。该类被实现为Bean工厂的后处理器，并将使用定义在文件中的属性来代替所有的占位符（${...}value）。 注意： 而在spring2.5的版本中提供了一种更简便的方式，如： 1. 这样以后要使用属性文件中的资源时，可以使用${属性名}来获得。 二、常用数据源的配置 第一种是：DBCP数据源，（需要加入2个jar文件，在spring中的lib下 jakarta-commons/commons-dbcp.jar和commons-pools.jar）主要配置如下：

spring使用基于注解的AOP事务管理

spring使用基于注解的AOP事务管理 16.6 AOP事务管理 AOP事务管理利用了Spring AOP的基础设施，在大多数情况下，Spring AOP会创建一个JDK代理以拦截方法调用。你可以使用装载时编织以在装载期编织切面，这样就不需要代理了（如果你记不清什么是装载时编织，请参看第6章）。你有两种方式来配置Spring AOP 事务管理，基于注解的配置以及XML配置。 16.6.1 使用基于注解的AOP事务管理 你可以借助于AOP的自动代理，通过注解将事务性行为引入到现有的bean中。让我们以代码清单16-21开始吧，它展示了类DeclarativeTxBankService。 代码清单16-21 DeclarativeTxBankService实现 请注意@Transactional属性，为了让Spring的事务管理基础设施可以利用该属性创建恰当的切入点和通知，我们需要使用AOP的自动代理和注解驱动的事务支持。代码清单16-22展示了与该注解相对应的XML配置。 代码清单16-22 基于注解的事务管理的配置文件

该XML配置文件展示了标准的bankService bean声明，紧跟其后的是 和标签。 标签使用@Transactional注解创建恰当的事务管理切面。接下来由通知匹配的bean。 1．探索tx:annotation-driven标签 标签是注解驱动的事务管理支持的核心。表16-3列出了 标签的所有属性。 表16-3 标签的属性 属性说明 transactionManager 指定到现有的PlatformTransaction Manager bean的引用，通知会使用该引用 mode 指定Spring事务管理框架创建通知bean的方式。 可用的值有proxy和aspectj。前者是默认值， 表示通知对象是个JDK代理；后者表示 Spring AOP会使用AspectJ创建代理 order 指定创建的切面的顺序。只要目标对象有多个通知就可以使用该属性 proxy-target-class 该属性如果为true就表示你想要代理目标类而不是bean所实现的所有接口

S详细讲解SH中Spring事务流程

给你详细讲一下SSH框架的事物管理，希望对你有帮助。 Struts+hibernate+spring整合开发web应用是相当流行的，只需要简单的配置就能轻松的对数据库进行crud操作，下面就hibernate＋spring 的配置做一下剖析，一边与大家一起分享经验： 1、准备工作： 可以利用hibernate tools生成相关映射文件已经po对象、dao对象，dao 也可以自己手动编写，无非就是实现crud，如果通过继承hibernate提供的HibernateDaoSupport,则可以更轻松的实现 关键就在于配置文件，下面看一个样例：

Spring分布式事务实现

Spring分布式事务实现 分布式事务是指操作多个数据库之间的事务，spring的org.springframework.transaction.jta.JtaTransactionManager，提供了分布式事务支持。如果使用WAS的JTA支持，把它的属性改为WebSphere对应的TransactionManager。 在tomcat下，是没有分布式事务的，不过可以借助于第三方软件jotm（Java Open Transaction Manager ）和AtomikosTransactionsEssentials实现，在spring中分布式事务是通过jta（jotm，atomikos）来进行实现。 1、https://www.360docs.net/doc/953681606.html,/ 2、https://www.360docs.net/doc/953681606.html,/Main/TransactionsEssentials 一、使用JOTM例子 (1) Dao及实现 GenericDao接口： ? 1 2 3 4 public interface GenericDao { public int save(String ds, String sql, Object[] obj) throws Exception; public intfindRowCount(String ds, String sql); } GenericDaoImpl实现：? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public class GenericDaoImpl implements GenericDao{ private JdbcTemplatejdbcTemplateA; private JdbcTemplatejdbcTemplateB; public void setJdbcTemplateA(JdbcTemplatejdbcTemplate) { this.jdbcTemplateA = jdbcTemplate; } public void setJdbcTemplateB(JdbcTemplatejdbcTemplate) { this.jdbcTemplateB = jdbcTemplate; } public int save(String ds, String sql, Object[] obj) throws Exception{ if(null == ds || "".equals(ds)) return -1; try{ if(ds.equals("A")){ return this.jdbcTemplateA.update(sql, obj); }else{ return this.jdbcTemplateB.update(sql, obj); } }catch(Exception e){ e.printStackTrace(); throw new Exception("执行" + ds + "数据库时失败！"); } } public intfindRowCount(String ds, String sql) {

全面分析 Spring 的编程式事务管理及声明式事务管理

开始之前 关于本教程 本教程将深入讲解Spring 简单而强大的事务管理功能，包括编程式事务和声明式事务。通过对本教程的学习，您将能够理解Spring 事务管理的本质，并灵活运用之。 先决条件 本教程假定您已经掌握了Java 基础知识，并对Spring 有一定了解。您还需要具备基本的事务管理的知识，比如：事务的定义，隔离级别的概念，等等。 本文将直接使用这些概念而不做详细解释。另外，您最好掌握数据库的基础知识，虽然这不是必须。 系统需求 要试验这份教程中的工具和示例，硬件配置需求为：至少带有512MB 内存（推荐1GB）的系统。需要安装以下软件： ?Sun JDK 或更新版本或IBM Developer Kit for the Java 5 platform 版本。?Spring framework 。本教程附带的示例代码已经在Spring 上测试过。?MySQL 或更新版本。 ? Spring 事务属性分析 事务管理对于企业应用而言至关重要。它保证了用户的每一次操作都是可靠的，即便出现了异常的访问情况，也不至于破坏后台数据的完整性。就像银行的自助取款机，通常都能正常为客户服务，但是也难免遇到操作过程中机器突然出故障的情况，此时，事务就必须确保出故障前对账户的操作不生效，就像用户刚才完全没有使用过取款机一样，以保证用户和银行的利益都不受损失。 在Spring 中，事务是通过TransactionDefinition 接口来定义的。该接口包含与事务属性有关的方法。具体如清单1所示： 清单1. TransactionDefinition 接口中定义的主要方法 public interface TransactionDefinition{ int getIsolationLevel(); int getPropagationBehavior(); int getTimeout(); boolean isReadOnly();

spring事务传播机制实例讲解

spring事务传播机制实例讲解 Java代码1、 [DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [https://www.360docs.net/doc/953681606.html,erService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT 2、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')] 3、 [DEBUG,DataSourceTransactionManager,main] Suspending current transaction, creating new transaction with name [com.zx.spring.BookService.addBook] 4、 [DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')] 5、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit 6、 [DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1b7ae22] 7、[DEBUG,DataSourceTransactionManager,main] Resuming suspended transaction after completion of inner transaction 8、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit 9、

spring的@Transactional注解详细用法

spring的@Transactional注解详细用法 各位读友大家好！你有你的木棉，我有我的文章，为了你的木棉，应读我的文章！若为比翼双飞鸟，定是人间有情人！若读此篇优秀文，必成天上比翼鸟！ spring的@Transactional注解详细用法Spring Framework对事务管理提供了一致的抽象，其特点如下：为不同的事务API 提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。显然声明式事务管理要优于编程式事务管理，这正是spring

Spring事务配置的五种方式

Spring事务原理 统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatus spring提供了几个关于事务处理的类： TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务，可以提交，回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 一般事务定义步骤： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.360docs.net/doc/953681606.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。 编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象. void add() { transactionTemplate.execute( new TransactionCallback(){ pulic Object doInTransaction(TransactionStatus ts) { //do sth} } } 声明式： 使用TransactionProxyFactoryBean: PROPAGATION_REQUIRED PROPAGATION_REQUIRED

计算机软件,spring中事务管理器的配置

浅析Spring提供的事务管理方法

浅析Spring提供的事务管理方法 Spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；而声明式的比编程式的更灵活方便。本文将讨论这两种事务管理的区别。 传统的JDBC事务管理 以往使用JDBC进行数据操作时，一般采用DataSource,从数据源中得到Connection,我们知道数据源是线程安全的，而连接不是线程安全的，所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理，包括连接池。例如TOMCAT，WEBSPHERE，WEBLOGIC等这些J2EE商业容器都提供了这个功能。 以往的我们使用JDBC在写代码时，事务管理可能会是这样： Connection conn = null; try { conn = DBConnectionFactory.getConnection; conn.setAutoCommit(false); //do something https://www.360docs.net/doc/953681606.html,mit(); //commit transcation } catch(Exception e) { conn.rollback(); //do sth } finally { try { conn.close();

catch(SQLException se){ //do sth.} //close ResultSet,PreparedStatement,Connection //notice:Maybe ocurr Exception when u close rs,pstmt,conn } 按照以往的思路来写代码，代码量比较长，而且容易疏忽，忘掉一些try/catch，引发一些异常无法catch，虽然有时候我们会写DBTool类，来关闭这些资源，并且保证在关闭这些资源时，不向外抛异常。 Spring提供的编程式的事务处理 Spring提供了几个关于事务处理的类： ?TransactionDefinition //事务属性定义 ?TranscationStatus //代表了当前的事务，可以提交，回滚。 ?PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 我们使用编程式的事务管理流程可能如下： 1 声明数据源 2 声明一个事务管理类，例如DataSourceTransactionManager,HibernateTransactionManger,JTATransactionManager等 3 在我们的代码中加入事务处理代码： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.360docs.net/doc/953681606.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} 使用spring提供的事务模板TransactionTemplate void add()

在spring中如何配代码的事务管理

在spring中如何配代码的事务管理 在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：org.springframework.web.context.ContextLoaderListener ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring 配置文件的位置。示例 使用”org.springframework.jdbc.datasource.DriverManagerDataSou rce”数据源来配置数据库驱动。示例如下：org.hsqldb.jdbcDriver jdbc:hsqldb:db/appfuse sa spring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransac 在context中定义DataSource，创建SessionFactoy，设置参

数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter 或OpenSessionInViewIntercepto 一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C 的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC 的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的

spring,mybatis事务管理配置与@Transactional注解使用[转]

spring,mybatis事务管理配置与@Transactional注解使用 [转] spring,mybatis事务管理配置与@Transactional注解使用 概述 事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。 Spring Framework对事务管理提供了一致的抽象，其特点如下： 为不同的事务API提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成 事务管理方式 spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 声明式事务管理建立在AOP之上的。其本质是对方法前后

进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于 @Transactional注解的方式)，便可以将事务规则应用到业 务逻辑中。 显然声明式事务管理要优于编程式事务管理，这正是spring 倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。 声明式事务管理也有两种常用的方式，一种是基于tx和aop 名字空间的xml配置文件，另一种就是基于@Transactional 注解。显然基于注解的方式更简单易用，更清爽。 自动提交(AutoCommit)与连接关闭时的是否自动提交 自动提交 默认情况下，数据库处于自动提交模式。每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则

spring事务配置详解

Spring事务配置的五种方法 2009-04-24 10:20 总结如下： Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。 具体如下图： 根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下： 第一种方式：每个Bean都有一个代理

spring事务

1.6 Spring事务： 1. 编程式事务管理——编程式的事务管理可以清楚滴控制事务的边界，也就是让您自行实现事务开始时间、撤消操作的时机、结束时间等，可以实现细粒度的事务控制。 2. 声明式事务管理——然而多数的情况下，事务并不需要细粒度的控制，而是采用声明式的事务管理，好处是Spring事务管理的相关API可以不用介入程序之中，从对象的角度来看，它并不知道自己正被纳入事务管理之中，在不需要事务管理的时候，只要在设置文件上修改一下设置，即可移去事务管理服务。 Spring声明式的事务管理依赖它的AOP框架来完成。使用声明式事务管理的好处是，事务管理不能侵入您所开发的组件，具体来说，DAO对象不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策略的话，也只需要在定义文件中重新配置。 事务的属性介绍： Spring使用AOP来完成声明式的事务管理，因而声明式事务是以方法为边界的，Spring的事务属性自然就在于描述事务应用至方法上的策略，在Spring 中事务属性分作以下的几个参数：传播行为（Propagation behavior）、隔离层级（Isolation Level）、只读提示（Read-only hints）、事务超时期间（The transaction timeout period） 传播行为（Propagation behavior）：传播行为定义了事务应用于方法的边界（Boundaries），它告知何时该开始一个新的事务，或何时事务被暂停，或方法是否要在事务中进行。如，若传播行为设置为PROPAGATION_REQUIRED，则事务的边界在开始第一个事务的方法呼叫及结束时，如果先前没有事务被开始，则事务边界即为目前方法的执行前后。又如果传播行为被声明为PROPAGATION_REQUIRES_NEW，则事务的边界即为该方法执行的前后。 隔离层级（Isolation Level）：在一个应用程序中，可能有多个事务同时在进行，这些事务应当彼此之间另一个事务的存在，好比现在整个应用程序就只有一个事务存在，由于事务彼此之间独立，若读取的是同一个数据的话，就容易发生问题。如： 脏读：（Dirty Read）脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另一个事务也访问了这个数据，然后使用了这个数据，由于这个数据是还没有提交的数据，（有可能回滚）那么另外这个事务读到的数据就是脏数据，依据脏数据所做的操作可能是不正确的。 不可重复读：（Non-repeatable read）指在一个事物中，多次读取同一个数据。当这个事务还没结束时，另外一个事务也访问该同一数据。那么，在第一个事务中

Spring 自动事务代理

spring 同时支持编程事务策略和声明式事务策略，大部分时候，都推荐使用声明式事务策略，使用声明式事务策略的优势十分明显。 对于使用声明式事务策略，可以使用TransactionProxyFactoryBean来配置事务代理Bean。正如它的类名所暗示的，它是一个工厂Bean，工厂Bean用于生成一系列的Bean实例，这一系列的Bean实例都是Proxy.这种事务代理正是基于Spring AOP组件。配置TransactionProxyFactoryBean时，一样需要指定目标Bean. 每个TransactionProxyFactoryBean为一个目标Bean生成事务代理，事务代理的方法改写了目标Bean的方法，就是在目标Bean的方法执行之前加入了事务，在目标Bean的方法正常结束之前提交事务，如查遇到了异常则回滚事务。 TransactionProxyFactoryBean创建事务代理时，需要了解当前事务所处的环境，该环境属性通过PlatformTransactionManager实例传入，而相关事务传入规则在TransactionProxyFactoryBean的定义中给出. PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED *0*IF

Spring事务隔离级别

Spring事务隔离级别 本文将介绍Spring事务隔离级别，Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。 AD： 一、Propagation ： key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。 有以下选项可供使用：PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY 支持当前事务，如果当前没有事务，就抛出异常。 PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。 PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常。 1：PROPAGATION_REQUIRED 加入当前正要执行的事务不在另外一个事务里，那么就起一个新的事务

比如说，ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候， ServiceA.methodA已经起了事务，这时调用ServiceB.methodB，ServiceB.methodB看到自己已经运行在ServiceA.methodA 的事务内部，就不再起新的事务。而假如ServiceA.methodA运行的时候发现自己没有在事务中，他就会为自己分配一个事务。 这样，在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常，事务都会被回滚。即使ServiceB.methodB的事务已经被提交，但是ServiceA.methodA在接下来fail要回滚，ServiceB.methodB也要回滚。 2：PROPAGATION_SUPPORTS 如果当前在事务中，即以事务的形式运行，如果当前不再一个事务中，那么就以非事务的形式运行。 3：PROPAGATION_MANDATORY 必须在一个事务中运行。也就是说，他只能被一个父事务调用。否则，他就要抛出异常。 4：PROPAGATION_REQUIRES_NEW 这个就比较绕口了。比如我们设计ServiceA.methodA的事务级别为 PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为 PROPAGATION_REQUIRES_NEW，那么当执行到ServiceB.methodB的时候， ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的事务，等待ServiceB.methodB的事务完成以后，他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务，那么就是存在两个不同的事务。如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚，如果他抛出的异常被ServiceA.methodA捕获，ServiceA.methodA事务仍然可能提交。 5：PROPAGATION_NOT_SUPPORTED

事务管理的五种方法

前段时间对Spring的事务配置做了比较深入的研究，在此之间对Spring的事务配置虽说也配置过，但是一直没有一个清楚的认识。通过这次的学习发觉Spring的事务配置只要把思路理清，还是比较好掌握的。 总结如下： Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。 具体如下图： 根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：

第一种方式：每个Bean都有一个代理

相关主题
相关文档
最新文档