利用 Spring Boot 设计风格良好的Restful API及错误响应

96
宅楠军
2018.07.05 22:46* 字数 3402

一、前言

网上经常会看到一些文章,旨在介绍如何使用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]:用户删除数据成功。
  1. 如果状态码是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

返回结果如我们所料,但是HTTP的响应码却还是200,应该是404。所以,紧靠这些无法满足我们的需求。当然,我们可以自定义拦截器实现响应码修改。这里,有一个更好的解决方案——Spring 全局异常处理机制。我们可以通过使用@ControllerAdvice注解定义全局统一的异常处理类来完成需求。

也即是说,在处理错误时,我们不再直接返回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 马上拦截并进行处理,最后返回自定义的错误对象。当然,若接口一切正常,还是按正常逻辑返回模型对象。

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

五、后语

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

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

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

欢迎关注本人微信公众号:

image
日记本
Gupao