Spring访问数据库异常的处理方法
摘要：天我们将谈谈Spring访问数据库异常的处理方法，使用JDBC API时，很多操作都要声明抛出java.sql.SQLException异常，通常情况下是要制定异常处理策略。
使用JDBC API时，很多操作都要声明抛出java.sql.SQLException异常，通常情况下是要制定异常处理策略。而Spring的JDBC模块为我们提供了一套异常处理机制，这套异常系统的基类是DataAccessException，它是RuntimeException的一种类型，那么就不用强制去捕捉异常了，Spring的异常体系如下： 
目前为止我们还没有明确地处理Spring中JDBC模块的异常。要理解它的异常处理机制，我们来做几个测试。看下面的测试代码：
1. public void insert(final Vehicle vehicle) {
2. String sql = "insert into vehicle
3. (ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT) values
4. (:id,:plate,:chassis,:color,:wheel,:seat)";
5. SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(
6. vehicle);
7. getSimpleJdbcTemplate().update(sql, parameterSource);
8. }
9. public void insert(final Vehicle vehicle) {
10. String sql = "insert into vehicle(ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT)
11. values(:id,:plate,:chassis,:color,:wheel,:seat)";
12. SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(
13. vehicle);
14. getSimpleJdbcTemplate().update(sql, parameterSource);
15. }
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"classpath:org/ourpioneer/vehicle/spring/applicationContext.xml");
VehicleDAO vehicleDAO = (VehicleDAO) ctx.getBean("vehicleDAO");
Vehicle vehicle = new Vehicle("辽B-000000", "1A00000001", "RED", 4, 4);
vehicle.setId(1);
vehicleDAO.insert(vehicle);
}
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"classpath:org/ourpioneer/vehicle/spring/applicationContext.xml");
VehicleDAO vehicleDAO = (VehicleDAO) ctx.getBean("vehicleDAO");
Vehicle vehicle = new Vehicle("辽B-000000", "1A00000001", "RED", 4, 4);
vehicle.setId(1);
vehicleDAO.insert(vehicle);
}
修改SQL语句，不使用自增主键的特性，并在这里设置重复的主键，那么运行程序，就会报出字段重复的异常。下面来捕捉这个异常：
1. try {
2. vehicleDAO.insert(vehicle);
3. } catch (DataAccessException e) {
4. SQLException sqle = (SQLException) e.getCause();
5. System.out.println("Error code: " + sqle.getErrorCode());
6. System.out.println("SQL state: " + sqle.getSQLState());
7. }
8. try {
9. vehicleDAO.insert(vehicle);
10. } catch (DataAccessException e) {
11. SQLException sqle = (SQLException) e.getCause();
12. System.out.println("Error code: " + sqle.getErrorCode());
13. System.out.println("SQL state: " + sqle.getSQLState());
14. }
此时，我们就可以获得错误码和SQL状态（不同的数据库系统会有不同）：
关于HSQL数据库的错误码可以到org.hsqldb.Trace类中查看，只要注意运行结果会有一个负号，而类中定义的是没有负号的。这样就知道了这个错误的具体含义，比如104：唯一约束验证失败。这就是我们故意设置的重复主键问题。
Spring的JDBC模块为我们预定义了一些错误代码，它存储在org.springframework.jdbc.support包下的sql-error-codes.xml文件中，其中描述HSQL的内容为：
1. bean id="HSQL" class="org.springframework.jdbc.support.SQLErrorCodes"
2. property name="databaseProductName"
3. valueHSQL Database Engine/value
4. /property
5. property name="badSqlGrammarCodes"
6. value-22,-28/value
7. /property
8. property name="duplicateKeyCodes"
9. value-104/value
10. /property
11. property name="dataIntegrityViolationCodes"
12. value-9/value
13. /property
14. property name="dataAccessResourceFailureCodes"
15. value-80/value
16. /property
17. /bean
18. bean id="HSQL" class="org.springframework.jdbc.support.SQLErrorCodes"
19. property name="databaseProductName"
20. valueHSQL Database Engine/value
21. /property
22. property name="badSqlGrammarCodes"
23. value-22,-28/value
24. /property
25. property name="duplicateKeyCodes"
26. value-104/value
27. /property
28. property name="dataIntegrityViolationCodes"
29. value-9/value
30. /property
31. property name="dataAccessResourceFailureCodes"
32. value-80/value
33. /property
34. /bean
其余数据库的错误码内容也可以从这个文件之中获得。下面我们来看看如何自定义异常处理。上面我们已经知道在org.springframework.jdbc.support包下有sql-error-codes.xml文件，在Spring启动时会自动读取这个文件中的错误码，它为我们预分类了一些错误码，而我们可以加强它，来使用我们自定义的异常。首先，定义一个异常类，我们就来自定义一下前面的-104错误，就是HSQL的重复键的问题：
1. package org.ourpioneer.vehicle.exception;
2. import org.springframework.dao.DataIntegrityViolationException;
3. public class VehicleDuplicateKeyException extends
4. DataIntegrityViolationException {
5. public VehicleDuplicateKeyException(String msg) {
6. super(msg);
7. }
8. public VehicleDuplicateKeyException(String msg, Throwable cause) {
9. super(msg, cause);
10. }
11. }
12. package org.ourpioneer.vehicle.exception;
13. import org.springframework.dao.DataIntegrityViolationException;
14. public class VehicleDuplicateKeyException extends
15. DataIntegrityViolationException {
16. public VehicleDuplicateKeyException(String msg) {
17. super(msg);
18. }
19. public VehicleDuplicateKeyException(String msg, Throwable cause) {
20. super(msg, cause);
21. }
22. }
之后我们重新新建一个sql-error-codes.xml代码，并将它放到类路径的根目录下，这样Spring会发现它并使用我们自定义的文件，在配置中定义如下：
1. bean id="HSQL" class="org.springframework.jdbc.support.SQLErrorCodes"
2. property name="databaseProductName" value="HSQL Database Engine" /
3. property name="useSqlStateForTranslation" value="false" /
4. property name="customTranslations"
5. list
6. ref local="vehicleDuplicateKeyTranslation" /
7. /list
8. /property
9. /bean
10. bean id="vehicleDuplicateKeyTranslation"
11. class="org.springframework.jdbc.support.CustomSQLErrorCodesTranslation"
12. property name="errorCodes" value="-104" /
13. property name="exceptionClass"
14. value="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyException" /
15. /bean
16. bean id="HSQL" class="org.springframework.jdbc.support.SQLErrorCodes"
17. property name="databaseProductName" value="HSQL Database Engine" /
18. property name="useSqlStateForTranslation" value="false" /
19. property name="customTranslations"
20. list
21. ref local="vehicleDuplicateKeyTranslation" /
22. /list
23. /property
24. /bean
25. bean id="vehicleDuplicateKeyTranslation"
26. class="org.springframework.jdbc.support.CustomSQLErrorCodesTranslation"
27. property name="errorCodes" value="-104" /
28. property name="exceptionClass"
29. value="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyException" /
30. /bean
HSQL的bean的名称不要改，并将useSqlStateForTranslation置为false，就可以使用我们自己定义的异常类了。在主函数中移除try/catch块，启动程序，我们就可以看到如下内容：
从启动信息中可以发现Spring发现了我们自定义的sql-error-codes.xml，并替换其中的HSQL数据库处理部分，使用了我们定义的异常，模拟出主键重复的异常后，VehicleDuplicateKeyException就抛出了。除此之外，还可以实现SQLExceptionTranslator接口，并在JDBC模板中注入其实例来实现异常控制，我们来看一下，首先创建一个Translator类：
1. package org.ourpioneer.vehicle.exception;
2. import java.sql.SQLException;
3. import org.springframework.dao.DataAccessException;
4. import org.springframework.jdbc.UncategorizedSQLException;
5. import org.springframework.jdbc.support.SQLExceptionTranslator;
6. public class VehicleDuplicateKeyTranslator implements SQLExceptionTranslator {
7. public DataAccessException translate(String task, String sql,
8. SQLException ex) {
9. if (task == null) {
10. task = "";
11. }
12. if (sql == null) {
13. }
14. if (ex.getErrorCode() == -104) {
15. return new VehicleDuplicateKeyException(buildMessage(task, sql, ex));
16. } else {
17. return new UncategorizedSQLException(task, sql, ex);
18. }
19. }
20. private String buildMessage(String task, String sql, SQLException ex) {
21. return "数据库操作异常：" + task + "; SQL [" + sql + "]; " + ex.getMessage();
22. }
23. }
24. package org.ourpioneer.vehicle.exception;
25. import java.sql.SQLException;
26. import org.springframework.dao.DataAccessException;
27. import org.springframework.jdbc.UncategorizedSQLException;
28. import org.springframework.jdbc.support.SQLExceptionTranslator;
29. public class VehicleDuplicateKeyTranslator implements SQLExceptionTranslator {
30. public DataAccessException translate(String task, String sql,
31. SQLException ex) {
32. if (task == null) {
33. task = "";
34. }
35. if (sql == null) {
36. }
37. if (ex.getErrorCode() == -104) {
38. return new VehicleDuplicateKeyException(buildMessage(task, sql, ex));
39. } else {
40. return new UncategorizedSQLException(task, sql, ex);
41. }
42. }
43. private String buildMessage(String task, String sql, SQLException ex) {
44. return "数据库操作异常：" + task + "; SQL [" + sql + "]; " + ex.getMessage();
45. }
46. }
其中，要覆盖translate方法，方法有三个参数，task表示当前操作要进行的任务是什么，sql就是执行的sql语句，ex表示SQLException，我们可以从中获取异常信息，其处理代码仅仅捕捉了错误码为-104（HSQL数据库）的错误，其余的配置信息可以根据需要来自行添加。之后要在Spring中重新配置它们：
1. bean id="vehicleDuplicateKeyTranslator"
2. class="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyTranslator"/bean
3. bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
4. property name="exceptionTranslator" ref="vehicleDuplicateKeyTranslator" /
5. property name="dataSource" ref="dataSource" /
6. /bean
7. bean id="vehicleDAO" class="org.ourpioneer.vehicle.dao.VehicleDAOImpl"
8. property name="jdbcTemplate" ref="jdbcTemplate" /
9. /bean
10. bean id="vehicleDuplicateKeyTranslator"
11. class="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyTranslator"/bean
12. bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
13. property name="exceptionTranslator" ref="vehicleDuplicateKeyTranslator" /
14. property name="dataSource" ref="dataSource" /
15. /bean
16. bean id="vehicleDAO" class="org.ourpioneer.vehicle.dao.VehicleDAOImpl"
17. property name="jdbcTemplate" ref="jdbcTemplate" /
18. /bean
调整DAO实现类的代码：
1. public class VehicleDAOImpl extends SimpleJdbcDaoSupport implements VehicleDAO {
2. … …
3. public void insert(final Vehicle vehicle) {
4. String sql = "insert into vehicle(ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?,?)";
5. getJdbcTemplate().update(sql, vehicle.getId(),vehicle.getPlate(),vehicle.getChassis(),vehicle.getColor(),vehicle.getWheel(),vehicle.getSeat());
6. }
7. … …
8. }
9. public class VehicleDAOImpl extends SimpleJdbcDaoSupport implements VehicleDAO {
10. … …
11. public void insert(final Vehicle vehicle) {
12. String sql = "insert into vehicle(ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?,?)";
13. getJdbcTemplate().update(sql, vehicle.getId(),vehicle.getPlate(),vehicle.getChassis(),vehicle.getColor(),vehicle.getWheel(),vehicle.getSeat());
14. }
15. … …
16. }
为了进行测试，其它代码可不用修改，这样继续运行测试程序，同时将sql-error-codes.xml文件从类路径的根路径下去除，就可以得到如下结果：
Spring的JDBC模块在自定义异常处理上也非常灵活，可以选择自己喜欢的方式来实现。希望对使用者有用，欢迎交流，下一部分开始介绍Spring的ORM。