springmvc深入理解

最新推荐文章于 2023-06-26 13:42:38 发布
最新推荐文章于 2023-06-26 13:42:38 发布
阅读量708 收藏 3
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liliping28/article/details/79865817
版权

本文参考文章https://www.cnblogs.com/baiduligang/p/4247164.html。感谢作者提供的技术知识，我优化了一下。

目录 
一、前言
二、spring mvc 核心类与接口
三、spring mvc 核心流程图

四、spring mvc DispatcherServlet说明

五、spring mvc 父子上下文的说明

六、springMVC-mvc.xml 配置文件片段讲解 
七、spring mvc 如何访问到静态的文件，如jpg,js,css

八、spring mvc 请求如何映射到具体的Action中的方法

九、 spring mvc 中的拦截器：
十、 spring mvc 如何使用拦截器

十一、 spring mvc 如何实现全局的异常处理

十二、 spring mvc 如何把全局异常记录到日志中

十三、 如何给spring3 MVC中的Action做JUnit单元测试

十四、 spring mvc 转发与重定向 （带参数重定向）

十五、 spring mvc 处理ajax请求

十六、 spring mvc 关于写几个配置文件的说明 

十七、 spring mvc 如何取得Spring管理的bean

十八、 spring mvc 多视图控制器

十九、 <mvc:annotation-driven /> 到底做了什么工作 
二十、 本文中springMVC.xml配置文件是核心，这里给一个下载地址

很多人对于刚开始工作经验时间不长的，大家很多地方不理解。我希望可以用白话让大家更可以理解。

springmvc我们为什么要学习呢？这可能大家有很多答案

我个人认为，springmvc学习起来很简单，比Struts2学习起来更快捷，更方便，更简洁。作为程序员，我们当然希望我们把更多的经历放在业务上。让我来比一下Struts2和springmvc吧。

springmvc的优点

1.首先springmvc的入口是Servlet

2.springMVC是基于方法开发的，它默认单例模式。它本身也可以为多例模式提供了方式，只需要我们在控制类里面加@scope（value="prototype"）即可。它本身默认为单例模式

3.springmvc是基于方法开发的

4.springmvc的拦截器其实就是spring的AOP的一种实现方式

5.springmvc本身可以跟spring无缝衔接。

Struts2的优点

1.首先Struts2的入口是filter

2.它本身是基本类开发的。所谓基本类指的就是当你请求时Controller，Controller里的所有方法共享参数。

3.Struts2在集成spring时配置文件繁琐复杂，不利于开发。

 

 

 

以上图片引用原文作者

本人针对引用作者的原图我来补充一下

1.DispatcherServlet中会通过ServletContent(上下文对象：上下文对象的作用就是在程序初始化时，将一些信息注入到这个对象中)，获取一些信息存放在ApplicationContext这个工具类中，ApplicationContext这个工具类底层采用的单例模式。所以当我们(Object)ApplicationContext.getBean("..xml")就可以得到我们注入bean的对像了。

2.DispatcherServlet-HandlerMapping(接口)-DefaultAnnotationHandlerMapping通过注解，把一个URL映射到Controller类上（order=0）或者SimpleUrlHandlerMapping （order=2147483646） 通过配置文件，把一个URL映射到Controller。如果找到控制器（Controller）-HandlerAdapter（接口适配器：就是找到你要请求那个方法的中转站)-AnnotationMethodHandlerAdapter类，通过注解或者SimpleUrlMethodHandlerAdapter（order=2147483646） 通过配置文件，把一个URL映射到Controller，把一个URL映射到Controller类的方法上，然后在查看该方法是否存在拦截器（-HandlerInterceptor （接口））-Controller-biz-dao-biz-Controller-ViewResolver接口-UrlBasedViewResolver类 通过配置文件，把一个视图名交给到一个View来处理或者InternalResourceViewResolver类，比上面的类，加入了JSTL的支持。在到View接口（-View接口）。以上是我对springmvc的原理过程的总结

//上面的-代表下一步走到那的意思（即交给谁来处理），order分优先级（值越小，代表优先级越高）

 

  1. <web-app>  
  2.     <servlet>  
  3.         <servlet-name>example</servlet-name>  
  4.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  5.         <load-on-startup>1</load-on-startup>  
  6.     </servlet>  
  7.     <servlet-mapping>  
  8.         <servlet-name>example</servlet-name>  
  9.         <url-pattern>*.form</url-pattern>  
  10.     </servlet-mapping>  
  11. </web-app>  

 

 1.<load-on-startup>1</load-on-startup>是启动顺序，让这个Servlet随Servletp容器一起启动。

    <url-pattern>*.form</url-pattern> 会拦截*.form结尾的请求。

