`

spring管理统一异常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层的异常处理。

 

1、定义接口

 

 

[java] view plaincopyprint?
  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. }  

 

 

2、实现

 

 

[java] view plaincopyprint?
  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 plaincopyprint?
  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 plaincopyprint?
  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就会拦截到该异常，并获取该异常的详细信息。

分享到：
| Socket 短连接、长连接
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics