Spring访问数据库异常的处理方法

使用JDBC API时，很多操作都要声明抛出java.sql.SQLException异常，通常情况下是要制定异常处理策略。而Spring的JDBC模块为我们提供了一套异常处理机制，这套异常系统的基类是DataAccessException，它是RuntimeException的一种类型，那么就不用强制去捕捉异常了，Spring的异常体系如下：

专注于为中小企业提供成都做网站、网站建设服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业璧山免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了成百上千家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

目前为止我们还没有明确地处理Spring中JDBC模块的异常。要理解它的异常处理机制，我们来做几个测试。看下面的测试代码：

 
 
 
 
      
  
  
  
  1.  public void insert(final Vehicle vehicle) {      
    2.   
  
  
  
  2. String sql = "insert into vehicle  
    3.   
  
  
  
  3. (ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT) values  
    4.   
  
  
  
  4. (:id,:plate,:chassis,:color,:wheel,:seat)";      
    5.   
  
  
  
  5.     SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(      
    6.   
  
  
  
  6.             vehicle);      
    7.   
  
  
  
  7.     getSimpleJdbcTemplate().update(sql, parameterSource);      
    8.   
  
  
  
  8. }     
    9.   
  
  
  
  9.     public void insert(final Vehicle vehicle) {  
    10.   
  
  
  
  10.         String sql = "insert into vehicle(ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT) 
    11.   
  
  
  
  11. values(:id,:plate,:chassis,:color,:wheel,:seat)";  
    12.   
  
  
  
  12.         SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(  
    13.   
  
  
  
  13.                 vehicle);  
    14.   
  
  
  
  14.         getSimpleJdbcTemplate().update(sql, parameterSource);  
    15.   
  
  
  
  15.     } 
    16.  
 
 


 
 
 
 
      
  
  
  
  1.      public static void main(String[] args) {      
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.         ApplicationContext ctx = new ClassPathXmlApplicationContext(       
    4.   
  
  
  
  4.  "classpath:org/ourpioneer/vehicle/spring/applicationContext.xml");      
    5.   
  
  
  
  5.         VehicleDAO vehicleDAO = (VehicleDAO) ctx.getBean("vehicleDAO");      
    6.   
  
  
  
  6.         Vehicle vehicle = new Vehicle("辽B-000000", "1A00000001", "RED", 4, 4);      
    7.   
  
  
  
  7.         vehicle.setId(1);      
    8.   
  
  
  
  8.             vehicleDAO.insert(vehicle);      
    9.   
  
  
  
  9. }     
    10.   
  
  
  
  10.     public static void main(String[] args) {  
    11.   
  
  
  
  11.         ApplicationContext ctx = new ClassPathXmlApplicationContext(       
    12.   
  
  
  
  12.  "classpath:org/ourpioneer/vehicle/spring/applicationContext.xml");  
    13.   
  
  
  
  13.         VehicleDAO vehicleDAO = (VehicleDAO) ctx.getBean("vehicleDAO");  
    14.   
  
  
  
  14.         Vehicle vehicle = new Vehicle("辽B-000000", "1A00000001", "RED", 4, 4);  
    15.   
  
  
  
  15.         vehicle.setId(1);  
    16.   
  
  
  
  16.             vehicleDAO.insert(vehicle);  
    17.   
  
  
  
  17. } 
    18.

修改SQL语句，不使用自增主键的特性，并在这里设置重复的主键，那么运行程序，就会报出字段重复的异常。下面来捕捉这个异常：

 
 
 
 
      
  
  
  
  1. try {      
    2.   
  
  
  
  2.     vehicleDAO.insert(vehicle);      
    3.   
  
  
  
  3. } catch (DataAccessException e) {      
    4.   
  
  
  
  4.     SQLException sqle = (SQLException) e.getCause();      
    5.   
  
  
  
  5.     System.out.println("Error code: " + sqle.getErrorCode());      
    6.   
  
  
  
  6.     System.out.println("SQL state: " + sqle.getSQLState());      
    7.   
  
  
  
  7. }     
    8.   
  
  
  
  8.         try {  
    9.   
  
  
  
  9.             vehicleDAO.insert(vehicle);  
    10.   
  
  
  
  10.         } catch (DataAccessException e) {  
    11.   
  
  
  
  11.             SQLException sqle = (SQLException) e.getCause();  
    12.   
  
  
  
  12.             System.out.println("Error code: " + sqle.getErrorCode());  
    13.   
  
  
  
  13.             System.out.println("SQL state: " + sqle.getSQLState());  
    14.   
  
  
  
  14.         } 
    15.

