Controller层的处理

一个完整的后端请求包括什么？

1. 接口地址（URL地址）。
2. 请求方式（GET、POST、DELETE、PUT）
3. 请求数据（request、head、body）
4. 响应数据（response）

一、Controller层参数接收

@RestController
@RequestMapping("/product/product-info")
public class ProductInfoController {

    @Autowired
    ProductInfoService productInfoService;

    @GetMapping("/findById")
    public ProductInfoQueryVo findById(Integer id) {
    	...
    }

    @PostMapping("/page")
    public IPage findPage(Page page, ProductInfoQueryVo vo) {
    	// 传入的参数为一个实体类。
        // 只要前端传来的JSON能通过属性映射到实体类的属性就可以。
        ...
    }
}

1. @RestController：@RestController = @Controller + ResponseBody。加上这个注解，springboot就会吧这个类当成controller进行处理，然后把所有返回的参数放到ResponseBody中.。
2. @RequestMapping：请求的前缀，也就是所有该Controller下的请求都需要加上/product/product-info的前缀。
3. @GetMapping(“/findById”)：标志这是一个get请求，并且需要通过/findById地址才可以访问到。
4. @PostMapping(“/page”)：表示是个post请求。
5. 参数：至于参数部分，只需要写上ProductInfoQueryVo，前端过来的json请求便会通过映射赋值到对应的对象中，例如请求这么写，productId就会自动被映射到vo对应的属性当中。

二、统一实体类

为了防止不同的请求所造成的返回的数据不同，而造成前端的接收比较麻烦，后端要和前端进行统一类。

一般包括 状态码 1/0;

传递的信息message(“xxx操作是否成功”);

以及数据Object data；

package com.chang.common;

import lombok.Data;
import java.util.HashMap;
import java.util.Map;

/*
    通用返回结果类，服务端响应的数据会被封装成为此对象。
    此类是一个通用结果类，服务端响应的所有结果最终都会包装成此种类型返回给前端页面。
	加上泛型。
 */
@Data
public class R<T> {

    private Integer code; //编码：1成功，0和其它数字为失败

    private String msg; //错误信息

    private T data; //数据

    private Map map = new HashMap(); //动态数据

    public static <T> R<T> success(T object) {
        R<T> r = new R<T>();
        r.data = object; // 对应一些员工数据什么的。
        r.code = 1;
        return r;
    }

    public static <T> R<T> error(String msg) {
        R r = new R();
        r.msg = msg;
        r.code = 0;
        return r;
    }

    /**
     * 操作map的动态数据
     * @param key
     * @param value
     * @return
     */
    public R<T> add(String key, Object value) {
        this.map.put(key, value);
        return this;
    }
}

数据的封装的变化：

{
  "productId": 1,
  "productName": "泡脚",
  "productPrice": 100.00,
  "productDescription": "中药泡脚加按摩",
  "productStatus": 0,
}

经过封装后就变成了

{
  "code": 1000,
  "msg": "请求成功",
  "data": {
    "productId": 1,
    "productName": "泡脚",
    "productPrice": 100.00,
    "productDescription": "中药泡脚加按摩",
    "productStatus": 0,
  }
}

然后前后端分离交互的 后端的Controller的返回值就需要统一一下了。

R<Xxx>

    @PostMapping("/findByVo")
    public ResultVo findByVo(@Validated ProductInfoVo vo) {
        ProductInfo productInfo = new ProductInfo();
        BeanUtils.copyProperties(vo, productInfo);
        return new ResultVo(productInfoService.getOne(new QueryWrapper(productInfo)));
    }

• 一般情况下，查询Get操作的返回值为R<List> 或者R
• return new R.success(list);
• 删除、修改、增加的操作为R
• return new R.success(“Xxx操作成功/失败！”);

当然也可通过枚举类来进行状态码的统一约定。因为是枚举类，会有get方法，而不会有set方法。

@Getter
public enum ResultCode implements StatusCode{
    SUCCESS(1000, "请求成功"),
    FAILED(1001, "请求失败"),
    VALIDATE_ERROR(1002, "参数校验失败"),
    RESPONSE_PACK_ERROR(1003, "response返回包装失败");

    private int code;
    private String msg;

