Spring学习（四）

 

Spring学习笔记( 17 )----使用Spring注解方式管理事务

--------------------------------------------------

使用Spring+JDBC集成步骤如下：

  

  *配置数据源，例如：

  

 

 

Xml代码 

1 .<bean id= "dataSource"  class = "org.apache.commons.dbcp.BasicDataSource"  destroy-method= "close" > 

2 .            <property name= "driverClassName"  value= "com.mysql.jdbc.Driver" /> 

3 .            <property name= "url"  value= "jdbc:mysql://localhost:3306/test" /> 

4 .            <property name= "username"  value= "root" /> 

5 .            <property name= "password"  value= "123456" /> 

6 .            <!-- 连接池启动时的初始值 --> 

7 .            <property name= "initialSize"  value= "1" /> 

8 .            <!-- 连接池的最大值 --> 

9 .            <property name= "maxActive"  value= "100" /> 

10 .            <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 --> 

11 .            <property name= "maxIdle"  value= "2" /> 

12 .            <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 --> 

13 .            <property name= "minIdle"  value= "1" /> 

14 .        </bean> 

  

  *配置事务，配置事务时，需要在xml配置文件中引入用于声明事务的tx命名空间，事务的配置有两种方式：注解方式和基于XML配置的方式

  

  

  

下面演示下使用Spring注解方式管理事务

  

首先在配置文件中配置Spring提供的事务管理器

  

 

 

Xml代码 

1 .<bean id= "txManager"  class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" > 

2 .            <!-- 指定数据源 --> 

3 .            <property name= "dataSource"  ref= "dataSource" /> 

4 .        </bean> 

  

  由于会使用注解方式，因此我们要打开注解处理器，对注解进行解析

  

 

 

Xml代码 

1 .<tx:annotation-driven transaction-manager= "txManager" /> 

  

  

  

这样我们的配置文件配置完成，下面我们在Mysql中建立一张表，

  

 

 

Sql代码 

1 .create table users 

2 .(                    

3 . id int ( 11 ) not null  auto_increment,   

4 . username varchar( 20 ) not null ,        

5 . primary key (id)                    

6 .)  

  

  

  

根据数据库，我们创建javabean

  

 

 

Java代码 

1 . package  com.szy.spring.bean; 

2 . /**

3. * @author  coolszy

4. * @time    Dec 6, 2009 2:13:33 PM

5. */ 

6 . public  class  User 

7 .{ 

8 .    private  int  id; 

9 .    private  String username; 

10 .    public  int  getId() 

11 .    { 

12 .        return  id; 

13 .    } 

14 .    public  void  setId( int  id) 

15 .    { 

16 .        this .id = id; 

17 .    } 

18 .    public  String getUsername() 

19 .    { 

20 .        return  username; 

21 .    } 

22 .    public  void  setUsername(String username) 

23 .    { 

24 .        this .username = username; 

25 .    } 

26 .}    

  

  

  

然后创建DAO接口，在DAO中提供几个方法：

  

 

 

Java代码 

1 . package  com.szy.spring.dao; 

2 . 

3 . import  java.util.List; 

4 . 

5 . import  com.szy.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 .}    

  

  

  

实现这个接口

  

  

  

 

 

Java代码 

1 . package  com.szy.spring.dao.impl; 

2 . 

3 . import  java.util.List; 

4 . 

5 . import  com.szy.spring.bean.User; 

6 . import  com.szy.spring.service.UserService; 

7 . 

8 . /**

9. * @author  coolszy

10. * @time    Dec 6, 2009 2:19:22 PM

11. */ 

12 . public  class  UserDAOImpl implements  UserDAO 

13 .{ 

14 . 

15 .    public  void  delete( int  id) 

16 .    { 

17 . 

18 .    } 

19 . 

20 .    public  List<User> getAllUsers() 

21 .    { 

22 .        return  null ; 

23 .    } 

24 . 

25 .    public  User getUser( int  id) 

26 .    { 

27 . 

28 .    } 

29 . 

30 .    public  void  save(User user) 

31 .    { 

32 . 

33 .    } 

34 . 

35 .    public  void  update(User user) 

36 .    { 

37 . 

38 .    } 

39 . 

40 .}    

  

  

  

下面把这个类交给Spring管理

  

 

 

Xml代码 

1 .<bean id= "userDAO"  class = "com.szy.spring.dao.impl.UserDAOImpl" />   

  

  由于要通过数据源对表进行操作，因此在DAO中添加数据源。

  

 

 

Java代码 

1 . private  DataSource dataSource; 

2 . 

3 .    public  void  setDataSource(DataSource dataSource) 

4 .    { 

5 .        this .dataSource = dataSource; 

6 .    }    

  

  

  

然后在配置文件中进行配置

  

 

 

Xml代码 

1 .<bean id= "userDAO"  class = "com.szy.spring.service.impl.UserDAOImpl" > 

2 .            <property name= "dataSource"  ref= "dataSource" /> 

3 .        </bean>    

  

  

  

这样我们就把数据源注入到类中。

  

