SpringMVC入门

注：本文前面搭建部分引用Java大联盟，后部分是博主编写。本文最后附上Java大联盟二维码。

1.SpringMVC是什么？

SpringMVC是目前最好的实现MVC设计模式的框架，是Spring框架的一个分支产品，以SpringIOC容器为基础，并利用容器的特性来简化它的配置。SpringMVC相当于Spring的一个子模块，可以很好的和Spring结合起来进行开发，是JavaWeb开发者必须要掌握的框架。

2.SpringMVC能干什么？

实现了MVC设计模式，MVC设计模式是一种常用的软件架构方式：以Controller（控制层），Model（模型层），View（视图层）三个模块分离的形式来组织代码。

3.MVC流程

控制层接受到客户端请求，调用模型层生成业务数据，传递给视图层，将最终的业务数据和视图响应给客户端做展示SpringMVC就是对这套流程的封装，屏蔽掉很多底层代码，开放出接口，让开发者可以更加轻松快捷的完成基于MVC模式的Web开发。

4.SpringMVC实现原理

1.DispatcherServlet：前端控制器，是整个流程控制的核心，控制其他组件的执行，统一调度，降低组件之间的耦合性，相当于总指挥。

2.Handler：处理器，完成具体业务逻辑，相当于Servlet或Action。

3.HandlerMapping：DispatcherServlet接收到请求之后，通过HandlerMapping将不同的请求分发到不同的Handler。

4.HandlerInterceptor：处理器拦截器，是一个接口，如果我们需要做一些拦截处理，可以来实现这个接口。

5.HandlerExecutionChain：处理器执行链，包括两部分内容：Handler和HandlerInterceptor（系统会有一个默认的HandlerInterceptor，如果需要额外拦截处理，可以添加拦截器设置）。

6.HandlerAdapter：处理器适配器，Handler执行业务方法之前，需要进行一系列的操作包括表单数据的验证，数据类型的转换，将表单数据封装到JavaBean等等，这一系列的操作，都是由HandlerAdapter来完成，DispatcherServlet通过HandlerAdapter执行不同的Handler。

7.ModelAndView：装载了模型数据和视图信息，作为Handler的处理结果，返回给DispatcherServlet。

8.ViewResolver：视图解析器，DispatcherServlet通过它将逻辑视图解析成物理视图，最终将渲染结果响应给客户端。

以上就是SpringMVC的核心组件。那么这些组件之间是如何进行交互的呢？

我们来看SpringMVC的实现流程：

1.客户端请求被DispatcherServlet（前端控制器）接收。

2.根据HandlerMapping映射到Handler。

3.生成Handler和HandlerInterceptor（如果有则生成）。

4.Handler和HandlerInterceptor以HandlerExecutionChain的形式一并返回给DispatcherServlet。

5.DispatcherServlet通过HandlerAdapter调用Handler的方法做业务逻辑处理。

6.返回一个ModelAndView对象给DispatcherServlet。

7.DispatcherServlet将获取的ModelAndView对象传给ViewResolver视图解析器，将逻辑视图解析成物理视图View。

8.ViewResolver返回一个View给DispatcherServlet。

9.DispatcherServlet根据View进行视图渲染（将模型数据填充到视图中）。

10.DispatcherServlet将渲染后的视图响应给客户端。



如何使用？

看到上面的实现原理，大家可能会有这样的担心，SpringMVC如此众多的组件开发起来一定很麻烦吧？答案是否定的，SpringMVC使用起来非常简单，很多组件都由框架提供，作为开发者我们直接使用即可，并不需要自己手动编写代码，真正需要我们开发者进行编写的组件只有两个，Handler：处理业务逻辑， View：JSP做展示。

4.环境搭建

1.创建maven工程，创建pom.xml配置SpringMVC依赖jar包。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>com.hzit</groupId>
<artifactId>SpringMVCMaven</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>SpringMVCTest Maven Webapp</name>
<url>http://maven.apache.org</url>

