轰轰烈烈的搭建Spring + Spring MVC + Mybatis

创建项目

打开IDEA -> Create New Project
勾选Create from archetype

选择使用的maven的本地位置,这个根据实际情况选择就好
图片描述

这一步会填写项目名称,根据实际来就好了。
图片描述

一个空的项目就已经完成了。

搭建项目基础目录

创建java文件夹
图片描述

设置java文件夹为Sources Root，只有在Rources RootxiaIRDEA才提供创建Java文件的选项
图片描述

创建Package
图片描述

配置Tomcat Service

图片描述

选择Deployment
图片描述

选择带exploded的
图片描述

然后OK，添加刚才的tomcat到配置里面
图片描述

图片描述

运行tomcat
图片描述

运行成功
图片描述

以上完成基础的搭建，下面会引入框架

配置Spring

pom.xml 添加Spring

<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">
         
     ...
     
    <properties>
        <spring.version>5.0.4.RELEASE</spring.version>
    </properties>
    
    <dependencies>
    
        ...
        
        <!-- 1)Spring核心 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 2)Spring DAO层 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 3)Spring web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency><!-- 4)Spring test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        ...
        
    </dependencies>

    ...

</project>

创建resources目录下的配置文件
图片描述

spring-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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:p="http://www.springframework.org/schema/p"
       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 ">

    <!-- 配置SpringMVC -->
    <!-- 1.开启SpringMVC注解模式 -->
    <!-- 简化配置：
        (1)自动注册DefaultAnootationHandlerMapping,AnotationMethodHandlerAdapter
        (2)提供一些列：数据绑定，数字和日期的format @NumberFormat, @DateTimeFormat, xml,json默认读写支持
    -->
    <mvc:annotation-driven />

    <!-- 2.静态资源默认servlet配置
        (1)加入对静态资源的处理：js,gif,png
        (2)允许使用"/"做整体映射
     -->
    <mvc:default-servlet-handler/>

    <!-- 3. 对模型视图名称的解析,即在模型视图名称添加前后缀 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          p:viewClass="org.springframework.web.servlet.view.JstlView"
          p:prefix="/WEB-INF/jsp/"
          p:suffix=".jsp"/>

    <!-- 4.扫描web相关的controller -->
    <context:component-scan base-package="com.wymm.controller" />
</beans>

如上配置，加入了一个InternalResourceViewResolver（视图解析器），这个视图解析器根据Controller的方法返回字符串或者ModelAndView，找到对应的视图（页面），可以再视图中加入EL表达式等代码绑定数据。
InternalResourceViewResolver中包含两个参数prefix和suffix，他们分别是视图解析器的前缀和后缀，比如，上面配置了prefix的值为‘/WEB-INF/jsp/’，那么当Controller返回字符串‘index’时，视图解析器回找到‘/WEB-INF/jsp/index’；如果再加上suffix属性，值为‘.jsp’，那么视图解析器就会去找‘/WEB-INF/jsp/index.jsp’。

web.xml 配置Spring MVC和编码格式

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1" metadata-complete="true">
    <display-name>Archetype Created Web Application</display-name>

    <!--
        使用Spring提供过滤器CharacterEncodingFilter处理字符编码。

        1).encoding用来设置编码格式
        2).forceEncoding用来设置是否理会 request.getCharacterEncoding()方法，设置为true则强制覆盖之前的编码格式
    -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 配置Spring MVC -->
    <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:conf/spring-*.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

如上面代码所示，这样配置的目的是把请求交给Spring框架的DispatcherServlet处理，由它找到请求路径所对应的Controller，把请求交由这个Controller处理。

pom.xml 添加servlet web

<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">
         
    ...
         
    <dependencies>
    
        ...
        
        <!-- Servlet web -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        
        ...
        
    </dependencies>
    
    ...
    
</project>

创建UserController.java和userIndex.jsp文件

创建UserController.java

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/index")
    public ModelAndView index(ModelAndView modelAndView){
        modelAndView.setViewName("/user/userIndex");
        return modelAndView;
    }
}

创建userIndex.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
    <title>User Index</title>
