SpringMVC简介

MVC体系结构

三层架构

我们的开发架构一版基于两种形式，一种是C/S架构，也就是客户端/服务器；一种是B/S架构，也就是浏览器/服务器架构。在JavaEE开发中，基本上都是基于B/S架构的开发。那么在B/S架构中，系统标准的三层架构包括：表现层、业务层和持久层。

三层架构中，每一层都各司其职。详情如下：

• 表现层：也就是我们常说的web层。它负责接收客户端请求，向客户端响应结果。通常客户端使用http协议请求web层，web层接收http请求，完成http响应。表现层包括展示层和控制层：控制层负责接受请求，展示层负责结果的展示。表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端。
• 业务层：也就是我们常说的service层。它负责业务逻辑的处理，和我们项目开发的需求息息相关。web层依赖业务层，业务层不依赖web层。业务层再进行业务处理的时候可能会依赖持久层。如果要对数据持久化需要保证事务一致性。
• 持久层：也就是我们常说的dao层。负责数据持久化，包括数据层（及数据库）和数据访问层，数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。通俗来讲，持久层就是和数据库交互，对数据库表进行增删改查的。

MVC设计模式

MVC全名是Model View Controller，是模型(model)-视图(view)-控制器(controller)的缩写，是一种用于设计创建Web应用程序表现层的模式。其各个部分为：

• Model（模型）：模型包含业务模型和数据模型，数据模型用于封装数据，业务模型用于处理业务。
• View（视图）：通常指的是我们的jsp或者html。作用一般就是展示数据的。通常视图是依据模型数据创建的。
• Controller（控制器）：是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的。

MVC倡导：每一层只编写自己的东西，不编写任何其他的代码。分层是为了解耦，解耦是为了维护方便和分工协作。

SpringMVC是什么

SpringMVC全名叫做Spring Web MVC，是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品。Spring的架构图如下：

SpringMVC已经成为目前最流行额MVC框架之一，并且随着Spring3.0的发布，全面超越Structs2，成为最优秀的MVC框架。

SpringMVC本质可以认为是对servlet的封装，简化了我们serlvet的开发。其处理请求流程如图所示：

SpringMVC的工作流程

SpringMVC请求处理流程

这个是我们面试中经常被问到的问题。详细来讲，一共分为十一步。我们参考下图所介绍：

详细流程如下：

• 第一步：用户发送请求值前端控制器DispatcherServlet。
• 第二步：DispatcherServlet收到请求调用HandlerMapping处理映射器。
• 第三步：处理映射器根据Url找到具体的Handler（后端控制器），生成处理器对象及处理器拦截器（如果有，就生成）一并返回给DispatcherServlet。
• 第四步：DispatcherServlet调用HandlerAdapter处理器适配器去调用Handler。
• 第五步：处理器适配器执行Handler。
• 第六步：Handler执行完成给处理器适配器返回ModelAndView。
• 第七步：处理器适配器向前端控制器返回ModelAndView（ModelAndView是SpringMVC框架的一个底层对象，包括Model和View）。
• 第八步：前端控制器请求视图解析器去进行视图解析，根据逻辑视图名来解析真正的视图。
• 第九步：视图解析器向前端控制器返回View。
• 第十步：前端控制器进行视图渲染，就是将模型数据（在ModelAndView对象中）填充到request域。
• 第十一步：前端控制器向用户响应结果。

SpringMVC九大组件

SpringMVC一共包含九大组件，详情如下：