2.<servlet-name>example</servlet-name>这个Servlet的名字是example，可以有多个DispatcherServlet，是通过名字来区分的。每一个DispatcherServlet有自己的WebApplicationContext上下文对象。同时保存的ServletContext中和Request对象中，关于key，以后说明。

3.在DispatcherServlet的初始化过程中，框架会在web应用的 WEB-INF文件夹下寻找名为[servlet-name]-servlet.xml 的配置文件，生成文件中定义的bean。

 

Xml代码 复制代码 收藏代码

  1. <servlet>  
  2.     <servlet-name>springMVC</servlet-name>  
  3.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  4.     <init-param>  
  5.         <param-name>contextConfigLocation</param-name>  
  6.         <param-value>classpath*:/springMVC.xml</param-value>  
  7.     </init-param>  
  8.     <load-on-startup>1</load-on-startup>  
  9. </servlet>  
  10. <servlet-mapping>  
  11.     <servlet-name>springMVC</servlet-name>  
  12.     <url-pattern>/</url-pattern>  
  13. </servlet-mapping>  

指明了配置文件的文件名，不使用默认配置文件名，而使用springMVC.xml配置文件。

其中<param-value>**.xml</param-value> 这里可以使用多种写法
1、不写,使用默认值:/WEB-INF/<servlet-name>-servlet.xml
2、<param-value>/WEB-INF/classes/springMVC.xml</param-value>
3、<param-value>classpath*:springMVC-mvc.xml</param-value>
4、多个值用逗号分隔

Servlet拦截匹配规则可以自已定义，拦截哪种URL合适？

当映射为@RequestMapping("/user/add")时，为例：

 

1、拦截*.do、*.htm， 例如：/user/add.do

这是最传统的方式，最简单也最实用。不会导致静态文件（jpg,js,css）被拦截。

 

2、拦截/，例如：/user/add

可以实现现在很流行的REST风格。很多互联网类型的应用很喜欢这种风格的URL。

弊端：会导致静态文件（jpg,js,css）被拦截后不能正常显示。想实现REST风格，事情就是麻烦一些。后面有解决办法还算简单。

