一、前言

网上经常会看到一些文章，旨在介绍如何使用Spring MVC或Spring Boot实现Restful接口，譬如：

 @RequestMapping(value = "/addUser", method = RequestMethod.POST)
    public boolean addUser( User user) {
        System.out.println("开始新增...");
        return userService.addUser(user);
    }
    
    @RequestMapping(value = "/updateUser", method = RequestMethod.PUT)
    public boolean updateUser( User user) {
        System.out.println("开始更新...");
        return userService.updateUser(user);
    }
    
    @RequestMapping(value = "/deleteUser", method = RequestMethod.DELETE)
    public boolean delete(@RequestParam(value = "userName", required = true) int userId) {
        System.out.println("开始删除...");
        return userService.deleteUser(userId);
    }
    
    @RequestMapping(value = "/userId", method = RequestMethod.GET)
    public User findByUserId(@RequestParam(value = "userId", required = true) int userId) {
        System.out.println("开始查询...");
        return userService.findUserById(userId);
    }

对于如上实现方式，本人着实不敢恭维。试问，这算哪门子的Restful？自认为其与Restful无丝毫关系，有误导众人之嫌。

对于RESTful 的相关概念，以及其API的设计方法，本人极力推荐阮一峰大神的文章《RESTful API 设计指南》，仅此一篇足够已。在此基础上，本人将小试牛刀，介绍如何在Spring Boot项目中设计风格良好的Restful API，以及如何实现Restful的错误响应。

文笔拙劣，并且水平有限，望各位看官不吝赐教，相互交流~

二、项目介绍

本项目IDE使用 intellij idea 2018, 构建工具使用Maven，JDK使用1.8。方便起见，我们可以使用maven的原型插件maven-archetype-quickstart快速建立一个Java 工程，在此基础上再进行功能开发。

2.1 目录结构

image.png

如上目录结构，了解Spring Boot或Spring MVC开发的朋友应该再熟悉不过了。这是一个较简单用户（User）服务，目前只实现了对用户模型基本的增删改查功能，尚未考虑多种异常情况。

2.2 项目依赖

在pom.xml中引入如下依赖：

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>1.5.14.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>1.5.14.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
    </dependencies>

由上可知，我们分别引入了如下依赖：

• spring-boot-starter-web
  众所周知，这是使用spring boot做web开发的必备依赖
• spring-boot-starter-data-jpa
  本项目使用JPA作为ORM框架
• springfox-swagger2与springfox-swagger-ui
  swagger是个好东西，可以用来生成RESTFUL接口的在线文档，而且更牛逼的是可以直接在文档中进行接口测试，代替Postman。在Spring Boot工程中，可以引入这两个依赖实现swagger的众多功能。
• mysql-connector-java
  不必多言，使用mysql必备

2.3 Spring Boot 配置文件

在resources目录中定义配置文件application.properties:

spring.jpa.database=MySQL
spring.datasource.url=jdbc:mysql://*.*.*.*:3306/test
spring.datasource.username=root
spring.datasource.password=abc

server.port=8801

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jackson.serialization.indent_output=true

logging.level.root=info

注意，除此之外，在pom.xml的build节点中，还需指定resources的路径：

        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>

2.4 模型定义

模型 User 相当简单，只有id、userName、age三个属性。其中，id我们不使用自增主键，直接利用JPA提供的UUID主键生成策略，如下所示：

//User.java
package com.mystudy.spring.domain;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.validation.constraints.NotNull;

@GenericGenerator(name = "jpa-uuid", strategy = "uuid")
@Entity
public class User
{
    @Id
    @NotNull
    @GeneratedValue(generator = "jpa-uuid")
    private String id;

    @NotNull
    private String userName;

    private int age;

    public String getId()
    {
        return id;
    }

    public void setId(String id)
    {
        this.id = id;
    }

    public String getUserName()
    {
        return userName;
    }

    public void setUserName(String userName)
    {
        this.userName = userName;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }
}

2.5 Repository 定义

Spring Data 为我们提供了很多Repository 接口，我们只需要简单的继承就可以快速实现领域对象（也就是前面提到的模型）的各种Dao层操作。若需要自定义操作，只需要按命名规范添加接口声明即可，具体参见官方文档。

