SpringMVC笔记--1 SpringMVC简介

最新推荐文章于 2021-03-22 20:48:45 发布

hancoder

最新推荐文章于 2021-03-22 20:48:45 发布

阅读量593

点赞数

分类专栏： Spring 文章标签： Spring SpringMVC

blog.csdn.net/hancoder 可以打赏后索要离线md文件，打赏码在谷粒笔记的文尾。博主目前就职于阿里云，有需要可内推

本文链接：https://blog.csdn.net/hancoder/article/details/103451438

版权

Spring 专栏收录该内容

31 篇文章 26 订阅

订阅专栏

第0章 SpringMVC框架的核心内容

1.SpringMVC 概述
2.SpringMVC 的 HelloWorld
3.使用 @RequestMapping 映射请求
4.映射请求参数 & 请求头
5.处理模型数据
6.视图和视图解析器
7.RESTful CRUD
8.SpringMVC 表单标签 & 处理静态资源
9.处理 JSON：使用 HttpMessageConverter 
10.文件的上传
11.使用拦截器 
12.SpringMVC 运行流程
13.在 Spring 的环境下使用 SpringMVC

第1章 SpringMVC 概述

1.1 SpringMVC 概述

1） Spring 为展现层提供的基于 MVC 设计理念的优秀的 Web 框架，是目前最主流的MVC 框架之一

2）Spring3.0 后全面超越 Struts2，成为最优秀的 MVC 框架。

3）Spring MVC 通过一套 MVC 注解，让 POJO 成为处理请求的控制器，而无须实现任何接口。

4）支持 REST 风格的 URL 请求。

5）采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性和灵活性。

1.2 SpringMVC是什么

1）一种轻量级的、基于MVC的Web层应用框架。偏前端而不是基于业务逻辑层。Spring框架的一个后续产品。

2）Spring框架结构图(新版本)：

1.3 SpringMVC能干什么

1）天生与Spring框架集成，如：(IOC,AOP)

2）支持Restful风格

3）进行更简洁的Web层开发

4）支持灵活的URL到页面控制器的映射

5）非常容易与其他视图技术集成，如:Velocity、FreeMarker等等

6）因为模型数据不存放在特定的API里，而是放在一个Model里(Map数据结构实现，因此很容易被其他框架使用)

7）非常灵活的数据验证、格式化和数据绑定机制、能使用任何对象进行数据绑定，不必实现特定框架的API

8）更加简单、强大的异常处理

9）对静态资源的支持

10）支持灵活的本地化、主题等解析

1.4 SpringMVC怎么玩

1）将Web层进行了职责解耦，基于请求-响应模型

2） springMVC常用主要组件

① DispatcherServlet：前端控制器，接收所有请求(如果配置/不包含 jsp)。Spring MVC围绕DispatcherServlet这个核心展开。DispatcherServlet是Spring MVC的总导演，总策划，它负责截获请求并将其分派给响应的处理器处理。

② Controller：处理器/页面控制器，做的是MVC中的C的事情，但控制逻辑转移到前端控制器了，用于对请求进行处理

③ HandlerMapping ：将请求映射到处理器（方法），找谁来处理，如果映射成功返回一个HandlerExecutionChain对象（包含一个Handler处理器(页面控制器)对象、多个HandlerInterceptor拦截器对象）

④ View Resolver : 视图解析器，找谁来处理返回的页面。把逻辑视图解析为具体的View，进行这种策略模式，很容易更换其他视图技术；

如InternalResourceViewResolver将逻辑视图名映射为JSP视图

⑤ LocalResolver：本地化、国际化

⑥ MultipartResolver：文件上传解析器

⑦ HandlerExceptionResolver：异常处理器

HandlerAdapter：负责调用具体的方法.

1.5 永远的HelloWorld

HelloWorld请求流程图解：

流程：

1、浏览器客户端发出HTTP请求，WEB应用服务器接收到这个请求，如果匹配到DispatcherServlet的请求映射路径（web.xml中指定），web容器就将该请求转交给DispatcherServlet处理。