3、拦截/*，这是一个错误的方式，请求可以走到Action中，但转到jsp时再次被拦截，不能访问到jsp。

如果想实现REST风格，办法我正可以先想一下，第一种是不是在我们进入spring容器之前，让Tomcat的Servlet我们先解析静态资源。第二种是让spring提供的Servlet来解析静态资源.

第一种自然可以想到在web.xml来启动Tomcat的Servlet来解析

 

  1. <servlet-mapping>  
  2.     <servlet-name>default</servlet-name>  
  3.     <url-pattern>*.css</url-pattern>  
  4. </servlet-mapping>  
  5. <servlet-mapping>  
  6.     <servlet-name>default</servlet-name>  
  7.     <url-pattern>*.js</url-pattern>  
  8. </servlet-mapping>  
  9. <servlet-mapping>  
  10.     <servlet-name>default</servlet-name>  
  11.     <url-pattern>*.jpg</url-pattern>  
  12. </servlet-mapping></span>  

不同的 servlet 容器/应用服务器，处理这些静态资源的 servlet 的名字不大一样：
Tomcat, Jetty, JBoss, and GlassFish：默认 Servlet 名字为 "default"；
Google App Engine：默认 Servlet 名字为 "_ah_default"；
Resin：默认 Servlet 名字为 "resin-file"；
WebLogic：默认 Servlet 名字为 "FileServlet"；
WebSphere：默认 Servlet 名字为 "SimpleFileServlet"；

第二种自然启动spring提供的Servlet来解析，把自然肯定在对应的springmvc.xml（举例文件）里了 

 

  1. <!-- 对静态资源的访问 -->  
  2. <mvc:resources mapping="/css/**" location="/css/" />  
  3. <mvc:resources mapping="/image/**" location="/image/" />  
  4. <mvc:resources mapping="/js/**" location="/js/" />  

mapping：表示页面中使用到的路径

location：表示从该路径下进行查找

以上的配置：css，image，js放置在webapp目录下，页面中使用时：localhost:8080/css/aaa.css

注意：对于方法二，在tomcat下可以正常使用，但在resin下静态资源仍然找不到，最后发现，直接使用如下的配置就可以兼容tomcat和resin了

 

  1. <mvc:default-servlet-handler />  

这种配置只支持有限的一些容器，对于spring不支持的容器，需要配置defaule-servlet-name进行指定。

对于不懂得可以看一下这个地址https://blog.csdn.net/u012730299/article/details/51872704这上面有很好的讲解

以上以上是对Rest请求方式总结，注明Rest是spring3.0以后的版本才有的。

在spring请求方式之前我们请求方式get和post2种，但是在spring3.0之后新增put和delete请求方式，这是针对spring的reset请求方式支持新增的，而且也新增注解@PathVariable来配合reset参数请求

 

  1.  /** 
  2.      * PathVariable:注解方法参数，表示该参数变量值是通过URL传递的 
  3.      * URL中必须包含该参数变量名，变量名需要相同才能完成变量传递注入 
  4.      */  
  5.     @RequestMapping(value = "/deleteUser/{id}", method = RequestMethod.DELETE, produces = "application/json")  
  6.     @ResponseBody  
  7.     public String deleteUser(@PathVariable Integer id) {  
  8.         boolean flag = userService.deleteUser(id);  
  9.         if (flag) {  
  10.             message = "success";  
  11.         } else {  
  12.             message = "error";  
  13.         }  
  14.         return message;  
  15.     } 

 以上是对Rest总结，注明Rest是spring3.0以后的版本才有的。

 

  1. <!-- 自动扫描的包名 -->  
  2.     <context:component-scan base-package="com.app,com.core,JUnit4" ></context:component-scan>  
  1.  <!-- 默认的注解映射的支持 -->  
  2.     <mvc:annotation-driven />  

<context:component-scan/> 扫描指定的包中的类上的注解，常用的注解有：

@Controller 声明Action组件
@Service    声明Service组件    @Service("myMovieLister") 
@Repository 声明Dao组件
@Component   泛指组件, 当不好归类时. 
@RequestMapping("/menu")  请求映射
@Resource  用于注入，( j2ee提供的 ) 默认按名称装配，@Resource(name="beanName") 
@Autowired 用于注入，(srping提供的) 默认按类型装配 
@Transactional( rollbackFor={Exception.class}) 事务管理
@ResponseBody
@Scope("prototype")   设定bean的作用域

 

<mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。<mvc:annotation-driven /> 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MVC为@Controllers分发请求所必须的。
并提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）。
后面，我们处理响应ajax请求时，就使用到了对json的支持。

后面，对action写JUnit单元测试时，要从spring IOC容器中取DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean，来完成测试，取的时候要知道是<mvc:annotation-driven />这一句注册的这两个bean。

 

大家思考一个问题springmvc怎么知道http方式请求时，它凭什么知道我们要去那个后台的Controller，那个方法呢？

1.很简单因为有HanflerMapper接口下有两个实现类DefaultAnnotationHandlerMapping(通过注解的方式)和SimpleUrlHandlerMapping（通过配置文件里的url）来找到相应的Controller。

2.我们该找那个具体方法了，我提到过适配器概念其实就是方法请求中转站。HandlerAdapter这个接口也有2个实现类，

AnnotationMethodHandlerAdapter类(通过注解)和SimpleUrlMethodHandlerAdapter（通过配置文件里的url）

<mvc:interceptors/> 是一种简写形式。通过看前面的大图，知道，我们可以配置多个HandlerMapping。<mvc:interceptors/>会为每一个HandlerMapping，注入一个拦截器。其实我们也可以手动配置为每个HandlerMapping注入一个拦截器。

 

  1. <!-- 视图解释类 -->  
  2.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
  3.         <property name="prefix" value="/WEB-INF/jsp/"/>  
  4.         <property name="suffix" value=".jsp"/><!--可为空,方便实现自已的依据扩展名来选择视图解释类的逻辑  -->  
  5.         <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />  
  6.     </bean>  

以上是我讲springmvc.xml文件分解给大家展示。目的是让大家先有编程思想，而不是我先给大家。这样方便大家自己思考学习起来也深刻。最后springmvc.xml简单的，应该配置一些东西大家有一个总体的思想。

 