这里，我们定义接口UserRepository，继承JpaRepository<User, String>接口：

package com.mystudy.spring.repository;

import com.mystudy.spring.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, String>
{
}

2.6 启动类

这再简单不过了：

package com.mystudy.spring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class UserApplication
{
    public static void main(String[] args)
    {
        SpringApplication.run(UserApplication.class, args);
    }
}

三、Restful 接口设计

请注意，本节是核心内容。

3.1 Controller 设计

在Spring MVC 中，Restful API的定义对应为Controller层。根据Restful的接口定义规范：

GET（SELECT）：从服务器取出资源（一项或多项）。
POST（CREATE）：在服务器新建一个资源。
PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）。
PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。
DELETE（DELETE）：从服务器删除资源。

我们设计接口如下所示：

//UserController.java
package com.mystudy.spring.api;

import com.mystudy.spring.domain.User;
import com.mystudy.spring.service.UserService;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/user")
public class UserController
{
    @Autowired
    private UserService userService;

    @ApiOperation(value="获取用户列表", notes="获取用户列表")
    @GetMapping(value = "/users")
    @ResponseStatus(HttpStatus.OK)
    public List<User> getUserList()
    {
        return userService.getUserList();
    }

    @ApiOperation(value="添加用户", notes="添加用户")
    @PostMapping(value = "/users")
    @ResponseStatus(HttpStatus.CREATED)
    public Object addUser(@RequestBody User user){
        return userService.addUser(user);
    }

    @ApiOperation(value="获取用户信息", notes="根据id获取用户信息")
    @GetMapping(value = "/users/{id}")
    @ResponseStatus(HttpStatus.OK)
    public Object getUser(@PathVariable("id") String id) throws NotFoundException
    {
        return userService.getUser(id);
    }

    @ApiOperation(value="删除用户", notes="根据id删除用户")
    @DeleteMapping(value = "/users/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteUser(@PathVariable("id") String id)
    {
        userService.deleteUser(id);
    }

    @ApiOperation(value="更新用户", notes="更新用户")
    @PatchMapping(value = "/users/{id}")
    @ResponseStatus(HttpStatus.CREATED)
    public User updateUser(@PathVariable("id") String id, @RequestBody User user)
    {
        return userService.update(id, user);
    }


    @ApiOperation(value="测试")
    @GetMapping(value = "/test")
    @ResponseStatus(HttpStatus.OK)
    public String test()
    {
        return "test ok!";
    }
}

如上，各个接口只是简单的将JSON请求进行映射，并转发到对应的Service层，Service层负责具体的业务处理。

在这些接口上，我们使用了如下注解：

• @GetMapping
• @PostMapping
• @DeleteMapping
• @PutMapping

它们在Spring 4.3中引进，旨在简化常用的HTTP方法的映射，并可以更好地表达被注解方法的语义。如@GetMapping实际上是一个组合注解，可以直接代替@RequestMapping(method = RequestMethod.GET)，我个人更推荐这种写法。

并且，在每个接口定义上，可以看到注解@ApiOperation，这就是我们前面的提到的swagger的应用。如果要为某个接口生成在线文档，只要在映射上添加该注解即可。似乎是侵入了代码，但是这点代价是值得的。在该注解中，value的值为接口说明，notes可以作为接口的简单描述。对应swagger的使用，文章后部分将会介绍。

同时，我们在每个接口上显示得使用了注解@ResponseStatus，用来标识接口正常返回时的HTTP状态码。另外，我们还需要注意每个接口的返回结果，除了删除用户，其他每个接口都有返回值。这是因为Restful 规范中提到：

GET /collection：返回资源对象的列表（数组）
GET /collection/resource：返回单个资源对象
POST /collection：返回新生成的资源对象
PUT /collection/resource：返回完整的资源对象
PATCH /collection/resource：返回完整的资源对象
DELETE /collection/resource：返回一个空文档

3.2 Service 设计

Service层负责具体的业务逻辑，其封装了Dao层的操作，如下：

//UserService.java
package com.mystudy.spring.service;

import com.mystudy.spring.domain.User;
import com.mystudy.spring.repository.UserRepository;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

import static com.mystudy.spring.util.Util.getNullPropertyNames;

@Service
public class UserService
{
    @Autowired
    private UserRepository userRepository;