<dependencies>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.1</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.1.RELEASE</version>
</dependency>
</dependencies>

<build>
<finalName>SpringMVCTest</finalName>
</build>
</project>

2.web.xml中配置SpringMVC的DispatcherServlet。

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
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_2_5.xsd"> <display-name></display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<!-- 指定springmvc.xml的路径 -->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

</web-app>

3.创建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.xsd"> 
<!-- 配置自动扫描 -->
<context:component-scan base-package="com.southwind.handler"></context:component-scan>

<!-- 配置视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀 -->
<property name="prefix" value="/"></property>
<!-- 后缀 -->
<property name="suffix" value=".jsp"></property>
</bean>

</beans>

自动扫描的类结合注解交给IOC容器来管理，视图解析器是SpringMVC底层的类，开发者只需要进行配置即可完成JSP页面的跳转，如何配置很简单，记住一条：目标资源路径=前缀+返回值+后缀。

比如DispatcherServlet返回index，配置文件中前缀是/，后缀是.jsp，代入上述公式：目标资源路径=/index.jsp。一目了然，不需要再解释。

4.创建Handler类。

@Controller
public class HelloHandler {

@RequestMapping("/index")
public String index(){
System.out.println("执行index业务代码");
return "index";
}

}

直接在业务方法出添加注解@RequestMapping(“/index”)，将URL请求index直接与index业务方法映射，使用起来非常方便。

5.启动tomcat，打开浏览器输入URL测试。



1.DispatcherServlet接收到URL请求index，结合@RequestMapping(“/index”)注解将该请求交给index业务方法。

2.执行index业务方法，控制打印日志，并返回”index”字符串。

3.结合springmvc.xml中的视图解析器配置，找到目标资源：/index.jsp，即根目录的index.jsp，将该jsp资源返回客户端完成响应。

SpringMVC环境搭建成功。

5.SpringMVC进阶部分

