it

SpringBoot统一API魔改

2022-06-11  本文已影响0人  Jingzhiwindy

配置注解

package com.example.demo.api;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface API {

    boolean request() default true;

    boolean response() default true;
}

以注解的形式对接口进行配置，可配置在Controller的类或方法上。request属性为true，表示请求体需要分公有域和私有域，私有域数据封装在data节点内；为false，表示不区分公有域和私有域。response同理，如果属性为true，会将返回的业务数据封装在data节点内。

响应码的定义

package com.example.demo.api;

import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

import java.util.Arrays;

public enum State {

    SUCCESS(0, "success"),
    VALID_FAIL(100, "valid fail"),
    PASSWORD_ERROR(101, "password error"),
    UNKNOWN_ERROR(999, "unknow error");

    @JsonValue
    private int code;
    private String message;

    State(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    @Override
    public String toString() {
        return String.format("[%03d] %s", code, message);
    }

    public void tryThrow() {
        throw new StatefulException(this);
    }

    public void tryThrow(String message) {
        throw new StatefulException(this, message);
    }

    public void tryThrow(String messageTemplate, Object... params) {
        throw new StatefulException(this, messageTemplate, params);
    }

    public void tryThrow(Throwable cause) {
        throw new StatefulException(this, cause);
    }

    public void isTrue(boolean expression) {
        isFalse(!expression);
    }

    public void isTrue(boolean expression, String message) {
        isFalse(!expression, message);
    }

    public void isTrue(boolean expression, String messageTemplate, Object... params) {
        isFalse(!expression, messageTemplate, params);
    }

    public void isFalse(boolean expression) {
        if (expression) {
            throw new StatefulException(this);
        }
    }

    public void isFalse(boolean expression, String message) {
        if (expression) {
            throw new StatefulException(this, message);
        }
    }

    public void isFalse(boolean expression, String messageTemplate, Object... params) {
        if (expression) {
            throw new StatefulException(this, messageTemplate, params);
        }
    }

    public <T> T notNull(T obj) {
        if (obj == null) {
            throw new StatefulException(this);
        }
        return obj;
    }

    public <T> T notNull(T obj, String message) {
        if (obj == null) {
            throw new StatefulException(this, message);
        }
        return obj;
    }

    public <T> T notNull(T obj, String messageTemplate, Object... params) {
        if (obj == null) {
            throw new StatefulException(this, messageTemplate, params);
        }
        return obj;
    }

    public <T extends CharSequence> T notBlank(CharSequence str) {
        if (StrUtil.isBlank(str)) {
            throw new StatefulException(this);
        }
        return (T) str;
    }

    public <T extends CharSequence> T notBlank(CharSequence str, String message) {
        if (StrUtil.isBlank(str)) {
            throw new StatefulException(this, message);
        }
        return (T) str;
    }

    public <T extends CharSequence> T notBlank(CharSequence str, String messageTemplate, Object... params) {
        if (StrUtil.isBlank(str)) {
            throw new StatefulException(this, messageTemplate, params);
        }
        return (T) str;
    }

    public <T> List<T> notEmpty(List<T> list) {
        if (list == null || list.isEmpty()) {
            tryThrow();
        }
        return list;
    }

    public <T> List<T> notEmpty(List<T> list, String errorMessage) {
        if (list == null || list.isEmpty()) {
            tryThrow(errorMessage);
        }
        return list;
    }

    public <T> List<T> notEmpty(List<T> list, String messageTemplate, Object... params) {
        if (list == null || list.isEmpty()) {
            tryThrow(messageTemplate, params);
        }
        return list;
    }

    @JsonCreator
    public static State valueOf(int code) {
        return Arrays.stream(values()).filter(state -> state.getCode() == code).findAny().orElse(null);
    }
}

定义了错误码、错误信息，以及一些断言。使用断言可以抛出包含错误码和错误信息的异常

支持响应码的异常

package com.example.demo.api;

import cn.hutool.core.util.StrUtil;

public class StatefulException extends RuntimeException {

    private State state;

    public StatefulException(State state) {
        this.state = state;
    }

    public StatefulException(State state, String message) {
        super(message);
        this.state = state;
    }

    public StatefulException(State state, String messageTemplate, Object... params) {
        super(StrUtil.format(messageTemplate, params));
        this.state = state;
    }

    public StatefulException(State state, Throwable cause) {
        super(cause);
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return StrUtil.isBlank(getMessage()) ? state.toString() : state + ": " + getMessage();
    }
}

公有域的定义

package com.example.demo.api;

import java.io.Serializable;

public class PublicDomain<T> implements Serializable {

    private T data;

    public PublicDomain() {
    }

