系统的异常处理机制是衡量一个系统设计的关键因素，良好的异常处理机制能在系统出现异常时准确的找到问题的所在。
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、定义接口
1. package
2. import
3. import
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
13. public boolean userExsit(String username) throws
14. public User findById(int id) throws
15. public List<User> queryUser(String hql,int beginIndex) throws
16. public void saveUser(User user) throws
17. public int gettotalSize(String hql) throws
18. }
2、实现
1. package
2. import
3. import
4. import
5. import
6. import
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
16. public User findById(int id) throws
17. null;
18. try
19. this.getHibernateTemplate().get(User.class, id);
20. catch
21. e.printStackTrace();
22. throw new Exception("主键查询用户失败", e);
23. }
24. return
25. }
26. public void saveUser(User user) throws
27. try
28. this.getHibernateTemplate().save(user);
29. catch
30. e.printStackTrace();
31. throw new Exception("增加用户失败", e);
32. }
33. }
34. @SuppressWarnings("unchecked")
35. public List<User> queryUser(String hql, int beginIndex) throws
36. try
37. return (List<User>) this.getHibernateTemplate().getSessionFactory()
38. .getCurrentSession().createQuery(hql).setFirstResult(
39. beginIndex).setMaxResults(
40. PropertyUtil.getPageSize()).list();
41. catch
42. e.printStackTrace();
43. throw new Exception("查询用户出现异常", e);
44. }
45. }
46. public boolean userExsit(String username) throws
47. boolean bl = true;
48. "from User where username='" + username + "'";
49. if (queryUser(hql, 0).size() == 0) {
50. false;
51. }
52. return
53. }
54. public int gettotalSize(String hql) throws
55. int totalsize = 0;
56. try
57. this.getHibernateTemplate().find(hql)
58. 0).toString());
59. catch
60. e.printStackTrace();
61. throw new Exception("查询用户总数失败", e);
62. }
63. return
64. }
65. }
这里需要说明的是，这里的异常我没有细致的分类，都是throws Exception。
service层的代码就省略了，因为只是调用DAO层的方法，下面来写异常的拦截
1. package
2. import
3. import
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
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
18. RuntimeException throwable) {
19. "产生异常的方法名称： "
20.
21. for(Object o:args){
22. "方法的参数： "
23. }
24.
25. "代理对象： "
26. "抛出的异常: " + throwable.getMessage()+">>>>>>>"
27. + throwable.getCause());
28. "异常详细信息： "+throwable.fillInStackTrace());
29. }
30. }
最后当然就是在配置文件里面配置了
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就会拦截到该异常，并获取该异常的详细信息。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