@Controller
@SessionAttributes(value= {"adress"})
public class SpringmvcHandler {

/**
* 简单示例
* @return
*/
@RequestMapping("/hello")
public String helloworld2() {

System.out.println("进入Hello world!");

return "success";
}

/**
* 控制器处理请求业务方法
* public String 方法名称(){
*      方法体
* }
*
* String:当方法处理完之后,所返回逻辑视图的名称
* params = {"name"} 单个请求参数
* params = {"name != tom"} 请求参数中不能有name = tom
* params = {"name"，"age"} 多个请求参数
* params = {"name"，"age != 13"} 请求参数中不能有age = 13 且必须有name这个参数
* params = {"name = tom"，"age != 13"} 请求参数中name必须等于tom age不能为13
*
* URL: /hello?name=tom
*
* 请求头 headers
* headers={ "accept=text/html" }
*
*/
@RequestMapping(value = "/hello" , method = RequestMethod.POST, params = {"name"}, headers={ "accept=text/html" })
public String helloworld1() {

System.out.println("进入Hello world!");

return "success";
}

/**
*
* @PathVariable 可以将URL中的占位符参数绑定到控制器处理方法的入参中
* URL: /PathVar/12
* value 可以省略
*/
@RequestMapping("testPathVar/{id}")
public String testPathVar(@PathVariable(value = "id") Integer id){
System.out.println("id = "+id);
//userDao.delete(id);
return "success";
}

/**
* 四种请求
*
* GET表示获取资源
* POST用来新建资源
* PUT用来更新资源
* DELETE用来删除资源
*
*/
@RequestMapping(value = "testGet/{id}", method = RequestMethod.GET )
public String testGet(@PathVariable("id") Integer id) {

System.out.println("ID为"+id+"正在用get方式请求资源......");

return "success";
}

/**
*
* POST方式
*
*/
@RequestMapping(value = "testPost", method = RequestMethod.POST )
public String testGet() {

System.out.println("正在用psot方式新建资源......");

return "success";
}

/**
* DELETE请求参数
*/
@RequestMapping(value = "testDelete/{id}", method = RequestMethod.DELETE )
public String testDelete(@PathVariable("id") Integer id) {

System.out.println("ID为"+id+"正在用delete方式删除资源......");

return "success";
}

/**
* PUT请求参数
*/
@RequestMapping(value = "testPut/{id}", method = RequestMethod.PUT)
public String testPut(@PathVariable("id") Integer id) {

System.out.println("ID为"+id+"正在用put方式更新资源......");

return "success";
}

/**
* 测试@RequestParam
* SpringMVC是通过处理方法的请求参数进行绑定形参声明前面
* 加入@RequestParam(value = "前端空间name的属性值")
*/
@RequestMapping(value = "/testRequestParam")
public String testRequestParam(@RequestParam(value = "id") Integer id,
@RequestParam(value = "name") String name) {

System.out.println("@RequestParam 获取前端请求id:"+id);
System.out.println("@RequestParam 获取前端请求name:"+name);

return "success";
}

/**
* 前端和接受参数名称一致可以省略注解
* 如果一致，必须进行用value关联
*/
@RequestMapping(value = "/testRequestParam2")
public String testRequestParam2(Integer id,String name) {

System.out.println("@RequestParam 获取前端请求id:"+id);
System.out.println("@RequestParam 获取前端请求name:"+name);

return "success";
}

/**
*POJO属性绑定参数
*/
@RequestMapping(value = "/testRequestParamPOJO")
public String testRequestParamPOJO(User u) {

System.out.println("@RequestParam 获取前端请求POJO-user:"+ u.toString());

return "success";
}

/**
*获取请求头中的参数信息
*/
@RequestMapping(value = "/testRequestHeader")
public String testRequestHeader(@RequestHeader("Accept") String accept,@RequestHeader("User-Agent") String Useragent) {

System.out.println("@RequestHeader 获取请求头Accept:"+ accept);
System.out.println("@RequestHeader 获取请求头User-Agent:"+ Useragent);

return "success";
}

/**
*获取请求头中的参数信息
*CookieValue
*/
@RequestMapping(value = "/testCookieValue")
public String testCookieValue(@CookieValue("JSESSIONID") String id) {

System.out.println("@CookieValue 获取CookieValue:"+ id);

return "success";
}

/**
* servlet API 对象
*
* HttpServletRequest
* HttpServletResponse
* HttpSession
* java.security.Principal
* locale 本地对象
* inputStream
* outputStream
* Reader
* Writer
*
*/
@RequestMapping(value = "/testServletAPI")
public String testServletAPI(HttpServletRequest request,HttpServletResponse reponse,HttpSession session) {

System.out.println("testServletAPI request:"+request);
System.out.println("testServletAPI reponse:"+reponse);
System.out.println("testServletAPI session:"+session);

return "success";
}

/**
* ModelAndView
* @return
*/
@RequestMapping(value = "/testModelAndView")
public ModelAndView testModelAndView() {

ModelAndView mv =  new ModelAndView();

//mv.setView("");  设置视图名称
mv.setViewName("success");
//设置参数  模型数据中的值是放到request中的
//addObject 参数String  obj
//addObjects 参数Map map
mv.addObject("name","tom");

return mv;
}

/**
* testMap
* @return
*/
@RequestMapping(value = "/testMap")
public String testMap(Map<String, Object> map) {

map.put("age", "18");

return "success";
}

/**
* testModel
* @return
*/
@RequestMapping(value = "/testModel")
public String testModel(Model model) {

model.addAttribute("email", "abc@qq.com");
return "success";
}

/**
* testModelMap
* @return
*/
@RequestMapping(value = "/testModelMap")
public String testModelMap(ModelMap modelMap) {

modelMap.addAttribute("adress", "adress");
return "success";
}

/**
* testSessionAttributes
* 在类上面标注@SessionAttributes
* 示例： @SessionAttributes(value= {"adress"})
* 这个adresss数据必须存在域中 resques范围中有效
* 示例：@SessionAttributes(types= {String.class})
* 表示将模型中所有String 施行共享
*/
@RequestMapping(value = "/testSessionAttributes")
public String testSessionAttributes() {

return "result";
}

/**
* ModelAttribute
* @param account
* @return
*/

@RequestMapping(value = "/testModelAttribute")
public String testModelAttributes(@ModelAttribute("abc")Account account) {

System.out.println("testModelAttributes account:"+account.toString());

return "success";
}

/**
* @ModelAttribute
* 设置请求之前回去数据库查询数据和进行比对
* @param map
*/
@ModelAttribute(value="abc") //用来指定map中的key
public Account start(Map<String, Object> map) {

//假设是从数据库中取出的对象进行更新
Account account = new Account(100, "tomJ", "2016-10-10");
//设置进modelMap中   如果不设置@ModelAttribute account必须和上面参数一样 否则必须要进行绑定设置
map.put("account", account);

return account;

}

/**
* 测试国际化让请求进入DisPatchServlet
* @return
*/
@RequestMapping(value = "/internationalization")
public String internationalization() {
return "internationalization";
}

@RequestMapping(value = "/toTime")
public String toTime() {

System.out.println("时间验证成功......");
return "success";
}

/**
* 用Ajax测试数据的接受的响应
* @param user
* @return
*/
@RequestMapping(value = "/ajax")
@ResponseBody
public User ajax(User user){
System.out.println("进入ajax........");
System.out.println("user:"+user.toString());
return user;
}

/**
* 用Ajax测试数据的接受的响应
* @param user
* @return
*/
@RequestMapping(value = "/ajaxs")
@ResponseBody
public User ajaxs(User user){
System.out.println("进入ajaxs........");
System.out.println("user:"+user.toString());
return user;
}

}

