Spring 学习小记（十八）

最新推荐文章于 2022-08-07 19:16:40 发布
原创 最新推荐文章于 2022-08-07 19:16:40 发布 · 250 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java

本文介绍了Spring MVC框架中处理异常的三种方法：使用SimpleMappingExceptionResolver、实现HandlerExceptionResolver接口以及利用@ExceptionHandler注解。通过实例展示了如何配置并应用这些方法。
Spring MVC异常处理
 
本小记学习目标
  1. SimpleMappingExceptionResolver
  2. HandlerExceptionResolver接口
  3. @ExceptionHandler注解
 
Spring MVC开发中，不管是对数据库操作、业务层操作、控制器层操作都有可能产生各种异常需要处理，对于异常的处理如果散落在各处，则它的耦合性则太高，从而加大了工作量并且处理方式不好统一。Spring MVC框架为了解决这个问题提供了相应的解决方案。
我们有三种式方式来统一处理异常：
第一、Spirng MVC提供的简单异常处理器SimpleMappingExceptionResolver
第二、Spring的异常处理接口HandlerExceptionResolver接口
第三、@ExceptionHandler注解
 
一、SimpleMappingExceptionResolver
实例说明
1.新增一个Maven的war工程，在pom.xml中导入如下jar依赖
< dependencies >
             <!-- context -->
             < dependency >
                   < groupId >org.springframework </ groupId >
                   < artifactId >spring-context </ artifactId >
                   < version >5.0.2.RELEASE </ version >
             </ dependency >
          <!-- Spring MVC -->
          < dependency >
             < groupId >org.springframework </ groupId >
             < artifactId >spring- webmvc </ artifactId >
             < version >5.0.2.RELEASE </ version >
          </ dependency >
         
          <!-- Spring web -->
          < dependency >
             < groupId >org.springframework </ groupId >
             < artifactId >spring-web </ artifactId >
             < version >5.0.2.RELEASE </ version >
             </ dependency >
         
          <!-- commons-logging -->
          < dependency >
             < groupId >commons-logging </ groupId >
             < artifactId >commons-logging </ artifactId >
             < version >1.2 </ version >
          </ dependency >
         
          <!-- spring- aop -->
          < dependency >
             < groupId >org.springframework </ groupId >
             < artifactId >spring- aop </ artifactId >
             < version >5.0.2.RELEASE </ version >
          </ dependency >
         
             < dependency >
             < groupId >javax.servlet </ groupId >
             < artifactId > jstl </ artifactId >
             < version >1.2 </ version >
             </ dependency >
       </ dependencies >
2.新增一个自己定义的异常类com.xiaoxie.exception.MyException
package com.xiaoxie.exception;
public class MyException extends Exception{
       private static final long serialVersionUID = 1L;
       public MyException() {
             super();
      }
      
       public MyException(String message) {
             super( message);
      }
}
3.新增一个Dao，com.xiaoxie.dao.ExceptionDao
package com.xiaoxie.dao;
import java.sql.SQLException;
import org.springframework.stereotype.Repository;
import com.xiaoxie.exception.MyException;
@Repository( "exceptionDao")
public class ExceptionDao {
       public void daoDBException() throws SQLException {
             throw new SQLException( "Dao中数据库异常！");
      }
      
       public void daoMyException() throws MyException {
             throw new MyException( "Dao中自定义的异常！");
      }
      
       public void daoUnknownException() throws Exception {
             throw new Exception( "Dao中未知异常！");
      }
}
4.新增一个service接口和service的实现类，com.xiaoxie.service.ExceptionService、com.xiaoxie.service.impl.ExceptionServiceImpl
ExceptionService:
package com.xiaoxie.service;
public interface ExceptionService {
       void serviceMyException() throws Exception;
       void serviceDBException() throws Exception;
       void serviceUnknownException() throws Exception;
      
       void daoMyException() throws Exception;
       void daoDBException() throws Exception;
       void daoUnknownException() throws Exception;
}
ExceptionServiceImpl:
package com.xiaoxie.service.impl;
import java.sql.SQLException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.xiaoxie.dao.ExceptionDao;
import com.xiaoxie.exception.MyException;
import com.xiaoxie.service.ExceptionService;
@Service( "exceptionService")
public class ExceptionServiceImpl implements ExceptionService{
       @Autowired
       private ExceptionDao exceptionDao;
      