• HandlerMapping（处理器映射器）：HandlerMapping是用来查找Handler的，也就是处理器，具体的表现形式可以是类，也可以是方法。比如，标注了@RequestMapping的每个方法都可以看成是一个Handler。Handler负责具体实际的请求处理。在请求到达后，HandlerMapping的作用便是找到请求相应的处理器Handler和Interceptor。
• HandlerAdapter（处理器适配器）：HandlerAdapter是一个适配器。因为SpringMVC中Handler可以是任意形式的，只要能处理请求即可。但是把请求交给Servlet的时候，由于Servlet的方法结构都是doService(HttpServletRequest req, HttpServletResponse resp)形式的。要让固定的Servlet处理方法调用Handler来进行处理，便是HandlerAdapter的职责。
• HandlerExceptionResolver：HandlerExceptionResolver用于处理Handler产生的异常情况。它的作用是根据异常设置ModelAndView，之后交给渲染方法进行渲染，渲染方法会将ModelAndView渲染成页面。
• ViewResolver：ViewResolver即视图解析器，用于将String类型的视图名和Locale解析为View类型的视图，只有一个resolveViewName()方法。从方法的定义可以看出，Controller层返回的String类型视图名viewName最终会在这里被解析成View。View是用来渲染页面的，也就是说，它会将程序返回的参数和数据填入模板中，生成html文件。ViewResolver在这个过程主要完成两件事情：ViewResolver找到渲染所用的模板（第一件大事）和所用的技术（第二件大事，其实也就是找到视图的类型，如JSP）并填入参数。默认情况下，SpringMVC会自动为我们配置一个InternalResourceViewResolver，是针对JSP类型视图的。
• RequestToViewNameTranslator：RequestToViewNameTranslator组件的作用是从请求中获取ViewName。因为ViewResolver根据ViewName查找View，但有的Handler处理完成之后，没有设置View，也没有设置ViewName，便要通过这个组件从请求中查找ViewName。
• LocaleResolver：LocaleResolver组件的resolveViewName方法需要两个参数，一个是视图名，一个是Locale。LocaleResolver用于从请求中解析出Locale，比如中国Locale是zh-CN，用来表示一个区域。这个组件也是i18n的基础。
• ThemeResolver：ThemeResolver组件是用来解析主题的。主题是样式、图片及它们所形成的显示效果的集合。SpringMVC中一套主题对应一个properties文件，里面存放着与当前主题相关的所有资源，如图片、CSS样式等。创建主题非常简单，只需准备好资源，然后新建一个“主题名.properties”并将资源设置进去，放在classpath下，之后便可以在页面中使用了。SpringMVC中与主题相关的类有ThemeResolver、ThemeSource和Theme。ThemeResolver负责从请求中解析出主题名，ThemeSource根据主题名找到具体的主题，其抽象也就是Theme，可以通过Theme来获取主题和具体的资源。
• MultipartResolver：MultipartResolver用于上传请求，通过将普通的请求包装成MultipartHttpServletRequest来实现。MultipartHttpServletRequest可以通过getFile()方法直接获得文件。如果上传多个文件，好可以调用getFIleMap()方法得到Map<FileName, File>这样的结构，MultipartResolver的作用就是封装普通的请求，使其拥有文件上传的功能。
• FlashMapManager：FlashMap用于重定向时的参数传递。主要就是避免在url上面传参导致信息泄露，我们可以使用FalshMap来传递重定向参数。

搭建SpringMVC

本节，我们来搭建一个简单的SpringMVC。使其可以实现简单的接受请求返回响应即可。首先，我们创建一个Maven工程，如下图所示：

创建好之后，加入如下的依赖坐标：

<?xml version="1.0" encoding="UTF-8"?>

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rubinchu</groupId>
    <artifactId>spring-mvc-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring-mvc-demo Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--引入spring webmvc的依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>spring-mvc-demo</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

接下来，配置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>
  <display-name>Archetype Created Web Application</display-name>
    <!--springmvc提供的针对post请求的编码过滤器-->
    <filter>
        <filter-name>encoding</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>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <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:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
          方式一：带后缀，比如*.action  *.do *.aaa
                 该种方式比较精确、方便，在以前和现在企业中都有很大的使用比
          方式二：/ 不会拦截 .jsp，但是会拦截.html等静态资源（静态资源：除了servlet和jsp之外的js、css、png等）
                为什么配置为/ 会拦截静态资源？？？
                    因为tomcat容器中有一个web.xml（父），你的项目中也有一个web.xml（子），是一个继承关系
                          父web.xml中有一个DefaultServlet,  url-pattern 是一个 /
                          此时我们自己的web.xml中也配置了一个 / ,覆写了父web.xml的配置
                为什么不拦截.jsp呢？
                    因为父web.xml中有一个JspServlet，这个servlet拦截.jsp文件，而我们并没有覆写这个配置，
                    所以springmvc此时不拦截jsp，jsp的处理交给了tomcat
                如何解决/拦截静态资源这件事？
          方式三：/* 拦截所有，包括.jsp
        -->
        <!--拦截匹配规则的url请求，进入springmvc框架处理-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

接下来，我们创建我们的源码文件夹和资源文件夹，一般的结构如下所示：

我们的spring的配置文件内容如下：

<?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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd
">
    <!--开启controller扫描-->
    <context:component-scan base-package="com.rubin.controller"/>
    <!--配置springmvc的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--
        自动注册最合适的处理器映射器，处理器适配器(调用handler方法)
    -->
    <mvc:annotation-driven/>

    <!--静态资源配置，方案一-->
    <!--
        原理：添加该标签配置之后，会在SpringMVC上下文中定义一个DefaultServletHttpRequestHandler对象
             这个对象如同一个检查人员，对进入DispatcherServlet的url请求进行过滤筛查，如果发现是一个静态资源请求
             那么会把请求转由web应用服务器（tomcat）默认的DefaultServlet来处理，如果不是静态资源请求，那么继续由
             SpringMVC框架处理
    -->
    <!--<mvc:default-servlet-handler/>-->

    <!--静态资源配置，方案二，SpringMVC框架自己处理静态资源
        mapping:约定的静态资源的url规则
        location：指定的静态资源的存放位置
    -->
    <mvc:resources location="classpath:/"  mapping="/resources/**"/>
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>
</beans>

我们编写一个Controller：

@Controller
@RequestMapping("test")
public class TestController {

    @RequestMapping("/")
    public String index() {
        return "index";
    }

    @RequestMapping("/hello")
    @ResponseBody
    public String hello(String name) {
        return "hello " + name + "!";
    }

}

之后再将项目发布到Tomcat容器上面，访问自己编写的访问路径，查看响应结果是否成功即可。在此不再赘述。至此，我们的SpringMVC就搭建完成了。

SpringMVC请求参数绑定

说白了，请求参数的绑定就是SpringMVC框架如何接收参数。我们原生的Servlet接收一个整型的参数，我们要编写如下代码：

String ageStr = request.getParameter("age");
Integer age = Integer.parseInt(ageStr);

我们的SpringMVC对原生的Servlet做了进一步的封装，使得我们接收参数变得很简单。下面，我们分类进行讲解说明。

绑定原生Servlet API作为参数

也就是说，我们想要使用原生的Servlet API作为参数（比如HttpServletRequest、HttpSession等等），我们直接在Handler方法中形参声明即可：

/**
  * SpringMVC 对原生servlet api的支持 url：/demo/handle02?id=1
  *
  * 如果要在SpringMVC中使用servlet原生对象，比如HttpServletRequest、HttpServletResponse、HttpSession
  * 等，直接在Handler方法形参中声明使用即可
  */