注解部分说明：

@RequestMapping（value = “”） 如果只有一个value, value可以省略

@RequestMapping 除了可以修饰方法之外，还可以修饰类

@RequestMapping 还支持Ant风格的URL

/user/*/hello 匹配 /user/aaa/hello URL

/user/**/hello 匹配 /user/aa/bb/hello URL 0个或多个路径

/user/hello? 匹配/user/helloa URL

Ant风格的请求映射

Ant风格资源地址支持3中匹配符

？：匹配文件名中的一个字符

*：匹配文件名中的任意字符

**：匹配多层路径

@PathVariable 映射URL绑定的占位符,带占位符的URL是Spring3.0新增加功能，该功能在SpringMVC 向REST目标挺

近发展过程中具有里程碑意义

-通过@PathVariable可以将URL中的占位符参数绑定到

控制器处理方法的入参中

示例：

@RequestMapping("delete/{id}")
public String delete(@PathVariable("id") Integer id){
userDao.delete(id);
return "success";
}

REST风格 资源表现层状态转化，是目前最流行的一种互联网软件架构，它结构清晰，符合标准，易于理解，扩展方便，所以现在得到越来越多的网站的采用

资源 表现层 状态转换

具体点说及时 HTTP协议里面

GET：表示获取资源

POST：用来新建资源

PUT：用来更新资源

DELETE：用来删除资源

web只提供get post 但是rest风格是四种 HiddenHttpMethodFilter:过滤器，可以过滤我们所有的请求

，并且可以将请求细分为四种

