Java接口响应封装类
 
Web开发中，前后分离是个趋势，现在大部分公司研发部门已经在走前后分离的路子了，前后分离开发各司其职能够有效的提高工作效率和开发质量。
 
REST接口会返回各种各样的数据，如果对接口的格式不加约束，很容易造成混乱。
 
在实际项目中，一般会把结果放在一个封装类中，封装类中包含http状态值，状态消息，以及实际的数据。
 
 
 
个人总结一下工作中用到的接口响应类。😃
 
 
状态枚举，接口响应状态码、消息，统一在此枚举类中定义，方便阅读、修改。
 
/**
 * 响应状态码枚举
 * @author liuyang
 * 2020-01-13
 */
public enum CodeEnum {

    SUCCESS(0, "成功"),
    FAIL(1, "失败"),
    ;

    private final Integer code;

    private final String msg;
  // 省略枚举构造方法、get、set方法
}
 
数据响应基类，方便以后扩展子类，也可用于增、删、改相关接口响应。
 
/**
 * 响应数据基类
 * @author liuyang
 * 2020-01-13
 */
public class BaseResponse {

    /**
     * 状态码
     */
    private Integer code;

    /**
     * 响应消息
     */
    private String msg;

    protected BaseResponse() {}

    protected BaseResponse(CodeEnum code) {
        this.code = code.getCode();
        this.msg = code.getMsg();
    }
  // 省略get/set方法
}
 
响应数据体，继承自 BaseResponse 类，增加了 范型 属性，方便响应各种数据。
 
/**
 * 响应数据体
 * @author liuyang
 * 2020-01-13
 */
public class ResponseData<T> extends BaseResponse {

    /**
     * 数据
     */
    private T data;

    private ResponseData(CodeEnum code) {
        super(code);
    }

    private ResponseData(CodeEnum code, T data) {
        super(code);
        this.data = data;
    }

    /**
     * 对外开放基础响应体已供调用，可用于增、删、改接口操作
     */
    public static BaseResponse out(CodeEnum code) {
        return new BaseResponse(code);
    }

    /**
     * 对外开放数据响应体已供调用，可用于查询数据实用，引用了范型设计，支持各种数据类型
     */
    public static <T> ResponseData<T> out(CodeEnum code, T data) {
        return new ResponseData<>(code, data);
    }
  // 省略get/set方法
}
 
以上三个类足可以满足日常开发，顺带说一句，CodeEnum枚举类也可用于定义处于业务异常逻辑，比如：抛出用户不存在的异常，然后配合Spring MVC的 @ControllerAdvice注解，统一响应异常信息。（如果不明白，可在评论区说明，可以考虑再出一篇针对异常处理的文章）
 
 
 
进入测试------------------------
 
 
基础响应，此处模拟删除
 
@GetMapping("/user/del/{userId}")
public BaseResponse delUser(@PathVariable Integer userId) {
	return ResponseData.out(CodeEnum.FAIL);
}
 
访问：localhost:8080/user/del/1
 
响应：
 
{
    "code": 1,
    "msg": "失败"
}
 
数据体响应，此处模拟用户列表
 
@GetMapping("/user-info")
public ResponseData<List<String>> userInfo() {
  List<String> list = new ArrayList<>();
  list.add(UUID.randomUUID().toString());
  list.add(UUID.randomUUID().toString());
  list.add(UUID.randomUUID().toString());
  list.add(UUID.randomUUID().toString());
  return ResponseData.out(CodeEnum.SUCCESS, list);
}
 
访问：localhost:8080/user-info
 
响应：
 
{
    "code": 0,
    "msg": "成功",
    "data": [
        "003252cf-3361-43c4-8fdc-b9091f83ea05",
        "6320cd96-ae04-4885-ac78-76241f19ac95",
        "34cdd394-97d4-4e7d-993f-e4688b86d0e0",
        "bd293a9e-465b-4796-b8fa-17fc37de9bf7"
    ]
}
 
以上，测试成功。
 
PS：可在此基础上加入一些符合自己需要的属性，比如：响应时间戳、响应标识等等…

 
 
为什么要监控
 
　　服务化接口是提供服务的，接口正确性、稳定性是最最重要的，在保证正确的同时需要尽量提高接口响应时间。
 
　　有的团队会有专门的工具来对系统响应时间、吞吐量做监控，但如果团队没有这种“待遇”就需要自己来做一些工具为自己的代码提供服务。
 
自己动手,丰衣足食
 
