spring AOP的異常攔截

系統的異常處理機制是衡量一個系統設計的關鍵因素，良好的異常處理機制能在系統出現異常時準確的找到問題的所在。

spring aop對異常的處理有良好的支持。spring 提供了一個接口 ThrowsAdvice，該接口裏面沒有任何方法，可是實現類裏面必須的實現

afterThrowing(Method method, Object[] args, Object target, RuntimeException  throwable) 或者

afterThrowing(RuntimeException  throwable)

 

若是須要記錄發生異常方法的詳細信息，則實現第一個方法就行，若是隻記錄發生的異常，實現第二個方法就ok！

 

那麼異常的處理應該在什麼位置來作處理呢？

通常咱們的系統都應該有如下幾個層次：Action--->Service---->DAO

 

DAO負責直接和數據庫打交道，也是發生異常頻率較高的地方，而service只是調用DAO所提供給外面的接口，action裏面大部分的操做也是調用service的服務，再加上少數其餘的邏輯，這部分的異常能夠單獨處理！下面咱們主要關心DAO層的異常處理。

 

一、定義接口

 

[java] view plain copy

1. package com.beckham.dao;  
2. import java.util.List;  
3. import com.beckham.model.User;  
4. /** 
5.  *  @author Owner 
6.  *  Jan 19, 2010   10:15:32 PM 
7.  *   
8.  *  struts2 
9.  *  com.beckham.dao 
10.  *  UserDAO.java 
11.  */  
12. public interface UserDAO {  
13.     public boolean userExsit(String username) throws Exception;  
14.     public User findById(int id) throws Exception;  
15.     public List<User> queryUser(String hql,int beginIndex) throws Exception;  
16.     public void saveUser(User user) throws Exception;  
17.     public  int gettotalSize(String hql) throws Exception ;  
18. }  

 

二、實現

 

[java] view plain copy

1. package com.beckham.daoimp;  
2. import java.util.List;  
3. import com.beckham.dao.SuperDAO;  
4. import com.beckham.dao.UserDAO;  
5. import com.beckham.model.User;  
6. import com.beckham.util.PropertyUtil;  
7. /** 
8.  *  @author Owner 
9.  *  Jan 19, 2010   10:15:50 PM 
10.  *   
11.  *  struts2 
12.  *  com.beckham.daoimp 
13.  *  UserDAOImp.java 
14.  */  
15. public class UserDAOImp extends SuperDAO implements UserDAO {  
16.     public User findById(int id) throws Exception {  
17.         User user = null;  
18.         try {  
19.             user = (User) this.getHibernateTemplate().get(User.class, id);  
20.         } catch (Exception e) {  
21.             e.printStackTrace();  
22.             throw new Exception("主鍵查詢用戶失敗", e);  
23.         }  
24.         return user;  
25.     }  
26.     public void saveUser(User user) throws Exception {  
27.         try {  
28.             this.getHibernateTemplate().save(user);  
29.         } catch (Exception e) {  
30.             e.printStackTrace();  
31.             throw new Exception("增長用戶失敗", e);  
32.         }  
33.     }  
34.     @SuppressWarnings("unchecked")  
35.     public List<User> queryUser(String hql, int beginIndex) throws Exception {  
36.         try {  
37.             return (List<User>) this.getHibernateTemplate().getSessionFactory()  
38.                     .getCurrentSession().createQuery(hql).setFirstResult(  
39.                             beginIndex).setMaxResults(  
40.                             PropertyUtil.getPageSize()).list();  
41.         } catch (Exception e) {  
42.             e.printStackTrace();  
43.             throw new Exception("查詢用戶出現異常", e);  
44.         }  
45.     }  
46.     public boolean userExsit(String username) throws Exception {  
47.         boolean bl = true;  
48.             String hql = "from User where username='" + username + "'";  
49.                 if (queryUser(hql, 0).size() == 0) {  
50.                     bl = false;  
51.                 }     
52.         return bl;  
53.     }  
54.     public int gettotalSize(String hql) throws Exception {  
55.         int totalsize = 0;  
56.         try {  
57.             totalsize = Integer.parseInt(this.getHibernateTemplate().find(hql)  
58.                     .get(0).toString());  
59.         } catch (Exception e) {  
60.             e.printStackTrace();  
61.             throw new Exception("查詢用戶總數失敗", e);  
62.         }  
63.         return totalsize;  
64.     }  
65. }  

 

這裏須要說明的是，這裏的異常我沒有細緻的分類，都是throws Exception。

 

service層的代碼就省略了，由於只是調用DAO層的方法，下面來寫異常的攔截

 

[java] view plain copy

1. package com.beckham.aop;  
2. import java.lang.reflect.Method;  
3. import org.springframework.aop.ThrowsAdvice;  
4. /** 
5.  * @author Owner Jan 18, 2010 2:37:10 PM 處理DAO層的異常 struts2 com.beckham.aop 
6.  *         ExceptionLog.java 
7.  */  
8. public class ExceptionLog implements ThrowsAdvice {  
9.     /** 
10.      * Owner  
11.      * 參數解釋 Method method 執行的方法  
12.      * Object[] args 方法參數 
13.      *  Object target 代理的目標對象 
14.      * Throwable throwable 產生的異常  
15.      * Jan 18, 2010 3:21:46 PM 
16.      */  
17.     public void afterThrowing(Method method, Object[] args, Object target,  
18.             RuntimeException  throwable) {  
19.         System.out.println("產生異常的方法名稱：  " + method.getName());  
20.           
21.         for(Object o:args){  
22.             System.out.println("方法的參數：   " + o.toString());  
23.         }  
24.           
25.         System.out.println("代理對象：   " + target.getClass().getName());  
26.         System.out.println("拋出的異常:    " + throwable.getMessage()+">>>>>>>"  
27.                 + throwable.getCause());  
28.         System.out.println("異常詳細信息：　　　"+throwable.fillInStackTrace());  
29.     }  
30. }  

 

最後固然就是在配置文件裏面配置了

 

[xhtml] view plain copy

1. <bean id="log" class="com.beckham.aop.LogAdvice"></bean>  
2.     <bean id="exceptionLog" class="com.beckham.aop.ExceptionLog"></bean>  
3.     <!-- beanName自動代理 -->  
4.     <bean id="logAdvice"  
5.         class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
6.         <property name="beanNames">  
7.             <list>  
8.                 <value>userDAO</value>  
9.             </list>  
10.         </property>  
11.         <property name="interceptorNames">  
12.         <list>  
13.             <value>log</value>  
14.             <value>exceptionLog</value>  
15.         </list>  
16.         </property>  
17.     </bean>  

 

到此，經過spring AOP攔截異常就完成了，這裏只是攔截DAO層的異常，此方法的好處就是處理異常和功能實現徹底分離開，只須要在寫方法的時候要記得拋出相應的異常，當出現異常時ThrowsAdvice就會攔截到該異常，並獲取該異常的詳細信息。