2、由DispatcherServlet控制器根据请求的信息（URL、HTTP方法、请求报文头、请求参数、Cookie等）及HandlerMapping的配置找到处理请求的处理器（Handler）。可将HandlerMapping看成路由控制器，将Handler看成目标主机。值得注意的是：Spring MVC中并没有定义一个Handler接口，实际上任何一个Object都可以成为请求处理器。

3、当DispatcherServlet根据HandlerMapping得到对应请求的Handler后，通过HandlerAdapter对Handler进行封装，再以统一的适配器接口调用Handler。HandlerAdapter是Spring MVC的框架级接口，顾名思义，HandlerAdapter是一个适配器，它用统一的接口对各种Handler方法进行调用。

4、处理器完成业务逻辑的处理后由HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet，ModelAndView包含了视图逻辑名和模型数据信息。

5、ModelAndView中的包含的是”逻辑视图名“，而非真正的视图对象，DispatcherServlet将ModelAndView传给视图解析器（ViewResolver）完成逻辑视图名到真实视图对象的解析工作，ViewReslover解析后返回具体View给DispatcherServlet。

6、当得到真实的视图对象View后，DispatcherServlet就使用这个View对象对ModelAndView中的模型数据进行视图渲染。然后DispatcherServlet将渲染结果响应给用户。

7、最终客户端得到相应消息，可能是一个普通的HTML页面，也可能是一个XML或JSON串，甚至是一张图片或一个PDF文档等不同的媒体形式。

代码步骤：

创建web工厂，导入jar包
在 web.xml 中配置MVC前端控制器 DispatcherServlet
配置SpringMVC的核心配置文件：springmvc.xml
需要创建一个入口页面，index.jsp
编写处理请求的处理器，并标识为处理器
浏览器端发送请求，请求服务器处理请求

1）新建Web工程，加入 jar 包

spring-aop-4.0.0.RELEASE.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar

commons-logging-1.1.3.jar

spring-web-4.0.0.RELEASE.jar
spring-webmvc-4.0.0.RELEASE.jar

2）web.xml

在 web.xml 中配置MVC前端控制器 DispatcherServlet

快捷方法：可以使用Ctrl+/快捷键，选DispatcherServlet即可

-------WEB-INF/web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">

    <!-- 配置SpringMVC核心控制器： -->
    <servlet>

        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置DispatcherServlet的初始化参数：设置文件的路径和文件名称
        初始化 DispatcherServlet的时候就会读取springmvc.xml，就会创建容器对象
        -->
        <init-param><!--代表实例化servlet的时候，就把springmvc的容器创建出来了。
   如果这里没配置spring.xml的话默认是/WEB-INF/【<servlet-name>-serlvet.xml】-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param> 

        <!--servlet的创建时机分为请求到达以后创建，服务器启动即创建。
  这里设置为在服务器启动时加载DispatcherServlet
		Servlet的创建时机：
					 1. 请求到达以后创建
					 2. 服务器启动即创建