在UserDAOImpl类中我们提供了dataSource，这样我们就可以对数据库进行操作，但是不推荐直接使用dataSource，建议使用JdbcTemplate

  

 

 

Java代码 

1 . private  JdbcTemplate jdbcTemplate; 

2 .    public  void  setDataSource(DataSource dataSource) 

3 .    { 

4 .        //this.dataSource = dataSource; 

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

6 .    }    

  

  下面我们使用jdbcTemplate对数据库进行增删改查，详细代码见附件。

  

 

 

Java代码 

1 . package  com.szy.spring.dao.impl; 

2 . 

3 . import  java.util.List; 

4 . 

5 . import  javax.sql.DataSource; 

6 . 

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

8 . 

9 . import  com.szy.spring.bean.User; 

10 . import  com.szy.spring.dao.UserDAO; 

11 . 

12 . /**

13. * @author  coolszy

14. * @time    Dec 6, 2009 2:19:22 PM

15. */ 

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 .    } 

31 . 

32 .    public  List<User> getAllUsers() 

33 .    { 

34 .        return  (List<User>)jdbcTemplate.query( "select * from users" , new  UserRowMapper()); 

35 .    } 

36 . 

37 .    public  User getUser( int  id) 

38 .    { 

39 .        return  (User)jdbcTemplate.queryForObject( "select * from users where id=?" , new  Object[]{id},  

40 .                new  int []{java.sql.Types.INTEGER}, new  UserRowMapper()); 

41 . 

42 .    } 

43 . 

44 .    public  void  save(User user) 

45 .    {  

46 .        jdbcTemplate.update( "insert into users(username) values(?)" , new  Object[]{user.getUsername()}, 

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

48 . 

49 .    } 

50 . 

51 .    public  void  update(User user) 

52 .    { 

53 .        jdbcTemplate.update( "update users set username=? where id=?" , new  Object[]{user.getUsername(),user.getId()}, 

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

55 . 

56 .    } 

57 . 

58 .}    

  

  编写测试代码，代码运行正常。

  

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

  

 

 

Java代码 

1 . 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 .     

  

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

  

 

 

Java代码 

1 . @Transactional (propagation=Propagation.NOT_SUPPORTED) 

  

  

  

  

  

PS：在上面的配置文件中我们在配置文件中指明了驱动类等信息，如果我们想写在配置文件中要怎么配置能，首先我们编写配置文件，

  

 

 

Jdbc.properties代码 

1 .driverClassName=com.mysql.jdbc.Driver 

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

3 .username=root 

4 .password= 123456 

5 .initialSize= 1 

6 .maxActive= 100 

7 .maxIdle= 2 

8 .minIdle= 1    

  

  然后Spring的配置文件需进行如下配置：

  

 

 

Xml代码 

1 .<context:property-placeholder location= "classpath:jdbc.properties" /> 

2 .        <bean id= "dataSource"  class = "org.apache.commons.dbcp.BasicDataSource"  destroy-method= "close" > 

3 .            <property name= "driverClassName"  value= "${driverClassName}" /> 

4 .            <property name= "url"  value= "${url}" /> 

5 .            <property name= "username"  value= "${username}" /> 

6 .            <property name= "password"  value= "${password}" /> 

7 .            <property name= "initialSize"  value= "${initialSize}" /> 

8 .            <property name= "maxActive"  value= "${maxActive}" /> 

9 .            <property name= "maxIdle"  value= "${maxIdle}" /> 

10 .            <property name= "minIdle"  value= "${minIdle}" /> 

11 .        </bean>    

  

   这样就可以从属性文件中读取到配置信息。

  

  

 

 

 

 

 

Spring学习笔记( 18 )----使用Spring配置文件实现事务管理

-------------------------------------------------------

由于我们要拦截UserDAOImpl中的方法，因此我们需要在配置文件中配置信息，在配置文件中使用了AOP技术来拦截方法。

  

 

 

Xml代码 

1 .<aop:config> 

2 .    <aop:pointcut id= "transactionPointcut"  expression= "execution(* com.szy.spring.dao.impl..*.*(..))" /> 

3 .    <aop:advisor advice-ref= "txAdvice"  pointcut-ref= "transactionPointcut" /> 

4 .  </aop:config>  

5 .  <tx:advice id= "txAdvice"  transaction-manager= "txManager" > 

6 .     <tx:attributes> 

7 .      <!-- 如果连接的方法是以get开头的方法，则不使用事务 --> 

8 .       <tx:method name= "get*"  read-only= "true"  propagation= "NOT_SUPPORTED" /> 

9 .       <tx:method name= "*" /> 

10 .     </tx:attributes> 

11 .  </tx:advice> 

  

   

  

这样Spring就能对这个类进行事务管理。

  

  

  

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

  

假设我们的delete方法如下：

  

 

 

Java代码 

1 . 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 . } 

  

  

  

  

  

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

  

测试代码：

  

 

 

Java代码 

1 . @Test 

2 . public  void  testDelete() 

3 . { 

4 .  userDAO.delete( 5 ); 

5 . } 

  

  

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

  

  

  

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