此时，我们就可以获得错误码和SQL状态（不同的数据库系统会有不同）：

关于HSQL数据库的错误码可以到org.hsqldb.Trace类中查看，只要注意运行结果会有一个负号，而类中定义的是没有负号的。这样就知道了这个错误的具体含义，比如104：***约束验证失败。这就是我们故意设置的重复主键问题。

Spring的JDBC模块为我们预定义了一些错误代码，它存储在org.springframework.jdbc.support包下的sql-error-codes.xml文件中，其中描述HSQL的内容为：

 
 
 
 
      
  
  
  
  1.     
    2.   
  
  
  
  2.          
    3.   
  
  
  
  3.         HSQL Database Engine     
    4.   
  
  
  
  4.          
    5.   
  
  
  
  5.          
    6.   
  
  
  
  6.         -22,-28     
    7.   
  
  
  
  7.          
    8.   
  
  
  
  8.          
    9.   
  
  
  
  9.         -104     
    10.   
  
  
  
  10.          
    11.   
  
  
  
  11.          
    12.   
  
  
  
  12.         -9     
    13.   
  
  
  
  13.          
    14.   
  
  
  
  14.          
    15.   
  
  
  
  15.         -80     
    16.   
  
  
  
  16.          
    17.   
  
  
  
  17.      
    18.   
  
  
  
  18.      
    19.   
  
  
  
  19.          
    20.   
  
  
  
  20.             HSQL Database Engine 
    21.   
  
  
  
  21.          
    22.   
  
  
  
  22.          
    23.   
  
  
  
  23.             -22,-28 
    24.   
  
  
  
  24.          
    25.   
  
  
  
  25.          
    26.   
  
  
  
  26.             -104 
    27.   
  
  
  
  27.          
    28.   
  
  
  
  28.          
    29.   
  
  
  
  29.             -9 
    30.   
  
  
  
  30.          
    31.   
  
  
  
  31.          
    32.   
  
  
  
  32.             -80 
    33.   
  
  
  
  33.          
    34.   
  
  
  
  34.      
    35.

其余数据库的错误码内容也可以从这个文件之中获得。下面我们来看看如何自定义异常处理。上面我们已经知道在org.springframework.jdbc.support包下有sql-error-codes.xml文件，在Spring启动时会自动读取这个文件中的错误码，它为我们预分类了一些错误码，而我们可以加强它，来使用我们自定义的异常。首先，定义一个异常类，我们就来自定义一下前面的-104错误，就是HSQL的重复键的问题：

 
 
 
 
      
  
  
  
  1. package org.ourpioneer.vehicle.exception;      
    2.   
  
  
  
  2. import org.springframework.dao.DataIntegrityViolationException;      
    3.   
  
  
  
  3. public class VehicleDuplicateKeyException extends     
    4.   
  
  
  
  4.         DataIntegrityViolationException {      
    5.   
  
  
  
  5.     public VehicleDuplicateKeyException(String msg) {      
    6.   
  
  
  
  6.         super(msg);      
    7.   
  
  
  
  7.     }      
    8.   
  
  
  
  8.     public VehicleDuplicateKeyException(String msg, Throwable cause) {      
    9.   
  
  
  
  9.         super(msg, cause);      
    10.   
  
  
  
  10.     }      
    11.   
  
  
  
  11. }     
    12.   
  
  
  
  12. package org.ourpioneer.vehicle.exception;  
    13.   
  
  
  
  13. import org.springframework.dao.DataIntegrityViolationException;  
    14.   
  
  
  
  14. public class VehicleDuplicateKeyException extends  
    15.   
  
  
  
  15.         DataIntegrityViolationException {  
    16.   
  
  
  
  16.     public VehicleDuplicateKeyException(String msg) {  
    17.   
  
  
  
  17.         super(msg);  
    18.   
  
  
  
  18.     }  
    19.   
  
  
  
  19.     public VehicleDuplicateKeyException(String msg, Throwable cause) {  
    20.   
  
  
  
  20.         super(msg, cause);  
    21.   
  
  
  
  21.     }  
    22.   
  
  
  
  22. } 
    23.