       @Override
       public void serviceMyException() throws Exception {
             throw new MyException( "service中自己定义异常！");
      }
       @Override
       public void serviceDBException() throws Exception {
             throw new SQLException( "service中数据库异常！");
      }
       @Override
       public void serviceUnknownException() throws Exception {
             throw new Exception( "service中未知异常！");
      }
       @Override
       public void daoMyException() throws Exception {
             exceptionDao.daoMyException();
      }
       @Override
       public void daoDBException() throws Exception {
             exceptionDao.daoDBException();
      }
       @Override
       public void daoUnknownException() throws Exception {
             exceptionDao.daoUnknownException();
      }
}
5.新增Controller类：com.xiaoxie.controller.ExceptionController
package com.xiaoxie.controller;
import java.sql.SQLException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.xiaoxie.exception.MyException;
import com.xiaoxie.service.ExceptionService;
@Controller
public class ExceptionController {
       @Autowired
       private ExceptionService exceptionService;
      
       @RequestMapping( "/db")
       public void controllerDBExcepton() throws Exception {
             throw new SQLException( "控制器中数据库异常！");
      }
      
       @RequestMapping( "/my")
       public void controllerMyException() throws Exception {
             throw new MyException( "控制器中自定义异常！");
      }
      
       @RequestMapping( "/no")
       public void controllerUnknownException() throws Exception {
             throw new Exception( "控制器中未知异常！");
      }
      
      
       @RequestMapping( "/servicedb")
       public void serviceDBExcepton() throws Exception {
             exceptionService.serviceDBException();
      }
      
       @RequestMapping( "/servicemy")
       public void serviceMyException() throws Exception {
             exceptionService.serviceMyException();
      }
      
       @RequestMapping( "/serviceno")
       public void serviceUnknownException() throws Exception {
             exceptionService.serviceUnknownException();
      }
      
      
       @RequestMapping( "/daodb")
       public void daoDBExcepton() throws Exception {
             exceptionService.daoDBException();
      }
      
       @RequestMapping( "/daomy")
       public void daoMyException() throws Exception {
             exceptionService.daoMyException();
      }
      
       @RequestMapping( "/daono")
       public void daoUnknownException() throws Exception {
             exceptionService.daoUnknownException();
      }
}
6.定义视图：index.jsp,404.jsp,error.jsp,my-error.jsp,sql-error.jsp(注意：这里的视图都是定义在webcontent下的，这里的位置与配置视图解析器时有关系)
index.jsp:
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >index </ title >
</ head >
< body >
       < a href= "${pageContext.request.contextPath } /daodb" >处理 dao中数据库异常 </ a >
       < a href= "${pageContext.request.contextPath } /daomy" >处理 dao中自定义异常 </ a >
       < a href= "${pageContext.request.contextPath } /daono" >处理 dao中未知异常 </ a >
       < hr />
       < a href= "${pageContext.request.contextPath } /servicedb" >处理service中数据库异常 </ a >
       < a href= "${pageContext.request.contextPath } /servicemy" >处理service中自定义异常 </ a >
       < a href= "${pageContext.request.contextPath } /serviceno" >处理service中未知异常 </ a >
       < hr />
       < a href= "${pageContext.request.contextPath } /db" >处理controller中数据库异常 </ a >
       < a href= "${pageContext.request.contextPath } /my" >处理controller中自定义异常 </ a >
       < a href= "${pageContext.request.contextPath } /no" >处理controller中未知异常 </ a >
       < hr />
       < a href= "${pageContext.request.contextPath } /404" >404错误 </ a >
</ body >
</ html >
404.jsp:
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" isErrorPage= "true" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >404 </ title >
</ head >
< body >
      资源不存在！
</ body >
</ html >
error.jsp:
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" isErrorPage= "true" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >未知异常 </ title >
</ head >
< body >
      程序出现未知错误： <%=exception %>
       < br />
      错误内容：
       < br />
       <%
            exception.printStackTrace(response.getWriter());
       %>
</ body >
</ html >
my-error.jsp:
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" isErrorPage= "true" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >自定义异常 </ title >
</ head >
< body >
      自定义异常错误： <%=exception %>
       < br />
      错误内容：
       < br />
       <%
            exception.printStackTrace(response.getWriter());
       %>
</ body >
</ html >
sql-error.jsp:
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" isErrorPage= "true" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >Insert title here </ title >
</ head >
< body >
      数据库异常错误： <%=exception %>
       < br />
      错误内容：
       < br />
       <%
            exception.printStackTrace(response.getWriter());
       %>