现在让大家来思考一下拦截器，它的作用，可以做一些什么事情，它是怎么找到要具体拦截那个方法吧，不能全都拦截对吧？

我们在现实中是不是都碰到过看例如爱奇艺里我可以浏览，但是当我们想看会员电影时大概只能看5分钟。然后就提示请看到会员。

1.拦截器可以做权限控制，日志处理，监控系统性能等。这个就是拦截可以做一些什么事

2.springmvc的拦截器就是Aop很好的体现和应用。关于AOP在spring深入理解会细讲

它是知道要拦截那些方法对吧。那它肯定跟DispatcherServlet有关，而且怎么知道的呢？

3.在springmvc.xml里配置的

 

<mvc:interceptors>  
   <!--  使用bean定义一个Interceptor，直接定义在mvc:interceptors根下面的Interceptor将拦截所有的请求   -->
    <!-- <bean class="com.bybo.aca.web.interceptor.Login"/> -->   
    <mvc:interceptor>  
        <!-- 进行拦截：/**表示拦截所有controller -->
        <mvc:mapping path="/**" />
    　　 <!-- 不进行拦截 -->
        <mvc:exclude-mapping path="/index.html"/>
       
        <bean class="com.bybo.aca.web.interceptor.Login"/>  
    </mvc:interceptor>  
</mvc:interceptors>

Spring为我们提供了：
org.springframework.web.servlet.HandlerInterceptor接口，

org.springframework.web.servlet.handler.HandlerInterceptorAdapter适配器，
实现这个接口或继承此类，可以非常方便的实现自己的拦截器。

有以下三个方法：

 Action之前执行:
 public boolean preHandle(HttpServletRequest request,
   HttpServletResponse response, Object handler);
 生成视图之前执行
 public void postHandle(HttpServletRequest request,
   HttpServletResponse response, Object handler,
   ModelAndView modelAndView);
 
最后执行，可用于释放资源
 public void afterCompletion(HttpServletRequest request,
   HttpServletResponse response, Object handler, Exception ex)
 
 
分别实现预处理、后处理（调用了Service并返回ModelAndView，但未进行页面渲染）、返回处理（已经渲染了页面） 
在preHandle中，可以进行编码、安全控制等处理； 
在postHandle中，有机会修改ModelAndView； 
在afterCompletion中，可以根据ex是否为null判断是否发生了异常，进行日志记录。 
参数中的Object handler是下一个拦截器。

这张图片是我粘贴别人的出处地址：https://www.cnblogs.com/Joke-Jay/p/7588580.html

如果出现错误了我应该怎么排查呢？我们应该用logger日志处理工具来处理吧。那就需要我们继承吧，我现在给大家提供一种简单方式。

1.加入日志jar包pom依赖

2.在resources目录下添加日志文件log4j.properties

3.配置web.xml日志监听

 

4:使用

 

1.<!-- slf4j -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.5</version>
</dependency>
2.#LOG_DIR:/usr/local/.../logs
LOG_DIR = E:\\logs //这里是日志文件的路径
#Level:ERROR,WARN,INFO,DEBUG
log4j.rootLogger = DEBUG,Console,FileInfo,FileError

log4j.appender.Console = org.apache.log4j.ConsoleAppender
log4j.appender.Console.Threshold = DEBUG
log4j.appender.Console.ImmediateFlush = true
log4j.appender.Console.Target = SYSTEM_OUT
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

log4j.appender.FileInfo = org.apache.log4j.DailyRollingFileAppender
log4j.appender.FileInfo.Threshold = INFO
log4j.appender.FileInfo.ImmediateFlush = true
log4j.appender.FileInfo.Append = true
log4j.appender.FileInfo.DatePattern = '_'yyyy-MM-dd'.log'
log4j.appender.FileInfo.encoding=UTF-8
log4j.appender.FileInfo.File = ${LOG_DIR}/info
log4j.appender.FileInfo.layout = org.apache.log4j.PatternLayout
log4j.appender.FileInfo.layout.ConversionPattern = [%-5p][%d{ISO8601}]%m%n

log4j.appender.FileError = org.apache.log4j.DailyRollingFileAppender
log4j.appender.FileError.Threshold = ERROR
log4j.appender.FileError.ImmediateFlush = true
log4j.appender.FileError.Append = true
log4j.appender.FileError.DatePattern = '_'yyyy-MM-dd'.log'
log4j.appender.FileError.encoding=UTF-8
log4j.appender.FileError.File = ${LOG_DIR}/error
log4j.appender.FileError.layout = org.apache.log4j.PatternLayout
log4j.appender.FileError.layout.ConversionPattern = [%-5p][%d{ISO8601}]%m%n

log4j.appender.cn.yivi.service.pay = info,pay
log4j.additivity.cn.yivi.service.pay = false
log4j.appender.pay = org.apache.log4j.DailyRollingFileAppender
log4j.appender.pay.Threshold = INFO
log4j.appender.pay.ImmediateFlush = true
log4j.appender.pay.Append = true
log4j.appender.pay.DatePattern = '_'yyyy-MM-dd'.log'
log4j.appender.pay.encoding=UTF-8
log4j.appender.pay.File = ${LOG_DIR}/pay
log4j.appender.pay.layout = org.apache.log4j.PatternLayout
log4j.appender.pay.layout.ConversionPattern = [%-5p][%d{ISO8601}]%m%n
3.<context-param>
  <param-name>log4jConfigLocation</param-name>
  <param-value>classpath:log4j.properties</param-value>
</context-param>

<listener>
  <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>

4.final Logger logger = LoggerFactory.getLogger(UserInfoService.class);

 

以上是我对日志的配置过程的总结，方式很多。我找了一个最方便，最常用的方式

 

大家是不是我们错误的日志是不可能给用户看呢对吧，一旦出现了错误。我们只能给用户看统一的错误页面，不是一个错误对应一个错误页面。我们也做不到。所有做一个统一的错误页面，一旦发生异常我们统一给用户看的，在springmvc中我该怎么做呢？

这里提供给大家2种方式

1.web.xml增加<error-page>标签项即可。注：其实只是在原有的springmvc配置的基础上增加<error-page>标签项即可。

　　

 

web.xml　　

复制代码

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
  <display-name>Archetype Created Web Application</display-name>

  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <!-- 设置dispatchservlet的匹配模式，通过把dispatchservlet映射到/，默认servlet会处理所有的请求，包括静态资源 -->
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- 字符集过滤器 -->
  <filter>
  <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <!--错误跳转页面-->
  <error-page>
    <exception-type>java.lang.Throwable</exception-type>
    <location>/WEB-INF/views/error/404.jsp</location>
  </error-page>
  <error-page>
    <error-code>404</error-code>
    <location>/WEB-INF/views/error/404.jsp</location>
  </error-page>
  <error-page>
    <error-code>500</error-code>
    <location>/WEB-INF/views/error/500.jsp</location>
  </error-page>
</web-app>

复制代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd"
       default-lazy-init="true">

    <!-- 通过mvc:resources设置静态资源，这样servlet就会处理这些静态资源，而不通过控制器 -->
    <!-- 设置不过滤内容，比如:css,jquery,img 等资源文件 -->
    <mvc:resources location="/*.html" mapping="/**.html" />
    <mvc:resources location="/css/*" mapping="/css/**" />
    <mvc:resources location="/js/*" mapping="/js/**" />
    <mvc:resources location="/images/*" mapping="/images/**" />

    <!-- 添加注解驱动 -->
    <mvc:annotation-driven />
    <!-- 默认扫描的包路径 -->
    <context:component-scan base-package="com.*" />

    <!-- mvc:view-controller可以在不需要Controller处理request的情况，转向到设置的View -->
    <!-- 像下面这样设置，如果请求为/，则不通过controller，而直接解析为/index.jsp -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!--  日志自定义注解拦截器 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.log.SystemLogAspect"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

TestController.java

复制代码

package com.controller;

import com.log.Log;
import com.remote.RemoteDemo;
import net.sf.json.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * Created by sunjf on 2016/6/26.
 */