之后我们重新新建一个sql-error-codes.xml代码，并将它放到类路径的根目录下，这样Spring会发现它并使用我们自定义的文件，在配置中定义如下：

 
 
 
 
      
  
  
  
  1.      
    2.   
  
  
  
  2.              
    3.   
  
  
  
  3.              
    4.   
  
  
  
  4.              
    5.   
  
  
  
  5.                  
    6.   
  
  
  
  6.                      
    7.   
  
  
  
  7.                  
    8.   
  
  
  
  8.              
    9.   
  
  
  
  9.          
    10.   
  
  
  
  10.       
  
  
  
  11.     class="org.springframework.jdbc.support.CustomSQLErrorCodesTranslation">     
    12.   
  
  
  
  12.              
    13.   
  
  
  
  13.           
  
  
  
  14.     value="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyException" />     
    15.   
  
  
  
  15.          
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.          
    18.   
  
  
  
  18.          
    19.   
  
  
  
  19.          
    20.   
  
  
  
  20.              
    21.   
  
  
  
  21.                  
    22.   
  
  
  
  22.              
    23.   
  
  
  
  23.          
    24.   
  
  
  
  24.      
    25.   
  
  
  
  25.       
  
  
  
  26.     class="org.springframework.jdbc.support.CustomSQLErrorCodesTranslation"> 
    27.   
  
  
  
  27.          
    28.   
  
  
  
  28.           
  
  
  
  29.     value="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyException" /> 
    30.   
  
  
  
  30.      
    31.

HSQL的bean的名称不要改，并将useSqlStateForTranslation置为false，就可以使用我们自己定义的异常类了。在主函数中移除try/catch块，启动程序，我们就可以看到如下内容：

从启动信息中可以发现Spring发现了我们自定义的sql-error-codes.xml，并替换其中的HSQL数据库处理部分，使用了我们定义的异常，模拟出主键重复的异常后，VehicleDuplicateKeyException就抛出了。除此之外，还可以实现SQLExceptionTranslator接口，并在JDBC模板中注入其实例来实现异常控制，我们来看一下，首先创建一个Translator类：

 
 
 
 
      
  
  
  
  1. package org.ourpioneer.vehicle.exception;      
    2.   
  
  
  
  2. import java.sql.SQLException;      
    3.   
  
  
  
  3. import org.springframework.dao.DataAccessException;      
    4.   
  
  
  
  4. import org.springframework.jdbc.UncategorizedSQLException;      
    5.   
  
  
  
  5. import org.springframework.jdbc.support.SQLExceptionTranslator;      
    6.   
  
  
  
  6. public class VehicleDuplicateKeyTranslator implements SQLExceptionTranslator {      
    7.   
  
  
  
  7.     public DataAccessException translate(String task, String sql,      
    8.   
  
  
  
  8.             SQLException ex) {      
    9.   
  
  
  
  9.         if (task == null) {      
    10.   
  
  
  
  10.             task = "";      
    11.   
  
  
  
  11.         }      
    12.   
  
  
  
  12.         if (sql == null) {      
    13.   
  
  
  
  13.         }      
    14.   
  
  
  
  14.         if (ex.getErrorCode() == -104) {      
    15.   
  
  
  
  15.             return new VehicleDuplicateKeyException(buildMessage(task, sql, ex));      
    16.   
  
  
  
  16.         } else {      
    17.   
  
  
  
  17.             return new UncategorizedSQLException(task, sql, ex);      
    18.   
  
  
  
  18.         }      
    19.   
  
  
  
  19.     }      
    20.   
  
  
  
  20.     private String buildMessage(String task, String sql, SQLException ex) {      
    21.   
  
  
  
  21.         return "数据库操作异常：" + task + "; SQL [" + sql + "]; " + ex.getMessage();      
    22.   
  
  
  
  22.     }      
    23.   
  
  
  
  23. }     
    24.   
  
  
  
  24. package org.ourpioneer.vehicle.exception;  
    25.   
  
  
  
  25. import java.sql.SQLException;  
    26.   
  
  
  
  26. import org.springframework.dao.DataAccessException;  
    27.   
  
  
  
  27. import org.springframework.jdbc.UncategorizedSQLException;  
    28.   
  
  
  
  28. import org.springframework.jdbc.support.SQLExceptionTranslator;  
    29.   
  
  
  
  29. public class VehicleDuplicateKeyTranslator implements SQLExceptionTranslator {  
    30.   
  
  
  
  30.     public DataAccessException translate(String task, String sql,  
    31.   
  
  
  
  31.             SQLException ex) {  
    32.   
  
  
  
  32.         if (task == null) {  
    33.   
  
  
  
  33.             task = "";  
    34.   
  
  
  
  34.         }  
    35.   
  
  
  
  35.         if (sql == null) {  
    36.   
  
  
  
  36.         }  
    37.   
  
  
  
  37.         if (ex.getErrorCode() == -104) {  
    38.   
  
  
  
  38.             return new VehicleDuplicateKeyException(buildMessage(task, sql, ex));  
    39.   
  
  
  
  39.         } else {  
    40.   
  
  
  
  40.             return new UncategorizedSQLException(task, sql, ex);  
    41.   
  
  
  
  41.         }  
    42.   
  
  
  
  42.     }  
    43.   
  
  
  
  43.     private String buildMessage(String task, String sql, SQLException ex) {  
    44.   
  
  
  
  44.         return "数据库操作异常：" + task + "; SQL [" + sql + "]; " + ex.getMessage();  
    45.   
  
  
  
  45.     }  
    46.   
  
  
  
  46. } 
    47.