    public PublicDomain(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

将请求和响应分为公有域部分和私有域部分。响应中公有域包含响应码、响应信息和由data封装的私有域。

响应体的定义

package com.example.demo.api;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

@JsonPropertyOrder({"resCode", "resMessage", "errorMessage", "data"})
public class ResultVo<T> extends PublicDomain<T> {

    // 响应状态码
    private int resCode;
    // 响应状态信息
    private String resMessage;
    // 错误详情
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String errorMessage;

    public ResultVo() {
        this(State.SUCCESS);
    }

    public ResultVo(T data) {
        super(data);
        this.resCode = State.SUCCESS.getCode();
        this.resMessage = State.SUCCESS.getMessage();
    }

    public ResultVo(State state) {
        this.resCode = state.getCode();
        this.resMessage = state.getMessage();
    }

    public ResultVo(StatefulException statefulException) {
        State state = statefulException.getState();
        this.resCode = state.getCode();
        this.resMessage = state.getMessage();
        this.errorMessage = statefulException.getMessage();
    }

    public ResultVo(State state, Throwable ex) {
        this.resCode = state.getCode();
        this.resMessage = state.getMessage();
        this.errorMessage = ex.getMessage();
    }

    public int getResCode() {
        return resCode;
    }

    public void setResCode(int resCode) {
        this.resCode = resCode;
    }

    public String getResMessage() {
        return resMessage;
    }

    public void setResMessage(String resMessage) {
        this.resMessage = resMessage;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public void setErrorMessage(String errorMessage) {
        this.errorMessage = errorMessage;
    }
}

请求体的处理

package com.example.demo.api;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.util.StreamUtils;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdviceAdapter;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;

@RestControllerAdvice(basePackages = "com.example.demo")
public class RequesstApiAdvice extends RequestBodyAdviceAdapter {

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        API apiAnn = methodParameter.hasMethodAnnotation(API.class) ?
                methodParameter.getMethodAnnotation(API.class) : methodParameter.getDeclaringClass().getAnnotation(API.class);
        return apiAnn != null && apiAnn.request() && !PublicDomain.class.equals(methodParameter.getParameterType());
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter,
                                           Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        JsonNode jsonNode = objectMapper.readTree(inputMessage.getBody());
        return new HttpInputMessage() {
            @Override
            public InputStream getBody() {
                JsonNode dataJsonNode = State.VALID_FAIL.notNull(jsonNode.get("data"), "请求体未包含私有域节点data");
                return new ByteArrayInputStream(dataJsonNode.toString().getBytes(StandardCharsets.UTF_8));
            }

            @Override
            public HttpHeaders getHeaders() {
                return inputMessage.getHeaders();
            }
        };
    }
}

响应体的处理

响应体的处理可以基于ResponseBodyAdvice，也可以基于HandlerMethodReturnValueHandler，两种方案可以任选其一

基于ResponseBodyAdvice的实现
package com.example.demo.api;

import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
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.example.demo")
public class ResponseApiAdvice implements ResponseBodyAdvice {
    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        API apiAnn = returnType.hasMethodAnnotation(API.class) ?
                returnType.getMethodAnnotation(API.class) : returnType.getDeclaringClass().getAnnotation(API.class);
        return apiAnn != null && apiAnn.response();
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        return body instanceof ResultVo ? body : new ResultVo<>(body);
    }
}
基于HandlerMethodReturnValueHandler的实现
package com.example.demo.api;

import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor;

import java.util.ArrayList;
import java.util.List;

@Component
public class ApiHandlerMethodReturnValueHandler implements HandlerMethodReturnValueHandler {

    private HandlerMethodReturnValueHandler handler;

    public ApiHandlerMethodReturnValueHandler(RequestMappingHandlerAdapter requestMappingHandlerAdapter) {
        List<HandlerMethodReturnValueHandler> originHandlers = requestMappingHandlerAdapter.getReturnValueHandlers();
        List<HandlerMethodReturnValueHandler> newHandlers = new ArrayList<>(originHandlers.size());
        for (HandlerMethodReturnValueHandler originHandler : originHandlers) {
            if (originHandler instanceof RequestResponseBodyMethodProcessor) {
                newHandlers.add(this);
                handler = originHandler;
            } else {
                newHandlers.add(originHandler);
            }
        }
        requestMappingHandlerAdapter.setReturnValueHandlers(newHandlers);
    }

    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        API apiAnn = returnType.hasMethodAnnotation(API.class) ?
                returnType.getMethodAnnotation(API.class) : returnType.getDeclaringClass().getAnnotation(API.class);
        return handler.supportsReturnType(returnType) && apiAnn != null && apiAnn.response();
    }

    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
        Object response = returnValue instanceof ResultVo ? returnValue : new ResultVo<>(returnValue);
        handler.handleReturnValue(response, returnType, mavContainer, webRequest);
    }
}

HandlerMethodReturnValueHandler 的作用是对处理器的处理结果再进行一次二次加工

全局异常处理

package com.example.demo.api;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionResolver {
    private final static Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionResolver.class);

    @ExceptionHandler(Exception.class)
    public ResultVo exceptionHandle(Exception ex) {
        LOGGER.error("error", ex);
        return new ResultVo(State.UNKNOWN_ERROR, ex);
    }

    @ExceptionHandler(RuntimeException.class)
    public ResultVo exceptionHandle(RuntimeException ex) {
        LOGGER.error("valid fail", ex);
        return new ResultVo(State.VALID_FAIL, ex);
    }

    @ExceptionHandler(StatefulException.class)
    public ResultVo exceptionHandle(StatefulException ex) {
        LOGGER.error(ex.getState().toString(), ex);
        return new ResultVo(ex);
    }
}

测试

package com.example.demo.user.entity;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class User {

    private String account;
    private String name;
    private String password;
}

package com.example.demo.user.controller;

import com.example.demo.api.API;
import com.example.demo.api.State;
import com.example.demo.user.entity.User;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @API
    @PostMapping("/login/passport")
    public User test(@RequestBody User user) {
        State.VALID_FAIL.notBlank(user.getAccount(), "账号为空");
        State.VALID_FAIL.notBlank(user.getPassword(), "密码为空");
        State.PASSWORD_ERROR.isTrue(user.getPassword().equals("123456"), "密码错误");
        return user;
    }
}

正确请求

{
    "data": {
        "account": "demo",
        "password": "123456"
    }
}

响应

{
    "resCode": 0,
    "resMessage": "success",
    "data": {
        "account": "demo",
        "name": null,
        "password": "123456"
    }
}

密码错误请求

{
    "data": {
        "account": "demo",
        "password": "123"
    }
}

响应

{
    "resCode": 101,
    "resMessage": "password error",
    "errorMessage": "密码错误",
    "data": null
}
上一篇 下一篇

猜你喜欢

热点阅读