@Controller
public class TestController {

    @Log(desc = "log测试")
    @RequestMapping(value = "test1")
    public String test1(){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("username", "sun");
        jsonObject.put("password", "123");
       // String result = RemoteDemo.remoteJsonRequest("http://localhost:8080/test2?username=sun&password=123", 5000, jsonObject);
        //System.out.println(result);
        return "error/success1";
    }

}

注：该方法跳转页面为success1.jsp，从项目结构中可以看出，我们的项目中是没有这个页面的

 

 

 

index.jsp　

复制代码

<html>
<body>
<h2>Hello World!</h2>
<form action="test1" method="post" id="form1">
    <input type="submit" name="submit" value="button">
</form>
</body>
</html>

404.jsp

复制代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>404</title>
</head>
<body>
    <h1 align="center" style="margin-top:100px;font-size: 200px">404</h1>
    <h3 align="center">未能找到您访问的资源。</h3>
</body>
</html>

运行结果

　　访问链接

　　

　　访问结果

　　

2.自定义的方式：

2.1.我们在WEB-INF/views/commons/error（目录自己定）新建我们自定义的错误页面，404.html, 500.html等等

 

2.2.SimpleMappingExceptionResolver只实现映射关系，我们还需要通过配置web.xml来实现。

 

<error-page>
    <error-code>404</error-code>
    <location>/error/404.html</location>