    public User addUser(User user)
    {
        return userRepository.save(user);
    }

    public List<User> getUserList()
    {
        return userRepository.findAll();
    }

    public User getUser(String id)
    {
        return userRepository.findOne(id);
    }

    public void deleteUser(String id)
    {
        userRepository.delete(id);
    }

    public User update(String id, User user)
    {
        User currentInstance = userRepository.findOne(id);

        //支持部分更新
        String[] nullPropertyNames = getNullPropertyNames(user);
        BeanUtils.copyProperties(user, currentInstance, nullPropertyNames);

        return userRepository.save(currentInstance);
    }
}

可以看到，Service的大部分方法只是简单的调用了Repository的接口。这里，我们需要重点关注update方法。

根据Restful的思想，我们知道更新操作可以分为全部更新和部分更新。结合HTTP语义，可以表示为：

PUT /zoos/ID：更新某个指定动物园的信息（提供该动物园的全部信息）
PATCH /zoos/ID：更新某个指定动物园的信息（提供该动物园的部分信息）

但实际上，PATCH语义的应用并不广泛。所以，为了方便，我将两个接口合在一起，同时支持全部和部分更新，HTTP动词使用PUT，仅供参考，大家酌情而定。

在实现部分更新时，有个问题需要注意。举例说明，若我们只需要更新User的age字段，前端提供JSON形如：

{
    "id": "8a8194e5645f53a101645f6048470000",
    "age": 12
  }

其旨在更新age为12，但若请求直接映射到User：

@PutMapping(value = "/users/{id}")
    public User updateUser(@PathVariable("id") String id, @RequestBody User user)
    {
        return userService.update(id, user);
    }

则对象user的userName属性会自动映射为null，这样会导致数据库中对应的userName字段被置为空，这是无法接受的。

如何解决？很容易想到，通过id查询出已存在的User对象(如A)，然后将传入的User对象（如B)的非空属性全部拷贝给A即可。

但是，难不成我们还要以一个一个的判断每个属性是否为空？大可不必，我们可以引入Spring提供的BeanUtils.copyProperties方法，该方法可以将一个对象的属性值拷贝给另一个对象，并可以忽略指定的属性。因此，我们只需要获得所有的空值属性，然后传递给BeanUtils.copyProperties即可。

如何获取空值属性？参考stackoverflow中的方案，如下所示：

//Util.java
package com.mystudy.spring.util;

import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;

import java.beans.FeatureDescriptor;
import java.util.stream.Stream;

public class Util
{
    public static String[] getNullPropertyNames(Object source) {
        final BeanWrapper wrappedSource = new BeanWrapperImpl(source);
        return Stream.of(wrappedSource.getPropertyDescriptors())
                .map(FeatureDescriptor::getName)
                .filter(propertyName -> wrappedSource.getPropertyValue(propertyName) == null)
                .toArray(String[]::new);
    }
}

但是，该方法其实有个大bug，当请求中不填写age时，User对象中的age会被映射为0（这是必定的，因为基本类型默认值为0)，但只要我们将基本类型替换为引用类型（默认值为null）即可解决该问题，也就是修改age的类型为Integer。当然，如果你不想使用模型进行映射，也可以使用Map等方式。

综上，通过这种方法，我们实现了模型的全部更新和部分更新功能，前端只需要通过一个接口，传递模型的全部字段或部分字段即可。这样，就可以避免出现类似updateByName，updateByAge, updaeByXX等啰嗦、多余的更新接口。

3.3 Swagger

没错，酷炫的东西到了。除了前面提到的注解@ApiOperation，我们还需要实现一个配置类：

//Swagger2.java
package com.mystudy.spring.util;

import com.google.common.collect.Sets;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class Swagger2 {
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .protocols(Sets.newHashSet("http")) //协议，http或https
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.mystudy.spring.api")) //一定要写对，会在这个路径下扫描controller定义
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("REST接口定义")
                .version("1.0") 
                .description("用于测试RESTful API")
                .build();
    }
}

