Spring声明式处理

关于spring事务管理以及异常处理的帖子，本论坛争论颇多，各有各的测试代码，也各有各的测试结果，
不知道是spring版本的不同还是各测试的例子的不同而导致测试结果出现差异．
本人也很想弄清楚spring是如何对Service进行事务管理的，并且还去看了一下spring框架关于事务管理几个相关类的源码，可惜由于本人功力有限，只看懂了皮毛．
既然源代码看不懂，那么只有运用例子进行测试，虽然笨了点，不过管是白猫还是黑猫，能捉老鼠就是好猫．：）
为引起不必要的争论，本帖子只针对本案例的测试结果进行小结，并保证此测试代码在本人的运行环境绝对正确．

开发环境：
ＯＳ：windows 2003 Server
Web Server: jakarta-tomcat-5.0.28
DataBase Server: MS SQL Server 2000 (打了ＳＰ３补丁)
IDE:  Eclipse 3.2.0+MyEclipse 5.0GA

测试案例系统结构：
web层<---->Service层<---->DAO层

web层使用struts 1.1，DAO使用的spring的JDBC，spring版本1.2

数据库中有两张表：
student1和Student2，表结构相同：id,name,address．其中id为主键且为自增长型.
student1表中有一条记录：
Java代码 
1.    id  name       address 
2.    1   xiaoming    wuhan 
3.     
4.    student2表中记录为空 


测试情形一：
web层捕获异常并处理，DAO层不捕获异常，Service也不捕获异常．

Service层接口：
Java代码 
1.    public interface StudentManagerService { 
2.       
3.        public void  bus_method(); 
4.    } 


DAO层接口
Java代码 
1.    public interface StudentDAO { 
2.       
3.        public void  deleteStudent1(); 
4.        public void  insertStudent2(); 
5.    } 


StudentDAO接口的实现：
Java代码 
1.    public class StudentDAOImp extends JdbcDaoSupport implements StudentDAO{ 
2.         //删除student1表中的id=1的记录 
3.         public void  deleteStudent1(){ 
4.    　　　　　JdbcTemplate jt=this.getJdbcTemplate(); 
5.    　　　　　jt.update("delete from student1 where id=1");      
6.    　　　} 
7.          
8.         //将student1表中删除的记录插入到student2中,但是此方法实现有错，因为 
9.    　　　//id字段设置为自增长的，所以在插入记录时我们不能指定值 
10.        　 public void  insertStudent2(){ 
11.    　　　　　　　JdbcTemplate jt=this.getJdbcTemplate(); 
12.                String arg[]=new String[3]; 
13.           arg[0]="1"; 
14.                arg[1]="xiaoming"; 
15.           arg[2]="wuhan"; 
16.                jt.update("insert student2(id,name,address) values(?,?,?)",arg); 
17.         } 
18.     
19.    }  


StudentManagerService 接口的实现：
Java代码 
1.    public class StudentManagerServiceImp implements StudentManagerService{ 
2.      private StudentDAO  stdDAO; 
3.      
4.      public void setStdDAO(StudentDAO   stdDAO){ 
5.         this.stdDAO=stdDAO; 
6.      } 
7.        
8.      //此方法为事务型的：删除student1中的记录成功且插入student2的记录也成功， 
9.    　//如果insertStudent2()方法执行失败，那么deleteStudent1()方法也应该会失败 
10.      public void  bus_method(){ 
11.        this.stdDAO.deleteStudent1(); 
12.        this.stdDAO.insertStudent2(); 
13.      } 
14.       
15.    }  



web层:
三个jsp,一个action:
index.jsp ==>首页面．上面仅仅有一个超链接<a herf="test.do">执行</a>
chenggong.jsp ==>Service执行成功后转向的JSP页面
shibai.jsp　====>Service执行失败后转向的JSP页面