</error-page>

<error-page>
    <error-code>500</error-code>
    <location>/error/500.html</location>
</error-page>

2.3.在spring-mvc配置文件中将404.html、500.html等设置为资源文件，避免被springmvc再次拦截。  

<mvc:resources mapping="/error/**" location="/WEB-INF/views/commons/error/" />

 

2.4.配置SimpleMappingExceptionResolver。

<bean class="org.springframework.web.servlet.handler. SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <map>
            <entry key="ResourceNotFoundException" value="common/error/resourceNotFoundError" />
            <entry key=".DataAccessException" value="common/error/dataAccessError" />
        </map>
    </property>
    <property name="statusCodes">
        <map>
            <entry key="common/error/resourceNotFoundError" value="404" />
            <entry key="common/error/dataAccessError" value="500" />
        </map>
    </property>
</bean>

感谢作者提供的：具体详细请参考https://www.cnblogs.com/baiduligang/p/4247164.html和https://www.cnblogs.com/sunjf/p/springmvc_error_view.html

springmvc中有转发和重定向这一概念，即forward(转发)和redirect（重定向），虽然我们实际中很少用，但是重定向可以解决跨域问题，还可以防止from重复

 

 

 

Xml代码 复制代码 收藏代码

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:tx="http://www.springframework.org/schema/tx"  
  6.     xmlns:context="http://www.springframework.org/schema/context"     
  7.     xmlns:mvc="http://www.springframework.org/schema/mvc"     
  8.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
  9.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd    
  10.     http://www.springframework.org/schema/tx    
  11.     http://www.springframework.org/schema/tx/spring-tx-3.0.xsd   
  12.     http://www.springframework.org/schema/context   
  13.     http://www.springframework.org/schema/context/spring-context-3.0.xsd   
  14.     http://www.springframework.org/schema/mvc   
  15.     http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">  
  16.   
  17.   
  18.     <!-- 自动扫描的包名 -->  
  19.     <context:component-scan base-package="com.app,com.core,JUnit4" ></context:component-scan>  
  20.        
  21.     <!-- 默认的注解映射的支持 -->  
  22.     <mvc:annotation-driven />  
  23.        
  24.     <!-- 视图解释类 -->  
  25.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
  26.         <property name="prefix" value="/WEB-INF/jsp/"/>  
  27.         <property name="suffix" value=".jsp"/><!--可为空,方便实现自已的依据扩展名来选择视图解释类的逻辑  -->  
  28.         <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />  
  29.     </bean>  
  30.        
  31.     <!-- 拦截器 -->  
  32.     <mvc:interceptors>  
  33.         <bean class="com.core.mvc.MyInteceptor" />  
  34.     </mvc:interceptors>        
  35.        
  36.     <!-- 对静态资源文件的访问  方案一 （二选一） -->  
  37.     <mvc:default-servlet-handler/>  
  38.        
  39.     <!-- 对静态资源文件的访问  方案二 （二选一）-->  
  40.     <mvc:resources mapping="/images/**" location="/images/" cache-period="31556926"/>  
  41.     <mvc:resources mapping="/js/**" location="/js/" cache-period="31556926"/>  
  42.     <mvc:resources mapping="/css/**" location="/css/" cache-period="31556926"/>  
  43.   
  44. </beans>   

在web.xml中：