</head>
<body>
<h2>User Index</h2>
</body>
</html>

此时，运行系统，可通过Spring注解进入jsp页面，如：/user/index

Spring & Mybatis

创建mapper层

pom.xml 引入 mybatis 和 jdbc

<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">
         
     ...
     
     <dependencies>
     
        ...
     
        <!-- 数据库 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
            <scope>runtime</scope>
        </dependency>
        <!-- DAO: MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
    
        ...
        
    <dependencies>
    
    ...

</project>

创建数据库mybatis

create database mybatis;

创建表user

CREATE TABLE user(
    id INT PRIMARY KEY auto_increment,
    username VARCHAR ( 20 ),
    password VARCHAR ( 20 ),
    sex VARCHAR ( 10 ),
    address VARCHAR ( 20 ) 
);

在 resources 目录下创建 jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3307/mybatis?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root

在 resources 目录下创建 conf/spring-mybatis.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"
       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/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--引入数据库配置文件jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"
          p:driverClassName="${jdbc.driver}"
          p:url="${jdbc.url}"
          p:username="${jdbc.username}"
          p:password="${jdbc.password}"/>

    <!--
        配置SqlSessionFactory对象

        1).注入数据库连接池
        2).配置MyBaties全局配置文件:mybatis-config.xml
        3).扫描model包 使用别名
        4).扫描sql配置文件:mapper需要的xml文件
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
          p:dataSource-ref="dataSource"
          p:configLocation="classpath:conf/mybatis-config.xml"
          p:typeAliasesPackage="com.wymm.model"
          p:mapperLocations="classpath:mapper/*.xml"/>

    <!--
        spring与mybatis整合配置，动态实现 mapper 接口，注入到 spring 容器中

        1).注入sqlSessionFactory
        2).给出需要扫描 mapper 接口包
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
          p:sqlSessionFactoryBeanName="sqlSessionFactory"
          p:basePackage="com.wymm.mapper"/>

    <!-- 对数据源进行事务管理 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
          p:dataSource-ref="dataSource"/>

</beans>

在 resources 目录下创建 conf/mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 配置全局属性 -->
    <settings>
        <!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->
        <setting name="useGeneratedKeys" value="true" />

        <!-- 使用列别名替换列名 默认:true -->
        <setting name="useColumnLabel" value="true" />

        <!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
</configuration>

创建UserMapper

public interface UserMapper {

    /**
     * 查询一个用户
     *
     * @param  id 用户id
     * @return User
     */
    public User getUser(Integer id) throws Exception;

    /*
     * 新增用戶
     * @param user
     * @return
     * @throws Exception
     */
    public int insertUser(User user) throws Exception;

    /*
     * 修改用戶
     * @param user
     * @param id
     * @return
     * @throws Exception
     */
    public int updateUser(User user) throws Exception;

    /*
     * 刪除用戶
     * @param id
     * @return
     * @throws Exception
     */
    public int deleteUser(Integer id) throws Exception;

    /*
     * 查询所有的用户信息
     * @return
     * @throws Exception
     */
    public List<User> getUsers() throws Exception;
}