action实现：
Java代码 
1.    public class StudentManagerAction  extends  Action{ 
2.     
3.         public ActionForward execute(ActionMapping mapping, ActionForm form, 
4.        HttpServletRequest request, HttpServletResponse response) { 
5.             try{ 
6.                 WebApplicationContext appContext=WebApplicationContextUtils.  
7.                      getWebApplicationContext(this.getServlet().getServletContext()); 
8.            StudentManagerService stdm=(StudentManagerService)appContext. 
9.                                            getBean("stdServiceManager"); 
10.                stdm.bus_method(); 
11.                return mapping.findForward("chenggong"); 
12.         } 
13.         catch(DataAccessException e){ 
14.            System.err.println("action execute service exception!"); 
15.            return mapping.findForward("shibai"); 
16.          } 
17.     
18.        } 
19.    } 



配置文件：

web.xml
Java代码 
1.    <?xml version="1.0" encoding="UTF-8"?> 
2.    <web-app xmlns="http://java./xml/ns/j2ee" xmlns:xsi="http://www./2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java./xml/ns/j2ee   http://java./xml/ns/j2ee/web-app_2_4.xsd"> 
3.      <context-param> 
4.        <param-name>log4jConfigLocation</param-name> 
5.        <param-value>/WEB-INF/log4j.properties</param-value> 
6.      </context-param> 
7.      <context-param> 
8.        <param-name>contextConfigLocation</param-name> 
9.        <param-value>/WEB-INF/applicationContext.xml</param-value> 
10.      </context-param> 
11.      <listener> 
12.        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class> 
13.      </listener> 
14.      <listener> 
15.        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
16.      </listener> 
17.      <servlet> 
18.        <servlet-name>action</servlet-name> 
19.        <servlet-class>org.apache.struts.action.ActionServlet</servlet-class> 
20.        <init-param> 
21.          <param-name>config</param-name> 
22.          <param-value>/WEB-INF/struts-config.xml</param-value> 
23.        </init-param> 
24.        <init-param> 
25.          <param-name>debug</param-name> 
26.          <param-value>3</param-value> 
27.        </init-param> 
28.        <init-param> 
29.          <param-name>detail</param-name> 
30.          <param-value>3</param-value> 
31.        </init-param> 
32.        <load-on-startup>0</load-on-startup> 
33.      </servlet> 
34.      <servlet-mapping> 
35.        <servlet-name>action</servlet-name> 
36.        <url-pattern>*.do</url-pattern> 
37.      </servlet-mapping> 
38.    </web-app> 


sturts-config.xml
Java代码 
1.    <struts-config> 
2.      <action-mappings > 
3.        <action  input="/index.jsp"  path="/test"  type="test.StudentManagerAction   > 
4.          <forward name="chenggong" path="/chenggong.jsp" /> 
5.          <forward name="shibai" path="/shibai.jsp" /> 
6.        </action> 
7.      </action-mappings> 
8.      <message-resources parameter="test.ApplicationResources" /> 
9.    </struts-config> 



applicationContext.xml
Java代码 
1.    <?xml version="1.0" encoding="UTF-8"?> 
2.    <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www./dtd/spring-beans.dtd"> 
3.    <beans> 
4.        <bean id="dataSource" 
5.          class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" > 
6.          <property name="driverClassName" value="com.microsoft.jdbc.sqlserver.SQLServerDriver"></property> 
7.          <property name="url" value="jdbc:microsoft:sqlserver://127.0.0.1:1433;databasename=test"></property> 
8.           <property name="username" value="sa"></property> 
9.           <property name="password" value="sa"></property> 
10.        </bean> 
11.         
12.         <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
13.            <property name="dataSource" ref="dataSource"/> 
14.         </bean> 
15.             
16.        <bean id="baseTxProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  lazy-init="true"> 
17.            <property name="transactionManager"> 
18.            <ref bean="transactionManager" /> 
19.             </property> 
20.             <property name="transactionAttributes"> 
21.             <props> 
22.                 <prop key="*">PROPAGATION_REQUIRED</prop> 
23.            </props> 
24.             </property> 
25.        </bean> 
26.     
27.        <bean id="stdServiceManager"  parent="baseTxProxy" > 
28.            <property name="target"> 
29.                 <bean class="test.StudentManagerServiceImp">     
30.                           <property name="stdDAO"> 
31.    　　　　　　　　　             <ref bean="stdDAO"/> 
32.                           </property>     
33.                      </bean>  
34.            </property>  
35.        </bean> 
36.     
37.        <bean id="stdDAO" class="test.StudentDAOImp"> 
38.           <property name="dataSource" ref="dataSource"/> 
39.        </bean> 
40.    </beans> 