<web-app xmlns="http://java.sun.com/xml/ns/javaee"  
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
      xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
      version="3.0">
    <!-- 解析静态文件的第一种方式 -->
    <!--配合resetful请求方式，将静态文件交给tomcat来解析  -->
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.css</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.js</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.jpg</url-pattern>
    </servlet-mapping>
    <servlet>  
        <servlet-name>spring-mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:spring-mvc-servlet.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-mvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!-- 启动日志监听器，目的是读取配置文件的初始化值，启动日志功能 -->
    <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>classpath:log4j.properties</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    </listener>
    <!-- 字符监听器，目的是在读取配置文件的初始化值，启动UF8编码，解决前台给后台的乱码功能 -->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/</url-pattern>
    </filter-mapping>
    <!-- 配置错误页面 -->
    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/view/error404.jsp</location>
    </error-page>
    <error-page>
        <exception-type>java.lang.Throwable</exception-type>
        <location>/WEB-INF/view/error500.jsp</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/WEB-INF/view/error500.jsp</location>
    </error-page>
    <welcome-file-list>
        <welcome-file>Login.jsp</welcome-file>
    </welcome-file-list> 

<!--session超时配置 -->
    <session-config>
        <session-timeout>60</session-timeout>
    </session-config>
</web-app>

 

 

 