-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--指定请求的匹配-->
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern><!--除了jsp都拦，除了jsp访问不到。所以像js，html等文件，要告诉springmvc这个是静态资源，别阻拦了
        相当于/* 但是区别是排除了jsp的请求不处理-->
    </servlet-mapping> 
</web-app>

附：

原来我们见到的是所见即所得，即标签中会写我们要跳转到哪个class中，然后由该class中的service方法处理请求。

而现在的标签只是代表他是一个DispatcherServlet，还需要进入指定的下一级xml中来检测什么虚拟路径去访问什么方法。而到了指定的下一级xml中，有了组件扫描，就要扫描那些带@RequestMapping注解的方法

Spring MVC所有的请求都经过DispatcherServlet来统一分发。DispatcherServlet将请求分发给Controller之前，需要借助于Spring MVC提供的HandlerMapping定位到具体的Controller。

HandlerMapping接口负责完成客户请求到Controller的映射。

Controller接口处理用户请求，这和java Servlet扮演的角色是一致的。一旦Controller处理完用户请求，则返回ModelAndView对象给DispatcherServlet前端控制器，ModelAndView中包含了模型model和视图view。

从宏观角度考虑，HandlerMapping是整个Web应用的控制器；从微观角度考虑，Controller是单个HTTP请求处理过程中的控制器，而ModelAndView是HTTP请求过程中返回的模型和视图。

ViewResolver接口在Web应用中负责查找View对象，从而将相应结果渲染给客户。

① 解释配置文件的名称定义规则:

实际上也可以不通过 contextConfigLocation标签来配置 SpringMVC 的配置文件, 而使用默认的.默认的配置文件为: /WEB-INF/-servlet.xml

<!-- 字符编码过滤器 -->
  <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>

附配置REST 过滤器

  <!-- 配置REST 过滤器  HiddenHttpMethodFilter
  	    将满足转换条件的请求进行转换. 
  	  1. 必须是post请求
  	  2. 必须要通过_method能获取到一个请求参数值(要转换成的请求方式)
   -->
  <filter>
  	<filter-name>HiddenHttpMethodFilter</filter-name>
  	<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>HiddenHttpMethodFilter</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>

3）springmvc.xml

加入 Spring MVC 的配置文件：springmvc.xml

Spring使用扫描机制来找到应用程序中所有基于注解的控制器类。为了保证Spring能找到控制器，需要完成两件事情：

1）需要在Spring MVC的配置文件中声明名称空间，spring-context（还有beans、mvc）

<beans 
   ...
  xmlns:context="http://www.springframework.org/schema/context"
   ...
>
...    
</beans>

2）需要应用元素，

<context:component-scan base-package="basePackage"/>

实例

下面xml里好像没加mvc的1-2

--------------springmvc.xml-----------
<?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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
	<!--  1. 组件扫描：为了扫描注解 -->
	<context:component-scan base-package="com.atguigu.springmvc"></context:component-scan>
	
	<!--  2. 视图解析器：如何把handler方法返回值解析为实际的物理视图
		 工作机制:  prefix + 请求处理方法的返回值 + suffix  =  物理视图路径. 
		 	例如： /WEB-INF/views/success.jsp
		WEB-INF: 是服务器内部路径。 不能直接从浏览器端访问该路径下的资源. 但是可以内部转发进行访问
        	Content下的index.jsp可以直接访问-->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>不能加任何前缀
		<property name="suffix" value=".jsp"></property>
	</bean>
	
</beans>

路径问题：

@RequestMapping(value="/hello")（value等于的值并不是一个路径，/hello只是一个字符串，用作匹配。/可写可不写）
index.jsp中的超链接<a href="hello">Hello SpringMVC</a>中的href="hello"，不能加/，因为这代表相对路径和绝对路径。相对路径下是相对于当前路径来发送请求，当前路径是原来文件的路径，而不是项目路径。如果href="/hello"，那么我们要请求的是http://localhost:8888/hello，这不是我们正确的http://localhost:8888/springmvc01/hello。

静态资源：

在部署描述符中的元素，Spring MVC的DispatcherServlet的URL模式设置为"/"，因为这所有的请求（包括那些用于静态资源）都被映射到DispatcherServlet。为了正确处理静态资源，需要在Spring MVC配置文件中添加一些元素：

<?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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    <!-- 扫描注解 -->
	<context:component-scan base-package="com.bjsxt.controller"></context:component-scan>
    
	<!-- 注解驱动 -->
	<!-- 包含了org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping -->
	<!-- org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter -->
	<mvc:annotation-driven></mvc:annotation-driven>
    
	<!-- 静态资源。用于指示Spring MVC哪些静态资源需要单独处理（不通过DispatcherServlet）。配置resources标签时必须配置annotation-driven标签
	两个*代表子目录下所有文件 -->
	<mvc:resources location="/js/" mapping="/js/**"></mvc:resources>
	<mvc:resources location="/css/" mapping="/css/**"></mvc:resources>
	<mvc:resources location="/images/" mapping="/images/**"></mvc:resources>
    <!--<mvc:resources location="/WEB-INF/js/" mapping="/js/**"></mvc:resources>-->
</beans>

Spring MVC的配置文件中最主要的是元素，这是要指示Spring MVC扫描目标包中的控制器类，本例是controller包。

接下来是元素，该元素做了很多事情，其中包括注册用于控制器注解的bean对象；

最后是元素，用于指示Spring MVC哪些静态资源需要单独处理（不通过DispatcherServlet）。

在上面的配置中，有两个元素。第一个确保在/css目录下的所有文件可见，第二个允许显示所有的/.html文件。

注意：如果没有元素，元素会阻止任意控制器被调用。若不需要使用元素，则不需要元素元素。

4）index.jsp

需要创建一个入口页面，index.jsp，

<a href="${pageContext.request.contextPath}/helloworld">Hello World</a>

点击会跳转到一个方法上，该方法上有注明@RequestMapping(value="/helloworld",method=RequestMethod.GET)，即下面HelloWorldController.java的方法

5）HelloWorldController.java

编写处理请求的处理器，并标识为处理器

package com.atguigu.springmvc.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
//org.springframework.stereotype.Controller注解类型位于spring-context-x.x.x.RELEASE.jar包下，用于指示Spring类的实例是一个控制器。 

@Controller  //声明Bean对象，为一个控制器组件。不能随便加。请求处理器+控制器//这个注解不能变，请求器和控制器必须加@Controller，把SpringMVCHandler标识为一个请求处理器
public class HelloWorldController {
 
    /**
     * 映射请求的名称：用于客户端请求；类似Struts2中action映射配置的action名称
     * 1. 使用 @RequestMapping 注解来映射请求的 URL
     * 2. 返回值会通过视图解析器解析为实际的物理视图, 
     对于 InternalResourceViewResolver 视图解析器, 会做如下的解析:
     *          通过 prefix + returnVal + suffix 这样的方式得到实际的物理视图, 然后做转发操作.
     *      /WEB-INF/views/success.jsp
     */
    @RequestMapping(value="/helloworld",method=RequestMethod.GET)//相当于/项目/helloworld
    public String helloworld(){//handler方法
         System.out.println("hello,world");
         return "success"; //结果如何跳转呢？需要配置映射解析器//查看xml中的视图解析器
        //handler方法返回值
    }        
}