创建UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wymm.mapper.UserMapper">
    <!-- 自定义返回结果集 -->
    <resultMap id="userMap" type="User">
        <id property="id" column="id" javaType="int"></id>
        <result property="username" column="username" javaType="String"></result>
        <result property="password" column="password" javaType="String"></result>
        <result property="sex" column="sex" javaType="String"></result>
        <result property="address" column="address" javaType="String"></result>
    </resultMap>

    <!-- 定义 SQL 语句，其中 id 需要和接口中的方法名一致 -->
    <!-- useGeneratedKeys：实现自动生成主键 -->
    <!-- keyProperty： 唯一标记一个属性 -->
    <!-- parameterType 指明查询时使用的参数类型，resultType 指明查询返回的结果集类型 -->
    <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
        insert into user (username,password,sex,address) values
        (#{username},#{password},#{sex},#{address})
    </insert>

    <update id="updateUser"  parameterType="User">
        update user set
        address=#{address} where
        id=#{id}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from user where
        id=#{id}
    </delete>

    <!-- 如未为 Java Bean 起类别名，resultType="com.shiyanlou.mybatis.model.User" -->

    <!-- 使用resultType时，一定要保证，你属性名与字段名相同；如果不相同，就使用resultMap -->
    <select id="getUser" parameterType="int" resultType="User">
        select * from user where id=#{id}
    </select>

    <select id="getUsers" resultMap="userMap">
        select * from user
    </select>

</mapper>

创建Service层

User

public class User {

    private Integer id;
    private String username;
    private String password;
    private String sex;
    private String address;

    // getter and setter
    
}

UserService.java

public interface UserService {

    /**
     * 查询一个用户
     *
     * @param  id 用户id
     * @return User
     */
    public User getUser(Integer id) throws Exception;

    /*
     * 新增用戶
     * @param user
     * @return
     * @throws Exception
     */
    public int insertUser(User user) throws Exception;

    /*
     * 修改用戶
     * @param user
     * @param id
     * @return
     * @throws Exception
     */
    public int updateUser(User user) throws Exception;

    /*
     * 刪除用戶
     * @param id
     * @return
     * @throws Exception
     */
    public int deleteUser(Integer id) throws Exception;

    /*
     * 查询所有的用户信息
     * @return
     * @throws Exception
     */
    public List<User> getUsers() throws Exception;
}

UserServiceImpl.java

@Service
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;

    /**
     * 查询一个用户
     *
     * @param  id 用户id
     * @return User
     */
    public User getUser(Integer id)  throws Exception {
        return userMapper.getUser(id);
    }

    /*
     * 新增用戶
     * @param user
     * @return
     * @throws Exception
     */
    public int insertUser(User user) throws Exception {
        return userMapper.insertUser(user);
    }

    /*
     * 修改用戶
     * @param user
     * @param id
     * @return
     * @throws Exception
     */
    public int updateUser(User user) throws Exception {
        return userMapper.updateUser(user);
    }

    /*
     * 刪除用戶
     * @param id
     * @return
     * @throws Exception
     */
    public int deleteUser(Integer id) throws Exception {
        return userMapper.deleteUser(id);
    }

    /*
     * 查询所有的用户信息
     * @return
     * @throws Exception
     */
    public List<User> getUsers() throws Exception {
        return userMapper.getUsers();
    }
}

spring-service.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 http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd ">

    <!-- 扫描service包下所有使用注解的类型 -->
    <context:component-scan base-package="com.wymm.service"/>
</beans>

修改web.xml

<param-value>classpath:spring/spring-mvc.xml</param-value>
# 改成 -->
<param-value>classpath:spring/spring-*.xml</param-value>

Controller层

创建相应文件

编写返回的Bean，统一返回格式，ResultBean


public class ResultBean<T> implements Serializable {

    /**
     * 错误代码
     */
    private static final int SUCCESS = 0; // 成功
    private static final int CHECK_FAIL = 1; // 失败
    private static final int UNKNOWN_EXCEPTION  = -99; // 抛出异常
    /**
     * 接口返回状态码，0表示成功，其他的看对应定义
     *
     * 推荐：
     * 0  ： 表示成功
     * >0 :  表示已知的异常（需要在调用的地方单独处理）
     * <0 :  表示未知的异常（不需要单独处理，调用方统一处理）
     */
    private int code = SUCCESS; // 返回状态

    /**
     * 返回信息（出错的时候使用）
     */
    private String msg = "success";

    /**
     * 返回的数据
     */
    private T data;

    /**
     * 请求正确（新增、修改、删除信息），返回调用
     */
    public ResultBean() {
        super();
    }

    /**
     * 请求数据正确，返回调用
     * @param data 返回数据
     */
    public ResultBean(T data) {
        super();
        this.data = data;
    }

    /**
     * 请求出错，返回调用
     * @param msg 错误提醒语句
     */
    public ResultBean(String msg) {
        this.code = CHECK_FAIL;
        this.msg = msg;
    }