　　AOP + Annotation 简陋实现，能达到目的
 
　　AOP : 使用环绕方式对接口拦截,在拦截接口前后记录时间最后计算用时
 
　　Annotation : 自定义注解在接口上设置超时时间(timeout)和超时是否发送邮件选项(emailIfTimeout)
 
　　通过对接口实际执行时间和配置的超时时间比较，系统可以计算出接口是否超时，此时可使用日志(或其他能通知到开发人员的方式)记录具体哪个接口、什么参数以及执行时间
 
　　注解可以提供更多的选项，来为自己接口服务，比如支持注解到类上，批量为接口设置了默认超时时间、支持日志中显示的处理方法名称 等等...
 
代码实施
 
接口Annotation定义
 
package opsteel.oupuzw.web.logistics.bean;

import org.springframework.core.annotation.AliasFor;

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

/**
 * 创建自定义注解输出接口耗时(@PrintCostTime)
 * create on 2018-08-08
 * @author Yesh
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface PrintCostTime {

    /** 输出方法名称 **/
    @AliasFor("name")
    String name() default "";

    /**
     * 接口超时时间,单位毫秒.默认值100毫秒
     * @return 设置的超时时间
     */
    int timeout() default 100;

    /**
     * 注解上的打印参数
     * @return 输出的时候打印出来
     */
    String[] printArgs() default {};

    /**
     * 是否开启日志监控功能默认开
     * @return 返回ture需要发送邮件
     */
    boolean enablePrint() default true;

    /**
     * 是否允许打印在默认列表里的参数(默认 true)
     * @return
     */
    boolean enablePrintDefaultArgs() default true;

    /**
     * 当接口响应超时时,是否发送邮件.默认发送
     * @return 返回ture需要发送邮件
     */
    boolean emailIfTimeout() default true;
}
 
package opsteel.oupuzw.web.logistics.bean;

import lombok.extern.log4j.Log4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 日志AOP监控接口响应时长
 * create on 2018-08-08
 *
 * @author Yesh
 */
@Component
@Aspect
@Log4j
public class PrintCostTimeAspect {

    @Around("@annotation(opsteel.oupuzw.web.logistics.bean.PrintCostTime)")
    public Object aroundPrintCostTime(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature signature = (MethodSignature) pjp.getSignature(); //方法签名
        PrintCostTime printCostTime = signature.getMethod().getAnnotation(PrintCostTime.class);//从签名注解中获取注解内容配置项
        String methodCName = printCostTime.name();//方法中文名称[注解中获取 不填写 为""]
        String methodName = signature.getName();
        //        Class clazz = pjp.getTarget().getClass();  //取拦截的Class
        //RequestMapping requestMapping = signature.getMethod().getAnnotation(RequestMapping.class);//从这里可以获取 请求地址
        //方法名和参数值
        //String[] ArgsNames = signature.getParameterNames();
        //Object[] argsValue = pjp.getArgs();
        //参数打印目前没必要 result 中可以获取 返回的json值
//        String argsLog = getArgsLog(printCostTime, ArgsNames, argsValue);

        long start = System.currentTimeMillis();  //开始时间
        Object[] args = pjp.getArgs(); //取拦截的Args
        Object result = pjp.proceed(args);  //运行被拦截的方法
        if (printCostTime.enablePrint()==false){ //若开关为 true 开启打印
            return result;
        }

        long end = System.currentTimeMillis();
        long diff = end - start;//计算耗时

        //若超过配置的阀值则打印耗时日志
        long thresholdInMs = printCostTime.timeout();
        if (diff >= thresholdInMs) {
            log.info(methodCName + ":[" + methodName + "]" + ",响应时间: " + diff + " ms");
            //发邮件发作即可
        }
        return result;
    }

}
 
 
 
@PrintCostTime(name = "XXX")
 
在Controller注解上即可描述当前接口花费时间
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

long start = System.currentTimeMillis();
//访问接口
long end = System.currentTimeMillis();
System.out.println("耗时:" + (end - start) + "ms");

 
 
前后端分离的开发模式中，或者与第三方接口交互，需要规范接口响应，下面是我在开发中的封装的一组响应实体类
 
 
响应实体父类， 父类中需要一个code，因为不管是响应消息还是数据，都要有code
 
/**
 - @title 响应实体父类
 - @author gavin
 - @date 2020年6月10日
 */
public class Response {
	
	private String code;

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}
}
 
