java中从Spring、Hibernate和Struts框架的action、service和dao三层结构异常处理体系设计

Spring的事务实现采用基于AOP的拦截器来实现，如果没有在事务配置的时候注明回滚的checked exception，那么只有在发生了unchecked exception的时候，才会进行事务回滚。因此在DAO层和service层，最好抛出unckecked exception，毕竟对于数据库操作，使用unckecked exception更加合适，这个方面的例子hibernate就是一个，在hibernate2中，HibernateException还是checked exceptions，但是到了hibernate3中就成了unchecked exceptions，因为对于数据库操作来说，一旦出现异常，就是比较严重的错误，而且在client端基本上是无能为力的，所以使用unchecked exceptions更加合适。

另外，在DAO和service层的代码中，除非是为了异常的转化、重新抛出，否则不要捕捉和处理异常，否则AOP在拦截的时候就不能捕捉到异常，也就不能正确执行回滚。这一点通常很容易被忽视，只有在明白了spring的事务处理机制后，才能领会到。

对于hibernate的异常，spring会包装hibernate的upckecked hibernateException到DAOAccessException，并且抛出，在事务管理层，一旦接收到DAOAccessException就会触发事务的回滚，同时该异常会继续向上层抛出，供上层进一步处理，比如在UI层向用户反馈错误信息等。

1. class NewException extends Exception {
2. }
3. public class ExceptionTest {
4. public void test() {
5. try {
6. throw new NewException();
7. } catch (NewException e) {
8. //throw new RuntimeException("检测异常转为非检测异常。", e);
9. throw new RuntimeException("检测异常转为非检测异常。");
10. }
11. }
12. public static void main(String[] args) {
13. ExceptionTest et = new ExceptionTest();
14. et.test();
15. }
16. }
17. /*
18. throw new RuntimeException("检测异常转为非检测异常。", e)结果：
19. Exception in thread "main" java.lang.RuntimeException: 检测异常转为非检测异常。
20. at cn.yang.ExceptionTest.test(ExceptionTest.java:12)
21. at cn.yang.ExceptionTest.main(ExceptionTest.java:18)
22. Caused by: cn.yang.NewException
23. at cn.yang.ExceptionTest.test(ExceptionTest.java:10)
24. ... 1 more
25. */
26. /*
27. throw new RuntimeException("检测异常转为非检测异常。")结果：
28. Exception in thread "main" java.lang.RuntimeException: 检测异常转为非检测异常。
29. at cn.yang.ExceptionTest.test(ExceptionTest.java:12)
30. at cn.yang.ExceptionTest.main(ExceptionTest.java:18)
31. */

public class DefaultFooService implements FooService {
    public Foo getFoo(String fooName) {
        throw new UnsupportedOperationException();
    }

public Foo getFoo(String fooName, String barName) {
        throw new UnsupportedOperationException();
    }

public void insertFoo(Foo foo)throws DataAccessException {
        throw new PermissionDeniedDataAccessException("执行事务操作时发生异常",new UnsupportedOperationException());
    }

public void updateFoo(Foo foo) {
        throw new UnsupportedOperationException();
    }
}

public final class Boot {

public static void main(final String[] args) throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "applicationContext.xml",Boot.class);
        FooService fooService = (FooService) ctx.getBean("fooService");
        try {
            fooService.insertFoo(new Foo());
        } catch (DataAccessException e) {
            System.out.println("事务操作出现异常");
        }
        
        
    }
}

public class Foo {
}

import org.springframework.dao.DataAccessException;

public interface FooService {
    
    Foo getFoo(String fooName);

Foo getFoo(String fooName, String barName);

void insertFoo(Foo foo)throws DataAccessException;

void updateFoo(Foo foo)throws DataAccessException;
}

<!-- this is the service object that we want to make transactional -->
    <bean id="fooService" class="x.y.service.DefaultFooService" />

<!-- the transactional advice (i.e. what 'happens'; see the <aop:advisor/> bean below) -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <!-- the transactional semantics -->
        <tx:attributes>
            <!-- all methods starting with 'get' are read-only -->
            <tx:method name="get*" read-only="true" />

<!-- other methods use the default transaction settings (see below) -->
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>

<!-- ensure that the above transactional advice runs for any execution
        of an operation defined by the FooService interface -->
    <aop:config>
        <aop:pointcut id="fooServiceOperation"
            expression="execution(* x.y.service.FooService.*(..))" />
        <aop:advisor advice-ref="txAdvice"
            pointcut-ref="fooServiceOperation" />
    </aop:config>

<!-- don't forget the DataSource -->
    <bean id="dataSource"
        class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="org.h2.Driver" />
        <property name="url"
            value="jdbc:h2:tcp://localhost/D:/try/data/sample;IFEXISTS=TRUE" />
        <property name="username" value="sa" />
        <property name="password" value="123456" />
    </bean>

<!-- similarly, don't forget the PlatformTransactionManager -->
    <bean id="txManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- other <bean/> definitions here -->
</beans>

1. <property name="transactionAttributes">
2. <props>
3. <prop key="insert*">PROPAGATION_REQUIRED,- MyCheckedException,+MyUnCheckedException</prop>
4. <prop key="update*">PROPAGATION_REQUIRED</prop>
5. <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
6. </props>
7. </property>