6）success.jsp

编写视图

/WEB-INF/views/success.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>Insert title here</title>
</head>
<body>
	<h1>Success Page.</h1>
</body>
</html>

7）部署测试：

http://localhost:8080/SpringMVC_01_HelloWorld/index.jsp

1.6 HelloWorld流程深度解析

1. 描到请求处理器， 以及请求处理中@RequestMapping注解，能得到具体的请求与请求处理器中方法的映射。
启动tomcat服务器，读取web.xml中的`<param-value>classpath:springmvc.xml</param-value>`，会加载DispatcherServlet（前端控制器），然后就会读取`springmvc.xml`，读取其中的`<context:component-scan base-package="com.atguigu.springmvc">`，组件扫描到`com.atguigu.springmvc`目录下的全部控制器（**Controller**），最终找到`/com/atguigu/springmvc/helloWorld/SpringMVCHandler.java`中的具体的请求处理器`@Controller public class SpringMVCHandler `。同时也扫描到了其中的对应的方法`@RequestMapping(value="/hello")`。此时springMVC的容器对象创建好了，也知道了有哪些请求处理器、请求处理器中有哪些方法、每个方法能处理什么请求。即准备好了具体的请求与什么方法之间的映射）。

2. 客户端发送请求: http://localhost:8888/Springmvc01/hello

3. 请求到达web.xml中与<url-pattern>进行匹配， 匹配成功，就将请求交给DispatcherServlet。虽然找到了`DispatcherServlet`，但是不处理，而是找到请求处理器。注意此时匹配成功只是找到了对应的DispatcherServlet，并没有找到具体的处理方法。

4. DispatcherServlet根据请求与请求处理方法的映射，将请求交给具体的请求处理器中的请求处理方法来进行处理。pringMVCHandler.java中的`@RequestMapping(value="/hello")`捕捉到/hello，然后处理返回`return "success";`（value等于的值并不是一个路径，/hello只是一个字符串，用作匹配。/可写可不写）。

5. 请求处理方法处理完请求， 最终方法会返回一个字符串

6. 然后被springmvc.xml中的视图解析器`<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">`捕捉到，视图解析器根据请求处理方法返回的结果， prefix + returnValue + suffix, 逻辑视图解析生成具体的物理视图路径：`/WEB-INF/views/success.jsp`，再通过转发的方式去往物理视图。输出界面`<h1>Success Page.</h1>`。

