controller层响应返回封装

控制层响应封装

控制层请求正确返回相应拦截封装

package com.demo.autotest.common.response;

import com.demo.autotest.common.exception.DemoException;
import com.demo.autotest.dto.ResponseDTO;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.ByteArrayHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

@RestControllerAdvice(basePackages = {"com.demo.autotest.controller"})  // 用来拦截响应
public class ResponseControllerAdvice implements ResponseBodyAdvice<Object> {
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> aClass) {
        // 如果接口返回的类型是二进制，返回false，即不对对象进行beforeBodyWrite处理
        return !aClass.equals(ByteArrayHttpMessageConverter.class);
    }

    @Override
    public Object beforeBodyWrite(Object data, MethodParameter returnType, MediaType mediaType, Class<?
            extends HttpMessageConverter<?>> aClass, ServerHttpRequest request, ServerHttpResponse response) {
        // String类型不能直接包装，所以要进行些特别的处理
        //控制层的String类型的返回值在Spring MVC中通常被视为已经准备好的响应体内容。这意味着字符串内容会直接被写入HTTP响应，而不会经过额外的转换或处理。
        if (returnType.getGenericParameterType().equals(String.class)) {
            ObjectMapper objectMapper = new ObjectMapper();
            try {
                // 将数据包装在ResponseTemp里后，再转换为json字符串响应给前端
                return objectMapper.writeValueAsString(new ResponseDTO<>(data));
            } catch (JsonProcessingException e) {
                throw new DemoException("String类型返回错误");
            }
        }
        // 将原本的数据包装在ResponseTemp里
        return new ResponseDTO<>(data);
    }
}

控制层请求异常拦截封装

package com.demo.autotest.common.response;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.demo.autotest.common.constant.ResponseCode;
import com.demo.autotest.common.exception.DemoException;
import com.demo.autotest.dto.ResponseDTO;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice   // 用来接收没有捕获的异常 从而定义异常处理方法
public class ExceptionControllerAdvice {

    @ExceptionHandler(DemoException.class)  // 定义异常发生时处理办法
    public ResponseDTO<String> LMExceptionHandler(DemoException e) {
        // 未知的失败
        return new ResponseDTO<>(ResponseCode.FAILED, e.getMessage());
    }

    @ExceptionHandler(TokenExpiredException.class)
    public ResponseDTO<String> TokenExpireExceptionHandler(TokenExpiredException e) {
        return new ResponseDTO<>(ResponseCode.EXPIRED_ERROR, e.getMessage());
    }

    @ExceptionHandler(JWTDecodeException.class)
    public ResponseDTO<String> PasswordVerifyExceptionHandler(JWTDecodeException e) {
        return new ResponseDTO<>(ResponseCode.DECODE_ERROR, e.getMessage());
    }
}

响应结果定义

定义统一返回格式

package com.demo.autotest.dto;

import com.demo.autotest.common.constant.ResponseCode;
import lombok.Data;

@Data
public class ResponseDTO<T> {

    private int status;

    private String message;

    private int code;

    private T data;

    public ResponseDTO(T data) {
        this(ResponseCode.SUCCESS, data);
    }

    public ResponseDTO(ResponseCode resultCode, T data) {
        this.status = resultCode.getStatus();
        this.code = this.status;
        this.message = resultCode.getMessage();
        this.data = data;
    }
}

定义统一请求状态

package com.demo.autotest.common.constant;

import lombok.Getter;

@Getter
public enum ResponseCode {
    SUCCESS(0, "成功"),

    FAILED(1000, "失败"),

    EXPIRED_ERROR(1001, "token过期错误"),

    DECODE_ERROR(1002, "token解析错误");

    private final int status;
    private final String message;

    ResponseCode(int status, String message) {
        this.status = status;
        this.message = message;
    }
}