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 plain copy print ?

1. package com.beckham.dao;
2. import java.util.List;
3. import com.beckham.model.User;
4. 
   
5. public interface UserDAO {
6. public boolean userExsit(String username) throws Exception;
7. public User findById(int id) throws Exception;
8. public List<User> queryUser(String hql,int beginIndex) throws Exception;
9. public void saveUser(User user) throws Exception;
10. public int gettotalSize(String hql) throws Exception ;
11. }

2、实现

[java] view plain copy print ?

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. public class UserDAOImp extends SuperDAO implements UserDAO {
9. public User findById(int id) throws Exception {
10. User user = null;
11. try {
12. user = (User) this.getHibernateTemplate().get(User.class, id);
13. } catch (Exception e) {
14. e.printStackTrace();
15. throw new Exception("主键查询用户失败", e);
16. }
17. return user;
18. }
19. public void saveUser(User user) throws Exception {
20. try {
21. this.getHibernateTemplate().save(user);
22. } catch (Exception e) {
23. e.printStackTrace();
24. throw new Exception("增加用户失败", e);
25. }
26. }
27. @SuppressWarnings("unchecked")
28. public List<User> queryUser(String hql, int beginIndex) throws Exception {
29. try {
30. return (List<User>) this.getHibernateTemplate().getSessionFactory()
31. .getCurrentSession().createQuery(hql).setFirstResult(
32. beginIndex).setMaxResults(
33. PropertyUtil.getPageSize()).list();
34. } catch (Exception e) {
35. e.printStackTrace();
36. throw new Exception("查询用户出现异常", e);
37. }
38. }
39. public boolean userExsit(String username) throws Exception {
40. boolean bl = true;
41. String hql = "from User where username='" + username + "'";
42. if (queryUser(hql, 0).size() == 0) {
43. bl = false;
44. }
45. return bl;
46. }
47. public int gettotalSize(String hql) throws Exception {
48. int totalsize = 0;
49. try {
50. totalsize = Integer.parseInt(this.getHibernateTemplate().find(hql)
51. .get(0).toString());
52. } catch (Exception e) {
53. e.printStackTrace();
54. throw new Exception("查询用户总数失败", e);
55. }
56. return totalsize;
57. }
58. }

这里需要说明的是，这里的异常我没有细致的分类，都是throws Exception。

service层的代码就省略了，因为只是调用DAO层的方法，下面来写异常的拦截

[java] view plain copy print ?

1. package com.beckham.aop;
2. import java.lang.reflect.Method;
3. import org.springframework.aop.ThrowsAdvice;
4. 
   
5. public class ExceptionLog implements ThrowsAdvice {
6. 
   
7. public void afterThrowing(Method method, Object[] args, Object target,
8. RuntimeException throwable) {
9. System.out.println("产生异常的方法名称： " + method.getName());
10. for(Object o:args){
11. System.out.println("方法的参数： " + o.toString());
12. }
13. System.out.println("代理对象： " + target.getClass().getName());
14. System.out.println("抛出的异常: " + throwable.getMessage()+">>>>>>>"
15. + throwable.getCause());
16. System.out.println("异常详细信息：　　　"+throwable.fillInStackTrace());
17. }
18. }

最后当然就是在配置文件里面配置了

[xhtml] view plain copy print ?

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