运行程序：启动服务器，并部署．进入index.jsp页面，点击"执行"超链接"---->页面跳向shibai.jsp
查看控制台：打印有：action execute service exception!
查看数据库：　student1表中的[1 xiaoming  wuhan] 记录仍然存在，student2表仍然为空．
小结：如果DAO层和Service不捕获异常而在web层捕获异常，web成功捕获异常，spring事务管理成功！


测试情形二：
web层捕获异常并处理，Service捕获异常并处理，DAO层不捕获异常．

修改StudentManagerServiceImp类
Java代码 
1.    public class StudentManagerServiceImp implements StudentManagerService{ 
2.      private StudentDAO  stdDAO; 
3.      
4.      public void setStdDAO(StudentDAO   stdDAO){ 
5.         this.stdDAO=stdDAO; 
6.      } 
7.        
8.      //此方法为事务型的，删除student1中的记录成功且插入student2的记录也成功 
9.    　//如果insertStudent2()方法执行失败，那么deleteStudent1()也应该会失败 
10.      public void  bus_method(){ 
11.       try{ 
12.          this.stdDAO.deleteStudent1(); 
13.          this.stdDAO.insertStudent2(); 
14.       } 
15.       catch(DataAccessException de) 
16.           System.err.println("service execute exception!"); 
17.        } 
18.      } 
19.       
20.    } 


运行程序：启动服务器，并部署．进入index.jsp页面，点击"执行"超链接"---->页面跳向chenggong.jsp
查看控制台：打印有：service execute exception!
查看数据库：　student1表中的[1  xiaoming  wuhan] 记录不存在，student2表仍然为空．
小结：如果Service捕获异常并处理而不向外抛出，web层捕获不到异常，spring事务管理失败！


测试情形(还原表中的数据)三：
web层捕获异常，Service捕获异常，DAO层也捕获异常．

修改StudentDAOImp类代码
Java代码 
1.    public class StudentDAOImp extends JdbcDaoSupport implements StudentDAO{ 
2.         //删除student1表中的id=1的记录 
3.         public void  deleteStudent1(){ 
4.            try{ 
5.    　　　　　JdbcTemplate jt=this.getJdbcTemplate(); 
6.    　　　　　jt.update("delete from student1 where id=1"); 
7.           } 
8.           catch(DataAccessException e){ 
9.             System.err.println("dao deleteStudent1　execute exception!"); 
10.           }      
11.    　　　} 
12.          
13.         //将student1表中删除的记录插入到student2中,但是此方法实现有错，因为 
14.    　　　//id字段设置为自增长的，所以在插入记录时我们不能指定值 
15.        　 public void  insertStudent2(){ 
16.              try{ 
17.    　　　　　　　JdbcTemplate jt=this.getJdbcTemplate(); 
18.                String arg[]=new String[3]; 
19.           arg[0]="1"; 
20.                arg[1]="xiaoming"; 
21.           arg[2]="wuhan"; 
22.                jt.update("insert student2(id,name,address) values(?,?,?)",arg); 
23.             } 
24.             catch(DataAccessException  e){ 
25.                System.err.println("dao insertStudent2  execute exception!"); 
26.     
27.             } 
28.         } 
29.     
30.    }  