public class HiddenHttpMethodFilter extends OncePerRequestFilter {

/** Default method parameter: {@code _method} */
public static final String DEFAULT_METHOD_PARAM = "_method";

private String methodParam = DEFAULT_METHOD_PARAM;

/**
* Set the parameter name to look for HTTP methods.
* @see #DEFAULT_METHOD_PARAM
*/
public void setMethodParam(String methodParam) {
Assert.hasText(methodParam, "'methodParam' must not be empty");
this.methodParam = methodParam;
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {

String paramValue = request.getParameter(this.methodParam);
if ("POST".equals(request.getMethod()) && StringUtils.hasLength(paramValue)) {
String method = paramValue.toUpperCase(Locale.ENGLISH);
HttpServletRequest wrapper = new HttpMethodRequestWrapper(request, method);
filterChain.doFilter(wrapper, response);
}
else {
filterChain.doFilter(request, response);
}
}

/**
* Simple {@link HttpServletRequest} wrapper that returns the supplied method for
* {@link HttpServletRequest#getMethod()}.
*/
private static class HttpMethodRequestWrapper extends HttpServletRequestWrapper {

private final String method;

public HttpMethodRequestWrapper(HttpServletRequest request, String method) {
super(request);
this.method = method;
}

@Override
public String getMethod() {
return this.method;
}
}

}

浏览器只支持GET POST

GET 直接去找GET

POST 寻找请求参数，是否还有一个名字_method这样的请求方式，

DELETE,PUT请求如果没有，就是post

@RequestParam 绑定请求参数值

在处理方法入参处使用@RequestParam 可以把请求参数传递给请求方法

–value :请求名

–required :是否必须 默认为True,表示请求参数中必须包含对应的参数，若不存在，将

抛出异常

SpringMVC是通过处理方法的请求参数进行绑定形参声明前面，加入@RequestParam(value = “前端空间name的属性值”)

如果形参一致 则可以省略

POJO对象绑定属性值

前端name和属性名称一致，如果user里面有个属性引用其他对象，则

前端name用级联方式命名 比如 adress.city

@RequestHeader绑定请求爆头的属性值

请求头包含了若干个属性，服务器可据此获知客户端的信息

通过@requestHeader即可将请求头中的属性值绑定到处理

方法的入参中

/**
* 控制器处理请求业务方法
* public String 方法名称(){
*      方法体
* }
*
* String:当方法处理完之后,所返回逻辑视图的名称
* params = {"name"} 单个请求参数
* params = {"name != tom"} 请求参数中不能有name = tom
* params = {"name"，"age"} 多个请求参数
* params = {"name"，"age != 13"} 请求参数中不能有age = 13 且必须有name这个参数
* params = {"name = tom"，"age != 13"} 请求参数中name必须等于tom age不能为13
*
* URL: /hello?name=tom
*
* 请求头 headers
* headers={ "accept=text/html" }
*
*/
@RequestMapping(value = "/hello" , method = RequestMethod.POST, params = {"name"}, headers={ "accept=text/html" })
public String helloworld1() {

System.out.println("进入Hello world!");

return "success";
}

@CookieValue绑定请求中的Cookie值

/**
* servlet API 对象
*
* HttpServletRequest
* HttpServletResponse
* HttpSession
* java.security.Principal
* locale 本地对象
* inputStream
* outputStream
* Reader
* Writer
*
*/
@RequestMapping(value = "/testServletAPI")
public String testServletAPI(HttpServletRequest request,HttpServletResponse reponse,HttpSession session) {

System.out.println("testServletAPI request:"+request);
System.out.println("testServletAPI reponse:"+reponse);
System.out.println("testServletAPI session:"+session);

return "success";
}

@SessionAttributes:将模型中的某个属性值暂存到HttpSession中，一边多个请求之间可以共享这个属性

若希望在多个请求之间公用某个模型属性数据，则可以在控制器类上

标注一个@SessionAttributes,SpringMVC将模型中对应的属性暂时

存在HttpSession中

-@SessionAttributes除了可以通过属性名指定需要放到会话中的属性外

还可以通过属性模型对象类型指定哪些模型属性需要放到会话中

-@SessionAttributes(types=User.class)会将隐含模型中所有类型为User.class的属性添加到会话中.

-@SessionAttributes(value={“user1”,”user2”})

-@SessionAttributes(types={User.class,Dept.class})

-@SessionAttributes(value={“user1”,”user2”},types={Depts.calss})

下面直接贴出代码，每个功能都有想用解释(Jar包自己百度下载)

Controller

package com.springmvc.handler;

import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.servlet.ModelAndView;
import com.springmvc.domain.Account;
import com.springmvc.domain.User;

@Controller
@SessionAttributes(value= {"adress"})
public class SpringmvcHandler {

/**
* 简单示例
* @return
*/
@RequestMapping("/hello")
public String helloworld2() {

System.out.println("进入Hello world!");

return "success";
}

/**
* 控制器处理请求业务方法
* public String 方法名称(){
*      方法体
* }
*
* String:当方法处理完之后,所返回逻辑视图的名称
* params = {"name"} 单个请求参数
* params = {"name != tom"} 请求参数中不能有name = tom
* params = {"name"，"age"} 多个请求参数
* params = {"name"，"age != 13"} 请求参数中不能有age = 13 且必须有name这个参数
* params = {"name = tom"，"age != 13"} 请求参数中name必须等于tom age不能为13
*
* URL: /hello?name=tom
*
* 请求头 headers
* headers={ "accept=text/html" }
*
*/
@RequestMapping(value = "/hello" , method = RequestMethod.POST, params = {"name"}, headers={ "accept=text/html" })
public String helloworld1() {

System.out.println("进入Hello world!");

return "success";
}

/**
*
* @PathVariable 可以将URL中的占位符参数绑定到控制器处理方法的入参中
* URL: /PathVar/12
* value 可以省略
*/
@RequestMapping("testPathVar/{id}")
public String testPathVar(@PathVariable(value = "id") Integer id){
System.out.println("id = "+id);
//userDao.delete(id);
return "success";
}

/**
* 四种请求
*
* GET表示获取资源
* POST用来新建资源
* PUT用来更新资源
* DELETE用来删除资源
*
*/
@RequestMapping(value = "testGet/{id}", method = RequestMethod.GET )
public String testGet(@PathVariable("id") Integer id) {

System.out.println("ID为"+id+"正在用get方式请求资源......");

return "success";
}

/**
*
* POST方式
*
*/
@RequestMapping(value = "testPost", method = RequestMethod.POST )
public String testGet() {

System.out.println("正在用psot方式新建资源......");

return "success";
}

/**
* DELETE请求参数
*/
@RequestMapping(value = "testDelete/{id}", method = RequestMethod.DELETE )
public String testDelete(@PathVariable("id") Integer id) {

System.out.println("ID为"+id+"正在用delete方式删除资源......");

return "success";
}

/**
* PUT请求参数
*/
@RequestMapping(value = "testPut/{id}", method = RequestMethod.PUT)
public String testPut(@PathVariable("id") Integer id) {

System.out.println("ID为"+id+"正在用put方式更新资源......");

return "success";
}

/**
* 测试@RequestParam
* SpringMVC是通过处理方法的请求参数进行绑定形参声明前面
* 加入@RequestParam(value = "前端空间name的属性值")
*/
@RequestMapping(value = "/testRequestParam")
public String testRequestParam(@RequestParam(value = "id") Integer id,
@RequestParam(value = "name") String name) {

System.out.println("@RequestParam 获取前端请求id:"+id);
System.out.println("@RequestParam 获取前端请求name:"+name);

return "success";
}

/**
* 前端和接受参数名称一致可以省略注解
* 如果一致，必须进行用value关联
*/
@RequestMapping(value = "/testRequestParam2")
public String testRequestParam2(Integer id,String name) {

System.out.println("@RequestParam 获取前端请求id:"+id);
System.out.println("@RequestParam 获取前端请求name:"+name);

return "success";
}

/**
*POJO属性绑定参数
*/
@RequestMapping(value = "/testRequestParamPOJO")
public String testRequestParamPOJO(User u) {

System.out.println("@RequestParam 获取前端请求POJO-user:"+ u.toString());

return "success";
}

/**
*获取请求头中的参数信息
*/
@RequestMapping(value = "/testRequestHeader")
public String testRequestHeader(@RequestHeader("Accept") String accept,@RequestHeader("User-Agent") String Useragent) {

System.out.println("@RequestHeader 获取请求头Accept:"+ accept);
System.out.println("@RequestHeader 获取请求头User-Agent:"+ Useragent);

return "success";
}

/**
*获取请求头中的参数信息
*CookieValue
*/
@RequestMapping(value = "/testCookieValue")
public String testCookieValue(@CookieValue("JSESSIONID") String id) {

System.out.println("@CookieValue 获取CookieValue:"+ id);

return "success";
}

/**
* servlet API 对象
*
* HttpServletRequest
* HttpServletResponse
* HttpSession
* java.security.Principal
* locale 本地对象
* inputStream
* outputStream
* Reader
* Writer
*
*/
@RequestMapping(value = "/testServletAPI")
public String testServletAPI(HttpServletRequest request,HttpServletResponse reponse,HttpSession session) {

System.out.println("testServletAPI request:"+request);
System.out.println("testServletAPI reponse:"+reponse);
System.out.println("testServletAPI session:"+session);

return "success";
}

/**
* ModelAndView
* @return
*/
@RequestMapping(value = "/testModelAndView")
public ModelAndView testModelAndView() {

ModelAndView mv =  new ModelAndView();

//mv.setView("");  设置视图名称
mv.setViewName("success");
//设置参数  模型数据中的值是放到request中的
//addObject 参数String  obj
//addObjects 参数Map map
mv.addObject("name","tom");

return mv;
}

/**
* testMap
* @return
*/
@RequestMapping(value = "/testMap")
public String testMap(Map<String, Object> map) {

map.put("age", "18");

return "success";
}

/**
* testModel
* @return
*/
@RequestMapping(value = "/testModel")
public String testModel(Model model) {

model.addAttribute("email", "abc@qq.com");
return "success";
}

/**
* testModelMap
* @return
*/
@RequestMapping(value = "/testModelMap")
public String testModelMap(ModelMap modelMap) {

modelMap.addAttribute("adress", "adress");
return "success";
}

/**
* testSessionAttributes
* 在类上面标注@SessionAttributes
* 示例： @SessionAttributes(value= {"adress"})
* 这个adresss数据必须存在域中 resques范围中有效
* 示例：@SessionAttributes(types= {String.class})
* 表示将模型中所有String 施行共享
*/
@RequestMapping(value = "/testSessionAttributes")
public String testSessionAttributes() {

return "result";
}

/**
* ModelAttribute
* @param account
* @return
*/

@RequestMapping(value = "/testModelAttribute")
public String testModelAttributes(@ModelAttribute("abc")Account account) {

System.out.println("testModelAttributes account:"+account.toString());

return "success";
}

/**
* @ModelAttribute
* 设置请求之前回去数据库查询数据和进行比对
* @param map
*/
@ModelAttribute(value="abc") //用来指定map中的key
public Account start(Map<String, Object> map) {

//假设是从数据库中取出的对象进行更新
Account account = new Account(100, "tomJ", "2016-10-10");
//设置进modelMap中   如果不设置@ModelAttribute account必须和上面参数一样 否则必须要进行绑定设置
map.put("account", account);

return account;

}

/**
* 测试国际化让请求进入DisPatchServlet
* @return
*/
@RequestMapping(value = "/internationalization")
public String internationalization() {
return "internationalization";
}

@RequestMapping(value = "/toTime")
public String toTime() {

System.out.println("时间验证成功......");
return "success";
}

/**
* 用Ajax测试数据的接受的响应
* @param user
* @return
*/
@RequestMapping(value = "/ajax")
@ResponseBody
public User ajax(User user){
System.out.println("进入ajax........");
System.out.println("user:"+user.toString());
return user;
}

/**
* 用Ajax测试数据的接受的响应
* @param user
* @return
*/
@RequestMapping(value = "/ajaxs")
@ResponseBody
public User ajaxs(User user){
System.out.println("进入ajaxs........");
System.out.println("user:"+user.toString());
return user;
}

}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">

<display-name>SpringMVC_01</display-name>

<!-- Spring MVC servlet -->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 初始化 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<!-- 注意这个路径,配置文件路径 -->
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>

<!--
在servlet的配置当中，<load-on-startup>5</load-on-startup>的含义是：
标记容器是否在启动的时候就加载这个servlet。
当值为0或者大于0时，表示容器在应用启动时就加载这个servlet；
当是一个负数时或者没有指定时，则指示容器在该servlet被选择时才加载。
正数的值越小，启动该servlet的优先级越高。
-->
<load-on-startup>1</load-on-startup>

<!-- 在spring mvc3.2及以上版本增加了对请求的异步处理，是在servlet3的基础上进行封装的。 -->
<async-supported>true</async-supported>

</servlet>

<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<!-- 接受所有用户请求 注意这里是 / 不是  /*-->
<url-pattern>/</url-pattern>
</servlet-mapping>

<!-- delete put REST风格请求过滤器 -->
<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>

<!-- 欢迎页面，初始页面 -->
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

Sping-MVC.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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> 
<!--
<mvc:annotation-driven>作用帮我们取注册一个
ResquestHandlerMapping,完成我们的映射
RequestMappingHandlerAdapter, 获取请求参数以及绑定
ExceptionHandlerExceptionResolver 异常
<mvc:default-servlet-handler/>提供了默认Servlet控制器，其他的失效
<mvc:annotation-driven>会帮我们注册三个常用bean

如果都没有配置，默认会去注册RequestMappingHandlerAdapter
-->
<!-- 静态资源的处理 -->
<!-- 让DisPatchServlet控制器失效，所有URL也失效 -->
<mvc:default-servlet-handler/>
<!-- 这个是让其他的URL有效，配合上面的使用进行静态资源设置 -->
<mvc:annotation-driven></mvc:annotation-driven>

<!--  扫描注解 -->
<context:component-scan base-package="com.springmvc.*"></context:component-scan>
<!-- 视图解析器   定义跳转的文件的前后缀 ，视图模式配置-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
<property name="prefix" value="/" />
<property name="suffix" value=".jsp" />
</bean>

<!-- a标签选择国际化 -->
<bean id="SessionLocaleResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver"></bean>
<!-- a标签选择国际化 配合使用-->
<mvc:view-controller path="/globalA" view-name="global"/>
<!-- 国际化 -->
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<!-- abc 是配置文件的前缀名称   -->
<property name="basename" value="abc"></property>
</bean>

<!-- 自定义命名空间 -->
<!--
URL : http://localhost:8080/SpringMVC_01/thecustom  直接映射到internationalization.jsp页面
注意    : 如果配置了自定义视图路径,那么控制器中的所有映射将无效 直接抛出404
如果想要两种都可以运行，必须配置<mvc:annotation-driven></mvc:annotation-driven>
<mvc:annotation-driven>是spring3.0之后增加的
-->
<mvc:view-controller path="/thecustom" view-name="internationalization"/>
<!--  这个是配置自己自定义视图解析器解析路径    -->
<mvc:view-controller path="/thecustomView" view-name="thecustomView"/>
<mvc:annotation-driven></mvc:annotation-driven>

<!--  配置自定义视图解析器    -->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
<!-- roder 视图解析器的优先级,值越小优先级越高,反之 -->
<property name="order" value="100"></property>
</bean>

<!-- 自定义拦截器 -->
<mvc:interceptors>

<!-- a标签选择国际化资源拦截器，配合下面  SessionLocaleResolver 使用 且这个拦截器是拦截所有 -->
<bean id="localeChangeInterceptor" class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"></bean>

<!-- mvc:interceptor 是一个关于拦截器的声明，mvc:mapping指定配置所有拦截器要拦截的资源-->
<!--
如果拦截所有请求<mvc:interceptor>去掉即可<mvc:interceptors>直接放入<bean id="interceptor"....
<mvc:mapping... 和  <mvc:interceptor> 删除即可。
-->
<mvc:interceptor>
<mvc:mapping path="/toTime"/>
<bean id="interceptor" class=" com.springmvc.interceptor.Interceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>

</beans>

个人demo链接：https://download.csdn.net/download/weixin_40263776/10280308

友情链接：


如有不对，还望指正