1）

1）用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获；

2） DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）:

判断请求URI对应的映射

① 不存在：

l 再判断是否配置了mvc:default-servlet-handler：

l 如果没配置，则控制台报映射查找不到，客户端展示404错误

l 如果有配置，则执行目标资源（一般为静态资源，如：JS,CSS,HTML）

② 存在：

l 执行下面流程

3）根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；

4） DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。

5）如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(…)方法【正向】

6）提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)方法，处理请求。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

① HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息

② 数据转换：对请求消息进行数据转换。如String转换成Integer、Double等

③ 数据根式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等

④ 数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

7） Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；

8）此时将开始执行拦截器的postHandle(…)方法【逆向】

9）根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet，根据Model和View，来渲染视图

10）在返回给客户端时需要执行拦截器的AfterCompletion方法【逆向】

11）将渲染结果返回给客户端

不存在映射的流程

1）正常流程，运行出结果

2）没有配置<mvc:default-servlet-handler/>，测试，直接报404。因为DispatcherServlet 拦截了所有请求，却没有找到静态资源或者映射，所以全交给了DispatcherServlet ，但是没找到mapping

① http://localhost:8080/SpringMVC_09_WorkFlow/helloworld2

四月 20, 2016 11:53:19 上午 org.springframework.web.servlet.PageNotFound noHandlerFound

警告: No mapping found for HTTP request with URI [/SpringMVC_09_WorkFlow/helloworld2] in DispatcherServlet with name ‘springDispatcherServlet’

② http://localhost:8080/SpringMVC_09_WorkFlow/test.html

四月 20, 2016 11:54:16 上午 org.springframework.web.servlet.PageNotFound noHandlerFound

警告: No mapping found for HTTP request with URI [/SpringMVC_09_WorkFlow/test.html] in DispatcherServlet with name ‘springDispatcherServlet’

3）配置了<mvc:default-servlet-handler/>后，测试，会去查找目标资源

没有显示警告。DispatcherServlet 没有找到映射，会交给Tomcat去查看静态资源。所以控制台没有警告。但没有找到静态资源，所以也显示404

4）测试，之前能正常访问的却报错了，这时，需要配置：<mvc:annotation-driven/>，否则，映射解析不好使。

2）一般请求的映射路径名称和处理请求的方法名称最好一致（实质上方法名称任意）

@RequestMapping(value="/helloworld",method=RequestMethod.GET)
public String helloworld(){
    //public String abc123(){
    System.out.println("hello,world");
    return "success";也可以写../到上级目录的形式
}

3）演示一个错误

经常有同学会出现配置上错误，把“/WEB-INF/views/”配置成了 "/WEB-INF/views"

<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

4）处理请求方式有哪几种

public enum RequestMethod {
    GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
}

5） @RequestMapping可以应用在什么地方

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {…}

回顾原来servlet的写法

前面index.jsp中有
    <a href="dispatcher?control=demo1">跳转1</a>
--------------------------
@WebServlet("/")//此时除了jsp都过滤。随意会走控制器，输出了hello。带jsp的走页面，不输出hello；放行jsp，不处理jsp，只认为他是个文件//相当于SpringMVC中的<serlet-mapping>中的<url-pattern>
   // 如果是/*
public class DispatchServlet extends HttpServlet{
    @Override
    protected void service(HttpServletRequest req,HttpServletResponse resp){
        String result = req.getParameter("control");
        System.out.println("result");
        System.out.println("hello执行控制器");
    }
}

发送请求，DispatcherServlet负责接收所有的请求，HandlerMapping负责解析请求，解析完后，适配器调用方法controller（handler）处理后，数据交给ViewResovler，ViewResovler处理完后把最后结果响应给客户。

配置web.xml的DispatcherServlet后，调用DispatcherServlet的无参构造器。创建一个application context。相当于New ApplicationContext，会利用init-params中内容。classpath：代表去src下加载。