运行程序：启动服务器，并部署．进入index.jsp页面，点击"执行"超链接"---->页面跳向chenggong.jsp
查看控制台：打印有：dao insertStudent2  execute exception!
查看数据库：　student1表中的 1,xiaoming,wuhan 记录不存在，student2表仍然为空．
小结如果DAO的每一个方法自己捕获异常并处理而不向外抛出，Service层捕获不到异常，Web层同样捕获不到异常，spring事务管理失败！


测试情形四：

还原数据库中的数据
还原StudentDAOImp类中的方法为测试情形一中的实现
web层捕获异常Service抛出的自定义异常StudentManagerException
Service捕获DataAccessException并抛出StudentManagerException，
StudentManagerException为DataAccessException的子类
DAO层不捕获异常

修改StudentManagerServiceImp类的实现：
Java代码 
1.    public class StudentManagerServiceImp implements StudentManagerService{ 
2.      private StudentDAO  stdDAO; 
3.      
4.      public void setStdDAO(StudentDAO   stdDAO){ 
5.         this.stdDAO=stdDAO; 
6.      } 
7.        
8.      //此方法为事务型的，删除student1中的记录成功且插入student2的记录也成功 
9.    　//如果insertStudent2()方法执行失败，那么deleteStudent1()也应该会失败 
10.      public void  bus_method() throws StudentManagerException{ 
11.       try{ 
12.          this.stdDAO.deleteStudent1(); 
13.          this.stdDAO.insertStudent2(); 
14.       } 
15.       catch(DataAccessException de) 
16.           System.err.println("service execute exception!"); 
17.    　　　　　throw new StudentManagerException();//StudentManagerException类继承DataAcce　　　　　　　　　　　　　　　　　　　　　　　　　　//ssException异常 
18.        } 
19.      } 
20.    } 



修改StudentManagerAction 
Java代码 
1.    public class StudentManagerAction  extends  Action{ 
2.     
3.         public ActionForward execute(ActionMapping mapping, ActionForm form, 
4.        HttpServletRequest request, HttpServletResponse response) { 
5.             try{ 
6.                 WebApplicationContext appContext=WebApplicationContextUtils.  
7.                      getWebApplicationContext(this.getServlet().getServletContext()); 
8.            StudentManagerService stdm=(StudentManagerService)appContext. 
9.                                            getBean("stdServiceManager"); 
10.                stdm.bus_method(); 
11.                return mapping.findForward("chenggong"); 
12.         } 
13.         catch(StudentManagerException　e){ 
14.            System.err.println("action execute service exception!"); 
15.            return mapping.findForward("shibai"); 
16.          } 
17.     
18.        } 
19.    } 

运行程序：启动服务器，并部署．进入index.jsp页面，点击"执行"超链接"---->页面跳向shibai.jsp
查看控制台：打印有：service execute exception!
action execute service exception!
查看数据库：　student1表中的 [1,xiaoming,wuhan] 记录仍然存在，student2表仍然为空．
小结如果DAO的每一个方法不捕获异常,Service层捕获DataAccessException异常并抛出自己定义异常(自定义异常为DataAccessException的子类)，Web层可以捕获到异常，spring事务管理成功！



结合源码总结：
1.spring在进行声明时事务管理时，通过捕获Service层方法的DataAccessException来提交和回滚事务的，而Service层方法的DataAccessException又是来自调用DAO层方法所产生的异常．

2.我们一般在写DAO层代码时，如果继承JdbcDaoSupport 类，并使用此类所实现的JdbcTemplate来执行数据库操作，此类会自动把低层的SQLException转化成 DataAccessException以及DataAccessException
的子类．

3.一般在Service层我们可以自己捕获DAO方法所产成的DataAccessException，然后再抛出一个业务方法有意义的异常 (ps:此异常最好继承DataAccessException)，然后在Web层捕获，这样我们就可以手动编码的灵活实现通过业务方法执行的成功和失败 来向用户转发不同的页面．