信息响应实体类，继承Response类，并且需要添加一个msg属性，用于存储返回码描述
 
/**
 * @title 消息响应实体类
 * @author gavin
 * @date 2020年6月10日
 */
public class ResponseMsg extends Response {

	private String msg;

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}
}
 
数据响应实体类，继承Response类，并且需要添加一个data属性，用来存储响应数据
 
/**
 * @title 数据响应实体类
 * @author gavin
 * @date 2020年6月10日
 */
public class ResponseData extends Response{

	private Object data;

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}
}
 
接下来就可以使用了，新建RspController测试一下响应错误信息和响应数据
 
@RestController
@RequestMapping("rsp")
public class RspController {
	
	@GetMapping("msg")
	public Response msg() {
		ResponseMsg responseMsg = new ResponseMsg();
		responseMsg.setCode("401");
		responseMsg.setMsg("用户无权限");
		return responseMsg;
	}
	
	@GetMapping("data")
	public Response data() {
		ResponseData responseData = new ResponseData();
		responseData.setCode("0");
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("name", "张三");
		map.put("age", 24);
		responseData.setData(map);
		return responseData;
	}
}
 
启动项目，使用postman访问一下
 
访问/rsp/msg接口，postman收到响应如下
 
访问/rsp/data接口，postman收到响应如下
 
 
 
 
开发中，返回码通常都是共用的，不需要每个接口都写一遍硬代码，我们可以对全局错误码封装一个枚举类
 
 
public enum ResponseEnum {
	
	SUCCESS("0" , "ok"),
	AUTH_DENIED("401","用户无权限");
	
	private String code;
	private String msg;
	
	ResponseEnum(String code , String msg){
		this.code = code;
		this.msg = msg;
	}
	
	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}	
}
 
有了全局返回码枚举类后，/rsp/msg接口中就不要写硬代码了，可以改成如下
 
@GetMapping("msg")
public Response msg() {
	ResponseMsg responseMsg = new ResponseMsg();
	responseMsg.setCode(ResponseEnum.AUTH_DENIED.getCode());
	responseMsg.setMsg(ResponseEnum.AUTH_DENIED.getMsg());
	return responseMsg;
}
 
 
 
虽然这样避免了多处使用硬代码的问题，但还是有些繁琐，我们还可以编写一个ResponseUtil类，来简化开发
 
 
/**
 * @title 响应工具类
 * @author gavin
 * @date 2020年6月11日
 */
public class ResponseUtil {
	/**
	 * @title 成功返回码
	 * @author gavin
	 * @date 2020年6月11日
	 * @return
	 */
	public static Response success() {
		ResponseMsg response = new ResponseMsg();
		response.setCode(ResponseEnum.SUCCESS.getCode());
		response.setMsg(ResponseEnum.SUCCESS.getMsg());
		return response;
	}
	
	
	/**
	 * @title 通用返回码
	 * @author gavin
	 * @date 2020年6月11日
	 * @return
	 */
	public static Response rspMsg(String code , String msg) {
		ResponseMsg response = new ResponseMsg();
		response.setCode(code);
		response.setMsg(msg);
		return response;
	}
	
	/**
	 * @title 通用返回码
	 * @author gavin
	 * @date 2020年6月11日
	 * @return
	 */
	public static Response rspMsg(ResponseEnum responseEnum) {
		ResponseMsg response = new ResponseMsg();
		response.setCode(responseEnum.getCode());
		response.setMsg(responseEnum.getMsg());
		return response;
	}
	
	/**
	 * @title 响应数据
	 * @author gavin
	 * @date 2020年6月11日
	 * @param data
	 * @return
	 */
	public static Response rspData(Object data) {
		ResponseData response = new ResponseData();
		response.setCode(ResponseEnum.SUCCESS.getCode());
		response.setData(data);
		return response;
	}
}
 
ResponseUtil类中封装了4个方法，基本上够我们日常开发使用了，接下来我们可以用这个工具类来简化一下/rsp/msg接口和/rsp/data接口，代码如下
 
@RestController
@RequestMapping("rsp")
public class RspController {
	
	@GetMapping("msg")
	public Response msg() {
		return ResponseUtil.rspMsg(ResponseEnum.AUTH_DENIED);
	}
	
	@GetMapping("data")
	public Response data() {
		
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("name", "张三");
		map.put("age", 24);
		
		return ResponseUtil.rspData(map);
	}
}
 
通过工具类简化后，基本上响应代码就只需要一行就可以了，大大简化了我们的代码。