/**
     * Create a new {@code DispatcherServlet} that will create its own internal web
     * application context based on defaults and values provided through servlet
     * init-params. Typically used in Servlet 2.5 or earlier environments, where the only
     * option for servlet registration is through {@code web.xml} which requires the use
     * of a no-arg constructor.
     * <p>Calling {@link #setContextConfigLocation} (init-param 'contextConfigLocation')
     * will dictate which XML files will be loaded by the
     * {@linkplain #DEFAULT_CONTEXT_CLASS default XmlWebApplicationContext}
     * <p>Calling {@link #setContextClass} (init-param 'contextClass') overrides the
     * default {@code XmlWebApplicationContext} and allows for specifying an alternative class,
     * such as {@code AnnotationConfigWebApplicationContext}.
     * <p>Calling {@link #setContextInitializerClasses} (init-param 'contextInitializerClasses')
     * indicates which {@code ApplicationContextInitializer} classes should be used to
     * further configure the internal application context prior to refresh().
     * @see #DispatcherServlet(WebApplicationContext)
     * 
     */
    public DispatcherServlet() {
        super();
        setDispatchOptionsRequest(true);
    }

helloworld: https://www.cnblogs.com/zyly/p/10819732.html

附：rest

<%@ 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>Insert title here</title>
</head>
<body>
	<a href="testServletAPI">Test Servlet API</a>
	<br/>
	<form action="testPOJO" method="post">
		用户名称: <input type="text" name="username"/>
		<br/>
		用户密码: <input type="password" name="password"/>
		<br/>
		用户邮箱: <input type="text" name="email"/>
		<br/>
		用户性别: 男 <input type="radio" name="gender" value="1"/>
				女<input type="radio" name="gender" value="0"/>
		<br/>
		<!-- 支持级联的方式 -->
		用户省份: <input type="text" name="address.province" />
		<br/>
		用户城市: <input type="text" name="address.city"/>
		<br/>
		<input type="submit" value="注册"/>
				
	</form>
	
	
	<br/>
	
	<a href="testCookieValue"> Test CookieValue</a>
	<br/>
	<a href="testRequestHeader">Test RequestHeader</a>
	<br/>
	
	<a href="testRequestParam?username=Tom&age=22">Test RequestParam</a>
	<br/>
	<!-- 修改一个订单 -->
	<form action="order" method="post">
		<input type="hidden" name="_method" value="PUT"/>
		<input type="submit" value="REST PUT"/>
	</form>
	<br/>
	
	<!-- 添加一个新的订单 -->
	<form action="order" method="post">
		<input type="submit" value="REST POST"/>		
	</form>
	<br/>
	<!-- 删除id为1001的订单 -->
	<form action="order/1001" method="post">
		<!-- 隐藏域· -->
		<input type="hidden" name="_method" value="DELETE"/>
		<input type="submit" value="REST DELETE"/>
	</form>
	<br/>
	<!-- 查询id为1001的订单 -->
	<a href="order/1001">REST GET</a>
	<br/>
	
	<a href="testPathVariable/Admin/1001">Test PathVaribale</a>
	<br/>
	<a href="testRequestMappingParamsAndHeaders?username=tom&age=22">Test RequestMapping Params  Headers</a>
	<br/>
	<form action="testRequestMappingMethod" method="post">
		<input type="submit" value="POST"/>
	</form>
	<br/>
	<a href="testRequestMappingMethod">Test RequestMapping Method</a>
	<br/>
	<a href="testRequestMapping">Test RequestMapping</a>
	<br/>
	<!-- 
		相对路径: 不以/开头的路径 . 相对于当前路径来发送请求. 
		绝对路径: 以/开头的路径 . 直接在 http://localhost:8888 后面拼接请求. 
	 -->
	<a href="hello">Hello SpringMVC</a>
</body>
</html>

hancoder

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
SpringMVC笔记--1 SpringMVC简介

第0章 SpringMVC框架的核心内容1.SpringMVC 概述2.SpringMVC 的 HelloWorld3.使用 @RequestMapping 映射请求4.映射请求参数 & 请求头5.处理模型数据6.视图和视图解析器7.RESTful CRUD8.SpringMVC 表单标签 & 处理静态资源9.处理 JSON：使用 HttpMessageConve...
复制链接

扫一扫