    ResultCode(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

三、参数校验

在SpringBoot中，使用@Validate注解进行校验。

首先添加Maven依赖。

<dependency>
       <groupId>javax.validation</groupId>
       <artifactId>validation-api</artifactId>
</dependency>

然后就可以在实体类字段的属性上面使用了。

message：当不符合校验条件的时候，IDEA会报告给我们什么信息。

String类型的判断用@NotBlank, 可防止空字符串。

@Data
public class ProductInfoVo {
    @NotNull(message = "商品名称不允许为空")
    private String productName;

    @Min(value = 0, message = "商品价格不允许为负数") //设置最小值
    private BigDecimal productPrice;

    private Integer productStatus;
}

测试：

1.写Controller层方法。

    @PostMapping("/findByVo")
    public ProductInfo findByVo(@Validated ProductInfoVo vo) {
        ProductInfo productInfo = new ProductInfo();
        BeanUtils.copyProperties(vo, productInfo);
        return new ResultVo(productInfoService.getOne(new QueryWrapper(productInfo)));
    }

2.传递数据。

productName : 泡脚
productPrice : -1
productStatus : 1

3.观看控制台的输出。

{
  "timestamp": "2020-04-19T03:06:37.268+0000",
  "status": 400,
  "error": "Bad Request",
  "errors": [
    {
      "codes": [
        "Min.productInfoVo.productPrice",
        "Min.productPrice",
        "Min.java.math.BigDecimal",
        "Min"
      ],
      "arguments": [
        {
          "codes": [
            "productInfoVo.productPrice",
            "productPrice"
          ],
          "defaultMessage": "productPrice",
          "code": "productPrice"
        },
        0
      ],
      "defaultMessage": "商品价格不允许为负数",
      "objectName": "productInfoVo",
      "field": "productPrice",
      "rejectedValue": -1,
      "bindingFailure": false,
      "code": "Min"
    }
  ],
  "message": "Validation failed for object\u003d\u0027productInfoVo\u0027. Error count: 1",
  "trace": "org.springframework.validation.BindException: org.springframework.validation.BeanPropertyBindingResult: 1 errors\nField error in object \u0027productInfoVo\u0027 on field \u0027productPrice\u0027: rejected value [-1]; codes [Min.productInfoVo.productPrice,Min.productPrice,Min.java.math.BigDecimal,Min]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [productInfoVo.productPrice,productPrice]; arguments []; default message [productPrice],0]; default message [商品价格不允许为负数]\n\tat xxxxx
  "path": "/leilema/product/product-info/findByVo"
}

4.优化异常处理。

我们看到代码抛出了org.springframework.validation.BindException的绑定异常，因此我们的思路就是AOP拦截所有controller，然后异常的时候统一拦截起来，进行封装！完美！

为了响应上面我们定义的状态码，我们可以使用SpringMVC的注解@ExceptionHandler

Spring mvc给我们提供了一个@RestControllerAdvice来增强所有@RestController，然后使用@ExceptionHandler注解，就可以拦截到对应的异常。

@RestControllerAdvice(basePackages = {"com.bugpool.leilema"})
public class ControllerResponseAdvice implements ResponseBodyAdvice<Object> {
    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        // response是ResultVo类型，或者注释了NotControllerResponseAdvice都不进行包装
        return !methodParameter.getParameterType().isAssignableFrom(ResultVo.class);
    }

    @Override
    public Object beforeBodyWrite(Object data, MethodParameter returnType, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest request, ServerHttpResponse response) {
        // String类型不能直接包装
        if (returnType.getGenericParameterType().equals(String.class)) {
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                // 将数据包装在ResultVo里后转换为json串进行返回
                return objectMapper.writeValueAsString(new ResultVo(data));
            } catch (JsonProcessingException e) {
                throw new APIException(ResultCode.RESPONSE_PACK_ERROR, e.getMessage());
            }
        }
        // 否则直接包装成ResultVo返回
        return new ResultVo(data);
    }
}

1. @RestControllerAdvice(basePackages = {“com.bugpool.leilema”})自动扫描了所有指定包下的controller，在Response时进行统一处理
2. 重写supports方法，也就是说，当返回类型已经是ResultVo了，那就不需要封装了，当不等与ResultVo时才进行调用beforeBodyWrite方法，跟过滤器的效果是一样的
3. 最后重写我们的封装方法beforeBodyWrite，注意除了String的返回值有点特殊，无法直接封装成json，我们需要进行特殊处理，其他的直接new ResultVo(data);就ok了

当然也有其他例子。

package com.chang.common;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;


import java.sql.SQLIntegrityConstraintViolationException;

/**
 * 全局异常处理,对于指定的Controller的请求都要进行异常捕获and处理。
 */
@ControllerAdvice(annotations = {RestController.class, Controller.class})
@ResponseBody
@Slf4j
public class GlobalExceptionHandler {

    /**
     * 异常处理方法： 处理这种异常
     * @return
     */
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public R<String> exceptionHandler(SQLIntegrityConstraintViolationException ex){
        log.error(ex.getMessage());

        if(ex.getMessage().contains("Duplicate entry")){
            String[] split = ex.getMessage().split(" ");
            // 这里是根据爆出的异常信息来进行分配的。
            String msg = split[2] + "已存在";
            return R.error(msg);
        }

        return R.error("未知错误");
    }


    /**
     * 异常处理方法： 处理这种异常
     * @return
     */
    @ExceptionHandler(CustomException.class)
    public R<String> exceptionHandler(CustomException ex){
        log.error(ex.getMessage());


        return R.error(ex.getMessage());
    }
}