其中，要覆盖translate方法，方法有三个参数，task表示当前操作要进行的任务是什么，sql就是执行的sql语句，ex表示SQLException，我们可以从中获取异常信息，其处理代码仅仅捕捉了错误码为-104（HSQL数据库）的错误，其余的配置信息可以根据需要来自行添加。之后要在Spring中重新配置它们：

 
 
 
 
      
  
  
  
  1.   
  
  
  
  2. class="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyTranslator">     
    3.   
  
  
  
  3.      
    4.   
  
  
  
  4.          
    5.   
  
  
  
  5.          
    6.   
  
  
  
  6.      
    7.   
  
  
  
  7.      
    8.   
  
  
  
  8.          
    9.   
  
  
  
  9.      
    10.   
  
  
  
  10.       
  
  
  
  11.     class="org.ourpioneer.vehicle.exception.VehicleDuplicateKeyTranslator"> 
    12.   
  
  
  
  12.      
    13.   
  
  
  
  13.          
    14.   
  
  
  
  14.          
    15.   
  
  
  
  15.      
    16.   
  
  
  
  16.      
    17.   
  
  
  
  17.          
    18.   
  
  
  
  18.      
    19.

调整DAO实现类的代码：

 
 
 
 
      
  
  
  
  1. public class VehicleDAOImpl extends SimpleJdbcDaoSupport implements VehicleDAO {      
    2.   
  
  
  
  2.     …   …      
    3.   
  
  
  
  3.     public void insert(final Vehicle vehicle) {      
    4.   
  
  
  
  4.         String sql = "insert into vehicle(ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?,?)";      
    5.   
  
  
  
  5.         getJdbcTemplate().update(sql, vehicle.getId(),vehicle.getPlate(),vehicle.getChassis(),vehicle.getColor(),vehicle.getWheel(),vehicle.getSeat());      
    6.   
  
  
  
  6.     }      
    7.   
  
  
  
  7. …   …      
    8.   
  
  
  
  8. }     
    9.   
  
  
  
  9. public class VehicleDAOImpl extends SimpleJdbcDaoSupport implements VehicleDAO {  
    10.   
  
  
  
  10.     …   …  
    11.   
  
  
  
  11.     public void insert(final Vehicle vehicle) {  
    12.   
  
  
  
  12.         String sql = "insert into vehicle(ID,PLATE,CHASSIS,COLOR,WHEEL,SEAT) values(?,?,?,?,?,?)";  
    13.   
  
  
  
  13.         getJdbcTemplate().update(sql, vehicle.getId(),vehicle.getPlate(),vehicle.getChassis(),vehicle.getColor(),vehicle.getWheel(),vehicle.getSeat());  
    14.   
  
  
  
  14.     }  
    15.   
  
  
  
  15. …   …  
    16.   
  
  
  
  16. } 
    17.

为了进行测试，其它代码可不用修改，这样继续运行测试程序，同时将sql-error-codes.xml文件从类路径的根路径下去除，就可以得到如下结果：

Spring的JDBC模块在自定义异常处理上也非常灵活，可以选择自己喜欢的方式来实现。希望对使用者有用，欢迎交流，下一部分开始介绍Spring的ORM。

网站栏目：Spring访问数据库异常的处理方法
URL标题：http://www.shufengxianlan.com/qtweb/news5/494055.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

解决方案知识

行业网站建设

九针服饰　　 　乐山服务器托管　　 　微官网开发　　 　响应式网站建设方案　　 　梦港之夜　　 　微信小程序　　 　成都花箱厂家　　 　消防工程　　 　绵阳电信机房　　 　网络营销　　 　成都包装设计公司　　 　成都网站制作　　 　成都免费建站　　 　手机软件开发　　 　抖音短视频　　 　响应式网站建设公司　　 　成都主机租用　　 　成都铁科精智测控　　 　网站解决方案　　 　服务器托管