</ body >
</ html >
注意：几个异常jsp页面中定义了isErrorPage="true",否则不可以使用exception对象
7.web.xml配置
<? xml version= "1.0" encoding= "UTF-8" ?>
<!-- 全局的异常处理页面 -->
< error-page >
       < error-code >404 </ error-code >
       < location >/404. jsp </ location >
</ error-page >
<!-- 前端核心 servlet 的配置（DispatcherServlet） -->
       < servlet >
             < servlet-name >springDispatcherServlet </ servlet-name >
             < servlet-class >org.springframework.web.servlet.DispatcherServlet </ servlet-class >
             < init-param >
                   < param-name >contextConfigLocation </ param-name >
                   < param-value >classpath:springmvc.xml </ param-value >
             </ init-param >
             < load-on-startup >1 </ load-on-startup >
       </ servlet >
       <!-- Map all requests to the DispatcherServlet for handling -->
       < servlet-mapping >
             < servlet-name >springDispatcherServlet </ servlet-name >
             < url-pattern >/ </ url-pattern >
       </ servlet-mapping >
      
       <!-- 配置解决 psot 请求中文乱码问题 -->
       < filter >
             < filter-name >CharacterEncodingFilter </ filter-name >
             < filter-class >org.springframework.web.filter.CharacterEncodingFilter </ filter-class >
             < init-param >
                   < param-name >encoding </ param-name >
                   < param-value > utf-8 </ param-value >
             </ init-param >
             < init-param >
                   < param-name >forceEncoding </ param-name >
                   < param-value >true </ param-value >
             </ init-param >
       </ filter >
       < filter-mapping >
             < filter-name >CharacterEncodingFilter </ filter-name >
             < url-pattern >/* </ url-pattern >
       </ filter-mapping >
</ web-app >
注意：404的配置，当出现404的错误时定位到404.jsp,由于404.jsp这个页面是在webcontent目录下，所以配置时使用/404.jsp
8.在classpath下新增spring的配置文件springmvc.xml
<? xml version= "1.0" encoding= "UTF-8" ?>
       xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context= "http://www.springframework.org/schema/context"
       <!-- spring自动扫描 -->
       < context:component-scan base-package= "com.xiaoxie.controller" />
       < context:component-scan base-package= "com.xiaoxie.service" />
       < context:component-scan base-package= "com.xiaoxie.dao" />
      
       <!-- 配置视图解析器 -->
       < bean class= "org.springframework.web.servlet.view.InternalResourceViewResolver" id= "internalResourceViewResolver" >
             <!-- 前缀 -->
             < property name= " prefix" value= "/" />
             <!-- 后缀 -->
             < property name= " suffix" value= ".jsp" />
       </ bean >
      
       <!-- 配置SimpleMappingExceptionResolver（异常与视图的对应关系） -->
       < bean class= "org.springframework.web.servlet.handler.SimpleMappingExceptionResolver" id= "simpleMappingExceptionResolver" >
             <!-- 定义默认的异常处理页面 -->
             < property name= " defaultErrorView" value= "error" />
             <!-- 定义异常处理页面用来获取异常信息的变量名称 ，默认为exception -->
             < property name= " exceptionAttribute" value= "ex" />
             <!-- 定义需要特殊处理的异常 -->
             < property name= " exceptionMappings" >
                   < props >
                         < prop key= "com.xiaoxie.exception.MyException" >my-error </ prop >
                         < prop key= "java.sql.SQLException" > sql-error </ prop >
                   </ props >
             </ property >
       </ bean >
</ beans >
注意：这个配置文件中的关键是配置了SimpleMappingExceptionResolver这个bean，从与把产生的异常与对应的视图关联起来
 
二、HandlerExceptionResolver接口实现异常的统一处理
org.springframework.web.servlet.HandlerExceptionResolver接口用于解析请求处理过程中所产生的异常，我们可以实现这个接口来对异常做统一的处理。
1.在com.xiaoxie.exception包下新增一个实现类MyExceptionHandler
package com.xiaoxie.exception;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
public class MyExceptionHandler implements HandlerExceptionResolver{
       @Override
       public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
                  Exception ex) {
            Map<String,Object> model = new HashMap<String,Object>();
             model.put( "ex", ex);
             //根据不同的异常来转到不同的页面
             if( ex instanceof MyException) {
                   return new ModelAndView( "my-error", model);
            } else if( ex instanceof SQLException) {
                   return new ModelAndView( "sql-error", model);
            } else {
                   return new ModelAndView( "error", model);
            }
      }
}
2.在Spring的配置文件中托管MyExceptionHandler，对实例中的SimpleMappingExceptionResolver进行注释，并在后面添加如下配置进行MyExceptionHandler的托管
<!-- Spring托管MyExceptionHandler -->
< bean class= "com.xiaoxie.exception.MyExceptionHandler" />
 
三、@ExceptionHandler注解声明异常处理方法
1.定义一个抽象类：BaseExceptionController类
package com.xiaoxie.controller;
import java.sql.SQLException;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.ExceptionHandler;
import com.xiaoxie.exception.MyException;
public abstract class BaseExceptoinController {
       @ExceptionHandler
       public String exception(HttpServletRequest request,Exception ex) {
             //request.setAttribute(" ex ", ex );
             if( ex instanceof MyException) {
                   return "my-error";
            } else if( ex instanceof SQLException) {
                   return "sql-error";
            } else {
                   return "error";
            }
      }
}
2.对于controller实现类extends BaseExceptionController
3.把实例中对MyExceptionHandler托管的配置进行注释
Java 异常处理
diaolove的博客
01-15 382
文章目录前言一、Exception 类的层次二、Java 内置异常类三、异常方法四、捕获异常多重捕获块throws/throw 关键字：finally关键字声明自定义异常五、通用异常 前言 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 异常发生的原因有很多，通常包含以下几大类： 用户输入了非法数据。 要打开的文件不存在。 网络通信时连接中断，或者JVM内存溢出。 这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。 要理解Java
Java异常处理
HouYing
06-08 1964
异常处理Java语言的设计从根本上便于我们写出整洁、设计良好的代码；尽管如此，在程序运行中仍可能有各种各样的错误出现。 1 、概念 采用新的异常处理机制        在以往的程序开发过程中，常常采用返回值进行处理。例如，在编写一个方法，可以返回一个状态代码，调用者根据状态代码判断出错与否。若状态代码表示一个错误，则调用这进行相应的处理，或显示一个错误页面或错误
JAVA异常处理
b44431的博客
05-26 131
图片来自网络 异常类体系 Error 一般指虚拟机相关错误，是程序无法处理的，如OutOfMemoryError、ThreadDeath、系统崩溃等。这种错误由JVM来处理，不可能捕获也无法恢复，JVM在大多数情况下会选择终止线程导致程序中断。 Exception 程序可以捕获处理的异常。分为两种：CheckedException，UncheckedE...
Java提高篇——Java 异常处理
weixin_34174422的博客
07-29 642
异常的概念 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出java.lang.ArithmeticException的异常。 异常发生的原因有很多，通常包含以下几大类： ...
Spring小记
一生烟雨的博客
01-03 1185
Spring : 春天 —->给软件行业带来了春天2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
我的日常小记：spring以及mybatis最终源码
06-24
在本项目中，"我的日常小记：spring以及mybatis最终源码" 是一个记录了开发者个人编程经验的项目，主要涉及两个核心框架——Spring和MyBatis。这两个框架是Java开发领域中非常流行的技术栈，广泛应用于企业级后端...
springboot 学习小记 5：后台添加目录模块
weixin_57169969的博客
08-07 287
springboot 学习小记 5：后台添加目录模块
Spring与MyBatis整合项目源码解析
本项目标题为“我的日常小记：spring以及mybatis最终源码”，从标题可以明确看出，该项目聚焦于Spring与MyBatis两大主流Java框架的整合应用，并且强调了“源码”这一关键词，意味着该项目不仅是一个功能实现的示例，...
深入探讨Spring框架核心源码与工具应用
Spring框架源码是学习Java开源项目极好的资源。源码分析可以加深对Spring框架内部工作原理的理解，包括IoC容器的启动流程、Bean的创建和生命周期管理、AOP的实现机制、事务管理的处理等。 6. 总结 Spring框架经过...
狂神带你深入学习Spring Cloud及代码实践
资源摘要信息:"狂神Spring Cloud学习笔记加代码" 知识点一：Spring Cloud概述 Spring Cloud是一系列框架的集合，它利用Spring Boot的开发便利性简化了分布式系统基础设施的开发，如服务发现、配置管理、消息总线、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值