liliping28
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringMVC拦截路径问题
huangyh技术栈
11-01 2101
1.1 创建项目、 添加依赖 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://m
对springMVC的深入认识
两碗面的博客
01-16 274
1、MVC设计模式（这里讲的是b/s情况下的模式） 2、springMVC框架与spring的关系 springMVC只是spring框架的一个模块；如下图是spring整个框架的内容： 3、springMVC的框架结构原理 1、 用户发起请求，请求到DispatcherServlet前端控制器 DispatcherServlet（中央调度），负责reques
Spring MVC源码深度剖析开源架构源码2021.pdf
04-27
Spring MVC源码深度剖析开源架构源码2021.pdf
Spring mvc <mvc:resources ***/> 作用
坑里水库的博客
05-04 2063
如在页面需要导入其它页面，样式等等 "/> 可以用
SpringMVC 的<mvc:resources>使用映射路径展示文件服务器上的图片
热门推荐
yansong_8686的专栏
08-08 4万+
接上一篇提到的部署中的问题，可以采用 即可解决，然而使用这种方式也不是一帆风顺的，需要解决其他的一些配置问题。 首先，spring mvc 的标签是在spring3.0.4出现的，主要是用来进行静态资源的访问。我们项目中是这样使用的： 对应的xx.propterties文件中的值如下： mapping_path=poster
SpringMVC访问静态资源实例讲解
weixin_42581112的博客
03-30 411
林炳文Evankaka原创作品。转自https://blog.csdn.net/Evankaka/article/details/45647031     &...
SpringMVC的简单理解
均为学习笔记
04-22 4026
一、SpringMVC简介 1、什么是MVC MVC是一种软件架构的思想，将软件按照模型、视图 、控制器来划分 M：Model，模型层，指工程中的javaBean，作用是处理数据 JavaBean分为两类： ● 一类称为实体类Bean：专门存储业务数据的，如User、Student等等 ● 一类称为业务处理Bean：指Service或Dao对象，专门用于处理业务逻辑和数据访问。 V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据 C：Controlle.
SpringMvc深入理解源码分析视频
05-13
本视频课程“SpringMvc深入理解源码分析”旨在帮助开发者深入理解Spring MVC的工作原理和核心机制，从而更好地利用它来构建高效、可维护的Web应用。 在Spring MVC中，主要涉及以下几个核心概念： 1. **...
springmvc深入解析.pdf
10-04
Spring MVC深入解析 Spring MVC是一个基于...* 需要深入了解Spring Framework Spring MVC是一个功能强大且灵活的Web应用程序框架，对于大型Web应用程序的开发非常有用。但是，需要开发者具有深入的技术知识和经验。
SpringMVC深入总结
12-11
SpringMVC是一个强大的Java Web开发框架，用于构建MVC架构的应用程序。在Spring 3.0.5版本中，SpringMVC展现出了简洁...通过深入理解SpringMVC的这些核心概念，开发者能够更好地设计和实现高效、可维护的Web应用程序。
SpringMVC快速入门教程-深入分析
09-20
【SpringMVC快速入门教程-深入分析】 SpringMVC 是一个强大的Java Web应用程序开发框架，它简化了构建基于模型-视图-控制器(MVC)架构的Web应用...通过深入理解其核心机制和配置，你可以构建出高效、可维护的Web应用。
SpringMVC PPT_springmvc_
10-04
本教程将深入探讨 SpringMVC 的核心概念、配置以及实际应用。 一、SpringMVC 概述 SpringMVC 作为 Spring 框架的一部分，提供了处理 HTTP 请求和响应的强大功能。它通过解耦控制器、业务逻辑和服务层，使得开发者...
Springmvc中配置静态资源的两种方式
godkzz的博客
08-07 2300
一、<mvc:default-servlet-handler />标签 在springmvc配置文件中加入 <mvc:annotation-driven /> <mvc:default-servlet-handler /> 原理是： 加入<mvc:default-servlet-handler />标签后，框架会创建控制器对象DefaultServletHttpRequestHandler（类似我们自己创建的Controller对象）。Default
Spring MVC详解（转）
朱塔山的博客
06-26 1万+
1.1介绍Spring MVC是Spring Framework提供的Web组件，全称是Spring Web MVC,是目前主流的实现MVC设计模式的框架，提供前端路由映射、视图解析等功能Java Web开发者必须要掌握的技术框架1.2MVC是什么MVC是一种软件架构思想，把软件按照模型，视图，控制器来划分Model:模型层，指工程中的JavaBean，用来处理数据JavaBean分成两类：一类称为实体类Bean:专门用来存储业务数据，比如Student,User。
SpringMVC是什么？
越来越好ing的博客
09-06 706
一，首先是一个MVC框架。 在web模型中，MVC是一种很流行的框架，通过把Model，View，Controller分离，把较为复杂的web应用分成逻辑清晰的几部分，是为了简化开发，减少出错。还是为了组内开发人员之间的配合。总之就是一种分层工作的办法。   二，springMVC，是spring的一个子框架，当然拥有spring的特性，如依赖注入。 三，springMVC的信息流是什么样...
SpringMVC[万字长文]
qq_47142993的博客
08-03 1344
文章目录一、SpringMVC简介1、什么是MVC2、什么是SpringMVC3、SpringMVC的特点二、HelloWorld1、开发环境2、创建maven工程a>添加web模块b>打包方式：warc>引入依赖3、配置web.xmla>默认配置方式b>扩展配置方式4、创建请求控制器5、创建springMVC的配置文件6、测试HelloWorlda>实现对首页的访问b>通过超链接跳转到指定页面7、总结三、@RequestMapping注解1、@RequestMap
SpringMVC框架理解
qq_53732688的博客
05-20 1571
一、SpringMVC框架介绍 springmvc是一个基于mvc的web框架。 springmvc拥有控制器，作用跟Struts类似，用于接收外部请求，解析参数传给服务层。 MVC是指 Model（模型）、View（视图）、Controller（控制器）的简写。 MVC主要的作用是降低了视图与业务逻辑的双向耦合。 二、Springmvc架构原理解析 发起请求到中央调度器 DispatcherServlet。 中央调度器接收到请求后，调用 HandlerMapping 映射器查找 Handl
深入理解学习SpringMVC-基础篇
程序员小王的博客
11-18 948
SpringMVC 一、Springmvc介绍 1、什么是Springmvc? 在Spring基础上 开发的框架 springMVC框架，是控制器框架 c层框架（Struts2也是C层框架） 本质：替换Struts2框架充当控制器 为了使Spring可插入MVC架构,SpringFrameWork在Spring基础上开发SpringMVC框架,从而在使用Spring进行WEB开发时可以选择使用Spring的SpringMVC框架作为web开发的控制器框架 。 MVC开发模式 1、M 模型层 实体+dao
基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业）
最新发布
08-06
基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业）含有代码注释，新手也可看懂，个人手打98分项目，导师非常认可的项目，期末大作业和课程设计高分必看，下载下来，简单部署，就可以使用。 基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业） 基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业） 基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业） 基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业） 基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业） 基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业） 基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业）基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明（大作业）基于Python+OpenCV实现双目立体视觉的图像匹配与测距代码+文档说明。
深入理解SpringMVC架构模式
SpringMVC课堂笔记 在软件开发领域，SpringMVC是一个基于Spring框架的Model-View-Controller（MVC）实现，它极大地简化了Java Web应用程序的开发。MVC是一种设计模式，用于分离应用程序的不同部分，使得代码更加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值