如上只使用了一些最基本的功能，还有很多个性化的配置大家可以自行发掘。

前面提到过，本项目的服务端口是8801，启动项目后，访问http://127.0.0.1:8801/swagger-ui.html，即可出现在线文档：

image.png

如上，每个接口都可以看到详细的参数，并可直接进行请求测试。如在添加用户接口中，我们先点击按钮“try out”，接着填写相关参数：

image.png

点击按钮“Exceute”即可执行，结果显示为成功：

image.png

综上，可以发现，结合Spring Boot时Swagger比Postman使用更加便捷。当然，这里只介绍了Swagger最基本的应用，更多特性请谷歌之。

四、Restful 错误响应

另外一个重点来了，也是一个难点。目前，我们只介绍了Restful 最简单的正常使用场景，没有介绍Restful 的错误响应的处理方式。在实际的前后端分离的开发中，服务端的多种错误情况都必须要反馈给前端进行处理。

4.1 错误响应风格

对于错误响应，结合阮一峰的文章，我个人倾向的风格是：

1. 正常的响应应该直接返回需要的数据，而无需嵌套或添加任何额外信息。此时HTTP的返回码可以为：

200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）。
201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。
202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）
204 NO CONTENT - [DELETE]：用户删除数据成功。

2. 如果状态码是4xx，就应该向用户返回出错信息。一般来说，返回的信息中将error作为键名，出错信息作为键值即可：

{
      error: "error message"
}

此时，HTTP的状态码就是相应的业务错误码，一般无需额外定义业务错误码。但很多时候，仅有的20多个HTTP状态码不足以表达服务端的所有异常，此时，我们就需要额外定义错误码，而HTTP状态码仅表示错误的大类型。例如，若查找的指定用户信息不存在，HTTP状态码依旧为404，响应可以返回：

{
  "code": 40401,
  "error": "user 11 not found!"
}

其中，code为自定义错误码40401，error为其对应的错误内容。40401的前缀404表示资源不存在，01可以表示具体表示user这种资源不存在。

当然，Restful 的错误响应风格并不局限于此，大家可以根据实际情况和使用习惯酌情考虑，我唯一建议的就是——合理利用HTTP错误码而不是完全弃之不顾。

4.2 Spring 统一异常处理

介绍完错误响应风格后，我们考虑如何在Spring Boot中实现之。很多人的的做法是将各种错误转化为错误响应对象进行返回。首先，我们定义一个表示错误响应的对象：

public class Result
{
    /**
     * 错误内容
     */
    private String error;

    /**
     * 自定义错误码
     */
    private int code;


    public Result(String error, int code)
    {
        this.error = error;
        this.code = code;
    }

    public String getError()
    {
        return error;
    }

    public void setError(String error)
    {
        this.error = error;
    }

    public int getCode()
    {
        return code;
    }

    public void setCode(int code)
    {
        this.code = code;
    }


    public enum ErrorCode{
        /**
         * 用户不存在
         */
        USER_NOT_FOUND(40401),

        /**
         * 用户已存在
         */
        USER_ALREADY_EXIST(40001),
        ;

        private int code;

        public int getCode()
        {
            return code;
        }

        ErrorCode(int code)
        {
            this.code = code;
        }
    }
}

可以看到，该对象中还定义了错误码的枚举类。接着，我们修改返回接口的返回类型为Object:

    @GetMapping(value = "/users/{id}")
    public Object getUser(@PathVariable("id") String id)
    {
        return userService.getUser(id);
    }

我们考虑被添加的用户已存在的错误情况，修改Service：

    public Object getUser(String id)
    {
        User currentInstance = userRepository.findOne(id);
        if (currentInstance == null)
        {
            return new Result("user " + id + "is exist!",
                    Result.ErrorCode.USER_ALREADY_EXIST.getCode());
        }
        return userRepository.findOne(id);
    }

好了，我们现在使用Swagger进行测试，查找一个不存在的用户abc：

image.png

也即是说，在处理错误时，我们不再直接返回Result对象，而采用异常机制。其实，我个人也觉得代码中到处返回Result对象真是一个bad smell。在Java中，错误得情况难道还有比异常更好的表现方式么？