@RequestMapping("/handle02")
public ModelAndView handle02(HttpServletRequest request, HttpServletResponse response,HttpSession session) {
    String id = request.getParameter("id");
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定简单类型参数

简单类型的参数指的是八种基本类型以及其包装类还有字符串。我们在接收参数的时候，大部分时候，null是有业务意义的，但是我们的基本类型是不支持null值的。所以，我们在做参数绑定的时候尽量使用包装类型。对于布尔类型的参数，请求参数要传true和false，或者是1和0。注意：绑定简单类型的参数值，只需要直接声明形参即可（形参的参数名和传递的参数名要保持一致，建议使用包装类型。当形参参数名称和传递的参数名称不一致的时候，可以使用@RequestParam注解进行手动映射）：

/**
  * SpringMVC 接收简单数据类型参数 url：/demo/handle03?id=1
  *
  * 注意：接收简单数据类型参数，直接在handler⽅法的形参中声明即可，框架会取出参数值
然后绑定到对应参
  * 数上
  * 要求：传递的参数名和声明的形参名称保持⼀致
  */
@RequestMapping("/handle03")
public ModelAndView handle03(@RequestParam("ids") Integer id, Boolean
 flag) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定Pojo类型的参数

/**
  * SpringMVC接收pojo类型参数 url：/demo/handle04?id=1&username=zhangsan
  *
  * 接收Pojo类型参数，直接形参声明即可，类型就是Pojo的类型，形参名无所谓
  * 但是要求传递的参数名必须和Pojo的属性名保持⼀致
  */
@RequestMapping("/handle04")
public ModelAndView handle04(User user) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定Pojo包装对象参数

也就是针对我们接受的参数中包含另外一个对象的情况，我们的参数对象封装如下：

public class QueryVo {
    private String mail;
    private String phone;
    // 嵌套了另外的Pojo对象
    private User user;
    public String getMail() {
        return mail;
    }
    public void setMail(String mail) {
        this.mail = mail;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
}

Handler定义如下：

/**
  * SpringMVC接收pojo包装类型参数 url：/demo/handle05?
user.id=1&user.username=zhangsan
  * 不管包装Pojo与否，它首先是⼀个Pojo，那么就可以按照上述Pojo的要求来
  * 1、绑定时候直接形参声明即可
  * 2、传参参数名和pojo属性保持⼀致，如果不能够定位数据项，那么通过属性名 + "." 的
方式进⼀步锁定数据
  *
  */
@RequestMapping("/handle05")
public ModelAndView handle05(QueryVo queryVo) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定日期类型的参数

我们的前端页面定义如下：

<fieldset>
    <p>测试用例：SpringMVC接收日期类型参数</p>
    <a href="/demo/handle06?birthday=2019-10-08">点击测试</a>
</fieldset>

我们来定义我们的Handler方法：

/**
  * 绑定日期类型参数
  * 定义⼀个SpringMVC的类型转换器接口，扩展实现接口，注册你的实现
  * @param birthday
  * @return
  */
@RequestMapping("/handle06")
public ModelAndView handle06(Date birthday) {
    Date date = new Date();
    ModelAndView modelAndView = new
 ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

定义我们的自定义日期转换器：

public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        // 完成字符串向日期的转换
        SimpleDateFormat simpleDateFormat = new
 SimpleDateFormat("yyyy-MM-dd");
        try {
            Date parse = simpleDateFormat.parse(source);
            return parse;
        } catch (ParseException e) {
             e.printStackTrace();
        }
        return null;
    }
}

注册我们的自定义类型转换器：

<!--自动注册最合适的处理器映射器，处理器适配器(调用handler方法)-->
<mvc:annotation-driven conversion-service="conversionServiceBean"/>
<!--注册自定义类型转换器-->
<bean id="conversionServiceBean"
class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <property name="converters">
        <set>
            <bean class="com.rubin.converter.DateConverter"></bean>
        </set>
    </property>
</bean>

SpringMVC对于Restful风格请求的支持

什么是Restful

Restful是一种web软件架构风格，它不是标准也不是协议，它倡导的是一个资源定位以及资源操作的风格。这个网上的介绍有很多，就不在此详细赘述这些概念性的东西。

SpringMVC编写Restful风格的接口

我们先来定义前端的页面：

<div>
    <h2>SpringMVC对Restful风格url的支持</h2>
    <fieldset>
        <p>测试用例：SpringMVC对Restful风格url的支持</p>
        <a href="/demo/handle/15">rest_get测试</a>
        <form method="post" action="/demo/handle">
            <input type="text" name="username"/>
            <input type="submit" value="提交rest_post请求"/>
        </form>
        <form method="post" action="/demo/handle/15/lisi">
            <input type="hidden" name="_method" value="put"/>
            <input type="submit" value="提交rest_put请求"/>
        </form>
        <form method="post" action="/demo/handle/15">
            <input type="hidden" name="_method" value="delete"/>
            <input type="submit" value="提交rest_delete请求"/>
        </form>
    </fieldset>
</div>

我们在来定义我们的Handler方法：

/*
 * restful get /demo/handle/15
 */
@RequestMapping(value = "/handle/{id}", method =
 {RequestMethod.GET})
public ModelAndView handleGet(@PathVariable("id") Integer id) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}
/*
 * restful post /demo/handle
 */