    /**
     * 请求异常，返回调用
     * @param e 异常
     */
    public ResultBean(Throwable e) {
        super();
        this.msg = e.toString();
        this.code = UNKNOWN_EXCEPTION;
    }
    
    /**
     * getter and setter
     * 
     * 因为属性是private的，所以属性必须有getter才能在被获取
     */

}

接口采用RESTful API

使用四种HTTP方法POST，GET，PUT，DELETE可以提供CRUD功能（创建，获取，更新，删除）。

获取：使用GET方法获取资源。GET请求从不改变资源的状态，无副作用。GET方法是幂等的。GET方法具有只读的含义。因此，你可以完美的使用缓存
创建：使用POST创建新的资源。对同一URL进行多次请求会生成多份资源，所以POST不是幂等的
更新：使用PUT创建或更新现有资源。对同一URL多次PUT都是相同的，所以PUT方法是幂等的
删除：使用DELETE删除现有资源，有副作用，但DELETE方法是幂等的

幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同

---	POST - 创建	GET - 获取	PUT - 更新	DELETE - 删除
/users	创建一个用户	获取用户列表	批量更新用户信息	批量删除用户信息
/users/{id}	---	获取单个用户信息	更新单个用户信息	删除单个用户信息

完成UserController的编码

/**
 * 用户信息管理
 */
@Controller
public class UserController {

    @Autowired
    private UserService userService;

    /*
     * 获取用户列表
     *
     * @return
     * @throws Exception
     */
    @ResponseBody
    @GetMapping("/users")
    public ResultBean<List<User>> getUsers() throws Exception {

        List<User> users = userService.getUsers();

        return new ResultBean<List<User>>(users);
    }

    /*
     * 新增用户信息
     *
     * @return
     * @throws Exception
     */
    @ResponseBody
    @PostMapping("/users")
    public ResultBean insertUser(@RequestBody User user) throws Exception {

        int result = userService.insertUser(user);

        if (result > 0) {
            return new ResultBean();
        } else {
            return new ResultBean("新增失败");
        }
    }

    /*
     * 获取用户信息
     *
     * @param id 用户id
     * @return
     * @throws Exception
     */
    @ResponseBody
    @GetMapping("/users/{id}")
    public ResultBean<User> getUser(@PathVariable Integer id) throws Exception {

        User user = userService.getUser(id);

        return new ResultBean<User>(user);
    }

    /*
     * 修改用户信息
     *
     * @return
     * @throws Exception
     */
    @ResponseBody
    @PutMapping("/users/{id}")
    public ResultBean updateUser(@PathVariable Integer id, @RequestBody User user) throws Exception {

        user.setId(id);
        int result = userService.updateUser(user);

        if (result > 0) {
            return new ResultBean();
        } else {
            return new ResultBean("修改失败");
        }

    }

    /*
     * 删除用户信息
     *
     * @param id 用户id
     * @return
     * @throws Exception
     */
    @ResponseBody
    @DeleteMapping("/users/{id}")
    public ResultBean deleteUser(@PathVariable Integer id) throws Exception {

        int result = userService.deleteUser(id);

        if (result > 0) {
            return new ResultBean();
        } else {
            return new ResultBean("删除失败");
        }
    }
}

使用@RequestBody注解常用来处理content-type不是默认的application/x-www-form-urlcoded编码的内容，比如说：application/json或者是application/xml等，本例子目标是处理application/json
使用@PathVariable Integer id映射@RequestMapping("/users/{id}") / @GetMapping("/users/{id}") / @DeleteMapping("/users/{id}")等请求中的{id}

引入fastjson

fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。

<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">
         
    ...
         
    <dependencies>
    
        ...
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        
        ...
        
    </dependencies>
    
    ...
    
</project>

/conf/spring-mvc.xml中添加FastJson，FastJson采用默认配置已经足够面对大多数场景

<?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:p="http://www.springframework.org/schema/p"
       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 ">

    ...

    <!-- FastJson注入 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

    ...

</beans>

参考链接

手把手教你整合最优雅SSM框架
 我的编码习惯-接口定义
 RESTful API 设计最佳实践