好吧，废话太多了，开始实现。新建一个全局异常GlobalException ，其作为众多自定义异常的父类：

public class GlobalException extends Exception {

    private int code;

    public GlobalException(String message)
    {
        super(message);
    }

    public GlobalException(String message, int code)
    {
        super(message);
        this.code = code;
    }

    public void setCode(int code)
    {
        this.code = code;
    }

    public int getCode()
    {
        return code;
    }
}

新建一个自定义异常NotFoundException，该异常专门用来表示各种类型资源不存在的异常情况：

public class NotFoundException extends GlobalException
{
    public NotFoundException(String message, int code)
    {
        super(message, code);
    }
}

新建类RestExceptionHandler，使用注解@ControllerAdvice，如下：

@ControllerAdvice
public class RestExceptionHandler
{
    private static Logger logger = LoggerFactory.getLogger(RestExceptionHandler.class);

    @ExceptionHandler(value = NotFoundException.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public Result handleResourceNotFoundException(NotFoundException e)
    {
        logger.error(e.getMessage(), e);
        return new Result(e.getMessage(), e.getCode());
    }
}

如上，通过使用注解@ControllerAdvice，类RestExceptionHandler就可以实现全局异常的拦截处理功能。自定义的方法handleResourceNotFoundException旨在拦截NotFoundException异常，一旦拦截成功后，我们可以进行各种处理操作，并且返回自己想要的结果。

其中，注解@ExceptionHandler表示要拦截的异常；注解@ResponseStatus可以指定HTTP响应的状态码;当然，注解@ResponseBody也必不可少。

OK，让我们先修改之前的用户查找接口，并且抛出异常：

    public Object getUser(String id) throws NotFoundException
    {
        User currentInstance = userRepository.findOne(id);
        if (currentInstance == null)
        {
            throw new NotFoundException("user " + id + " is not exist!", Result.ErrorCode.USER_NOT_FOUND.getCode());
        }
        return userRepository.findOne(id);
    }

当然，Controller也要抛出异常：

    @GetMapping(value = "/users/{id}")
    public Object getUser(@PathVariable("id") String id) throws NotFoundException
    {
        return userService.getUser(id);
    }

OK，重新请求一个不存在的用户尝试一下：

image.png

如上，如我们所愿，HTTP响应码也返回了，同时查看服务控制台：

com.mystudy.spring.exception.NotFoundException: user abc is not exist!
    at com.mystudy.spring.service.UserService.getUser(UserService.java:36) ~[classes/:na]
    at com.mystudy.spring.api.UserController.getUser(UserController.java:36) ~[classes/:na]
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:na]
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
    at java.base/java.lang.reflect.Method.invoke(Method.java:564) ~[na:na]
    at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:205) ~[spring-web-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:133) ~[spring-web-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:97) ~[spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:827) ~[spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:738) ~[spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85) ~[spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:967) ~[spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:901) ~[spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:970) [spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:861) [spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:635) [tomcat-embed-core-8.5.31.jar:8.5.31]
    at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:846) [spring-webmvc-4.3.18.RELEASE.jar:4.3.18.RELEASE]
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:742) [tomcat-embed-core-8.5.31.jar:8.5.31]
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231) [tomcat-embed-core-8.5.31.jar:8.5.31]
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) [tomcat-embed-core-8.5.31.jar:8.5.31]
省略

没错，这才打开的正确方式！一旦接口抛出异常，Spring 马上拦截并进行处理，最后返回自定义的错误对象。当然，若接口一切正常，还是按正常逻辑返回模型对象。

同理，我们还可以新建多种其他异常，比如表示非法参数、权限不足等。需要注意的是，请不要为每种资源都新建异常，比如你不需要创建UserNotFoundException、BookNotFoundException等，否则会显得多么繁琐。

五、后语

至此，本文的目标已经达成，首先介绍了如何使用Spring Boot设计Restful API，然后介绍了常用的Restful 错误响应风格，最后利用Spring Boot的全局异常处理机制实现了Restful 的错误响应功能。

项目源码请戳：https://gitee.com/haoranjunzi/study-restful

本人水平有限，难免有错误或遗漏之处，望大家指正和谅解，欢迎评论留言。