Java实现统一封装格式返回对象/请求前置切面

概述

实际业务开发中，由于多种业务情况，返回值不统一，对于对接方或前端数据对接时数据格式不统一，
处理起来比较麻烦，对系统的所有返回数据进行统一封装，保持一致
以及特殊定制类返回值不需要统一格式，另外定义注解是否使用统一返回形式：NotGlobalRet
直接定义自动封装返回对象对了切面类

全局请求前置切面

/**
 * 切面
 **/
@Aspect
@Component
@Slf4j
public class SysLogAspect {

    /**
     * 进入方法时间戳
     */
    private Long startTime;
    /**
     * 方法结束时间戳(计时)
     */
    private Long endTime;

    public SysLogAspect() {
    }
     /**
     * 定义请求日志切入点，其切入点表达式有多种匹配方式,这里是指定路径
     */
    @Pointcut("execution(public * com.project.controller..*.*(..)) ")
    public void webLogPointcut() {
    }
     /**
     * 前置通知：
     * 1. 在执行目标方法之前执行，比如请求接口之前的登录验证;
     * 2. 在前置通知中设置请求日志信息，如开始时间，请求参数，注解内容等
     *
     * @param joinPoint
     * @throws Throwable
     */
    @Before("webLogPointcut()")
    public void doBefore(JoinPoint joinPoint) {

        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            return;
        }
        HttpServletRequest request = attributes.getRequest();
        String sessionId = request.getHeader(SecurityConstant.TOKEN);
        String from = request.getHeader(SecurityConstant.FROM);
        //打印请求的内容
        startTime = System.currentTimeMillis();
        log.info("请求sessionId : 【{}】，请求来源:{}，请求url:{}，请求ip : {}",
                from, sessionId, request.getServletPath(), WebUtil.getIP(request));
        log.info("请求参数 : {}", Arrays.toString(joinPoint.getArgs()));
    }
    /**
     * 返回通知：
     * 1. 在目标方法正常结束之后执行
     * 1. 在返回通知中补充请求日志信息，如返回时间，方法耗时，返回值，并且保存日志信息
     *
     * @param ret
     * @throws Throwable
     */
    @AfterReturning(returning = "ret", pointcut = "webLogPointcut()")
    public void doAfterReturning(Object ret) throws Throwable {
        endTime = System.currentTimeMillis();
        log.info("请求耗时：{}", (endTime - startTime));
    }

返回对象处理类

/**
 * 统一修改api的成功返回值
 */
@Slf4j
@RestControllerAdvice
//控制配置类是否生效,可以使用@ConditionalOnProperty注解来控制@Configuration是否生效.
@ConditionalOnProperty(prefix="filter", name = "enabled", havingValue = "true")
public class RetAutoConfiguration implements ResponseBodyAdvice<Object> {
@Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 判断请求的Controller类或方法是否有注解
        Method method = returnType.getMethod();
        if (method == null) {
            return false;
        }
        Class<? extends Method> clazz = method.getClass();
        //有这个注解的@NotGlobalRet  就不使用统一格式的返回对象，直接返回
        boolean notGlobalRetFlag = returnType.hasMethodAnnotation(NotGlobalRet.class);
        if (clazz.isAnnotationPresent(NotGlobalRet.class) || notGlobalRetFlag) {
            return false;
        }
        return true;
    }
    
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        // 返回类和异常不包装
        if (body instanceof RetObj || body instanceof Exception) {
            return body;
        }
        return RetObj.success(body);
    }
}

配置中的值

filter.enabled=true  //false表示不生效

不使用统一封装格式注解

/**
 * 全局返回处理
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface NotGlobalRet {

}

统一返回格式类

/**
 * 返回信息
 */
@NoArgsConstructor
@Data
public class RetObj<T> implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * 状态,1为成功（兼容boyun,1为成功,0为失败，-1位警告)
     */
    private int flag;
    /**
     * 提示消息
     */
    private String msg;
    /**
     * 数据
     */
    private T obj;

    private RetObj(IRetCode retCode) {
        this(retCode, null, retCode.getMsg());
    }

    private RetObj(IRetCode retCode, String msg) {
        this(retCode, null, msg);
    }
    private RetObj(IRetCode retCode, T data) {
        this(retCode, data, retCode.getMsg());
    }
    private RetObj(IRetCode retCode, T data, String msg) {
        this(retCode.getCode(), data, msg);
    }
    private RetObj(int flag, T obj, String msg) {
        this.flag = flag;
        this.obj = obj;
        this.msg = msg;
    }

    /**
     * 返回成功
     *
     * @return R
     */
    public static <T> RetObj<T> success() {
        return new RetObj<>(CommonRetEnum.SUCCESS);
    }

    /**
     * 返回成功
     *
     * @param <T> T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> success(T obj) {
        return new RetObj<>(CommonRetEnum.SUCCESS, obj);
    }
    /**
     * 返回成功
     *
     * @param retCode 业务代码
     * @param msg     消息
     * @param <T>     T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> success(IRetCode retCode, String msg) {
        return new RetObj<>(retCode, msg);
    }
    /**
     * 返回失败
     *
     * @param msg 消息
     * @param <T> T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> fail(String msg) {
        return new RetObj<>(CommonRetEnum.FAIL, msg);
    }
    /**
     * 返回失败
     *
     * @param flag 状态码
     * @param msg  消息
     * @param <T>  T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> fail(int flag, String msg) {
        return new RetObj<>(flag, null, msg);
    }
    /**
     * 返回成功
     *
     * @param <T> T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> fail(int flag, String msg, T obj) {
        return new RetObj<>(flag, obj, msg);
    }
    /**
     * 返回R
     *
     * @param resultCode 业务代码
     * @param <T>        T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> fail(IRetCode resultCode) {
        return new RetObj<>(resultCode);
    }
    /**
     * 返回R
     *
     * @param resultCode 业务代码
     * @param <T>        T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> fail(IRetCode resultCode, String msg) {
        return new RetObj<>(resultCode, msg);
    }
    /**
     * 返回成功
     *
     * @param <T> T 泛型标记
     * @return R
     */
    public static <T> RetObj<T> fail(T obj) {
        return new RetObj<>(CommonRetEnum.FAIL, obj);
    }
}

业务api接口

/**
 * 业务api接口
 */
public interface IRetCode extends Serializable {
    /**
     * 状态码
     *
     * @return int
     */
    int getCode();

    /**
     * 消息
     *
     * @return String
     */
    String getMsg();
}

业务代码枚举

public enum CommonRetEnum implements IRetCode {
    SUCCESS(1, "成功"),
    OLD_SUCCESS(0, "成功"),
    FAIL(-1, "失败"),
    EXCEPTION(5001, "系统繁忙"),
    UN_AUTHENTICATION(4010, "请求未认证");
    final int code;
    final String msg;
    @Override
    public int getCode() {
        return this.code;
    }
    @Override
    public String getMsg() {
        return this.msg;
    }
    private CommonRetEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}