@RequestMapping(value = "/handle", method = {RequestMethod.POST})
public ModelAndView handlePost(String username) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}
/*
 * restful put /demo/handle/15/lisi
 */
@RequestMapping(value = "/handle/{id}/{name}",method =
 {RequestMethod.PUT})
public ModelAndView handlePut(@PathVariable("id") Integer
 id,@PathVariable("name") String username) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}
/*
 * restful delete /demo/handle/15
 */
@RequestMapping(value = "/handle/{id}",method =
 {RequestMethod.DELETE})
public ModelAndView handleDelete(@PathVariable("id") Integer id) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

除此之外，我么还需要定义一个过滤器来将我们的put和delete请求转化成post请求。过滤器定义如下：

<!--配置springmvc请求方式转换过滤器，会检查请求参数中是否有_method参数，如果有就
按照指定的请求方式进行转换-->
<filter>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <filter-
class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-
class>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>hiddenHttpMethodFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

SpringMVC与Json的交互

SpringMVC与Json的交互涉及到两个方向：

• 前端到后端：前端发送Json字符串，后端直接接收为Pojo参数，使用@RequestBody注解。
• 后端到前端：后端直接返回Pojo对象，前段直接接收为Json对象或字符串，使用@ResponseBody注解。

SpringMVC想要与Json交互，需要引入如下的jar包：

<!--json数据交互所需jar，start-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.0</version>
</dependency>
<!--json数据交互所需jar，end-->

前端代码示例如下：

<div>
    <h2>Ajax json交互</h2>
    <fieldset>
        <input type="button" id="ajaxBtn" value="ajax提交"/>
    </fieldset>
</div>

$(function () {
    $("#ajaxBtn").bind("click",function () {
        // 发送ajax请求
        $.ajax({
            url: '/demo/handle07',
            type: 'POST',
            data: '{"id":"1","name":"李四"}',
            contentType: 'application/json;charset=utf-8',
            dataType: 'json',
            success: function (data) {
                alert(data.name)
            }
        })
    })
})

后端Handler方法定义如下：

@RequestMapping("/handle07")
// 添加@ResponseBody之后，不再走视图解析器那个流程，而是等同于response直接输出
数据
public @ResponseBody User handle07(@RequestBody User user) {
    // 业务逻辑处理，修改name为张三丰
    user.setName("张三丰");
    return user;
}