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：可在此基础上加入一些符合自己需要的属性，比如：响应时间戳、响应标识等等…

接口类：
1 package org.sunshine.dcda.epg.wechat.controller.niao;
2
3 import javax.servlet.http.HttpServletRequest;
4 import org.springframework.stereotype.Controller;
5 import org.springframework.web.bind.annotation.RequestMapping;
6 import org.springframework.web.bind.annotation.RequestMethod;
7 import org.springframework.web.bind.annotation.ResponseBody;
8 import org.sunshine.dcda.basecomponent.json.JsonUtils;
9 import org.sunshine.dcda.epg.wechat.common.vo.NiaodaifuVO;
10 import org.sunshine.dcda.epg.wechat.controller.base.BaseController;
11
12 @Controller
13 public class NiaodaifuController extends BaseController {
14
15     @ResponseBody
16     @RequestMapping(value="/urineTestData", produces="text/html;charset=UTF-8", method=RequestMethod.POST)
17     public String urineTestData(HttpServletRequest request) {
18         String data = getRequestStr(request);
19         NiaodaifuVO n = JsonUtils.fromJson(data, NiaodaifuVO.class);    //Json转对象
20         System.out.println("~~~~~~~~~~~~~~~~~");
21 //        //接收数据
22         System.out.println("2017年12月7日 10:58:13："+n.getCname()
23         +n.getRecord_id()+",userbind:"+n.getUserbind()
24         +",family_id:"+n.getFamily_id()+",mobile:"+n.getMobile()
25         +",---:"+n.getFamily_name()+",---:"+n.getNj_userid()
26         +",---status:"+n.getStatus()+",---:"+n.getSuggestion()
27         +",---:"+n.getCreated()+",---type:"+n.getType()
28         +",--*********data:"+n.getData());
29         System.out.println(n);
30         //Unicode转中文
31 //        String chinese = convert(data);
32         System.out.println("!!!!~~~~~~~~~~~");
33
34         return "二〇一七年十二月七日 10:58:34";
35     }
36     //Unicode转中文
37     public String convert(String utfString){
38         StringBuilder sb = new StringBuilder();
39         int i = -1;
40         int pos = 0;
41
42         while((i=utfString.indexOf("\\u", pos)) != -1){
43             sb.append(utfString.substring(pos, i));
44             if(i+5 < utfString.length()){
45                 pos = i+6;
46                 sb.append((char)Integer.parseInt(utfString.substring(i+2, i+6), 16));
47             }
48         }
49
50         return sb.toString();
51     }
52
53     @RequestMapping(value="/testNiao")
54     public String test(){
55         System.out.println("@@@@@@@@2017.12.07@@@@@@@@@@");
56         return "~~~~~~~~~~~~~2017-12-07~~~~~~~~~~";
57     }
58 }
接口调用传参测试类：
package org.sunshine.dcda.epg.wechat.controller.niao;
import java.io.IOException;
import org.sunshine.dcda.basecomponent.http.utils.HttpUtils;
import org.sunshine.dcda.basecomponent.json.JsonUtils;
import org.sunshine.dcda.epg.wechat.common.vo.NiaodaifuVO;
public class TestNiao {
public static void main(String[] args) {
NiaodaifuVO vo = new NiaodaifuVO();
vo.setCname("cnameQQQQQQQQ");
vo.setCreated(1);
System.out.println(JsonUtils.toJson(vo));
try {
System.out.println(HttpUtils.doPost("http://twx.aicares.net/urineTestData", JsonUtils.toJson(vo)));
} catch (IOException e) {
e.printStackTrace();
}
}
}
接口继承   读取流工具类：
package org.sunshine.dcda.epg.wechat.controller.base;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.MessageFormat;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.sunshine.dcda.aicare.service.model.CustomerVo;
import org.sunshine.dcda.basecomponent.string.StringUtils;
import org.sunshine.dcda.epg.wechat.common.enums.MetaCodeEnums;
import org.sunshine.dcda.epg.wechat.common.exception.ServiceException;
import org.sunshine.dcda.epg.wechat.common.utils.LocalMethodVisitUtils;
import org.sunshine.dcda.epg.wechat.common.vo.InputVO;
import org.sunshine.dcda.epg.wechat.common.vo.OutputVO;
import org.sunshine.dcda.epg.wechat.service.cache.ICustomerCacheComponent;
import org.sunshine.dcda.epg.wechat.service.cache.IPublicInfoCacheComponent;
import org.sunshine.dcda.wechat.service.model.PublicInfoVo;
@Controller
public class BaseController {
private final Logger logger = LoggerFactory.getLogger(BaseController.class);
@Resource
private IPublicInfoCacheComponent publicInfoCacheComponent;
@Resource
private ICustomerCacheComponent customerCacheComponent;
public String getRequestStr(HttpServletRequest request) {
StringBuilder str = new StringBuilder();
BufferedReader bufferedReader = null;
InputStreamReader inputStreamReader = null;
try {
inputStreamReader = new InputStreamReader(request.getInputStream(), "UTF-8");
bufferedReader = new BufferedReader(inputStreamReader);
String line = null;
while ((line = bufferedReader.readLine()) != null) {
str.append(line);
}
logger.info("读取request文件流信息：" + str);
} catch (Exception e) {
logger.error("读取request文件流信息异常：" + e.getMessage());
} finally {
if (null != bufferedReader) {
try {
bufferedReader.close();
} catch (IOException e) {
logger.error(e.getMessage());
}
}
if (null != inputStreamReader) {
try {
inputStreamReader.close();
} catch (IOException e) {
logger.error(e.getMessage());
}
}
}
return str.toString();
}
public void printResponse(HttpServletResponse response, String result) {
try {
logger.info("response.getWriter().print : " + result);
response.getWriter().print(result);
} catch (IOException e) {
logger.error(e.getMessage());
}
}
public void redirect500(HttpServletResponse response) {
try {
response.setContentType("text/html; charset=UTF-8");
response.sendRedirect(LocalMethodVisitUtils.getAbsoluteUrl("/500"));
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
public void redirectPublicStop(HttpServletResponse response) {
try {
response.setContentType("text/html; charset=UTF-8");
response.sendRedirect(LocalMethodVisitUtils.getAbsoluteUrl("/publicStop"));
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
public OutputVO checkParamRequired(InputVO inputVO, String... keys) throws ServiceException {
OutputVO outputVO = new OutputVO();
if (null == inputVO || StringUtils.isEmpty(inputVO.getCid()) || StringUtils.isEmpty(inputVO.getPa())) {
logger.error("非法访问，customerId or publicAccount is null. inputVO = {}", inputVO.toString());
throw new ServiceException(MetaCodeEnums.ERR_PARAM.getKey(), "parameter error, customerId or publicAccount is null");
}
String publicAccount = inputVO.getPa();
String customerId = inputVO.getCid();
PublicInfoVo publicInfoVo = null;
try {
publicInfoVo = publicInfoCacheComponent.queryByPublicAccount(publicAccount);
} catch (Exception e) {
logger.error(e.getMessage(), e);
publicInfoVo = null;
}
if (null == publicInfoVo) {
logger.error("非法访问，publicInfoVo is not exists, publicAccount = {}", publicAccount);
throw new ServiceException(MetaCodeEnums.ERR_PARAM.getKey(), "parameter error, publicInfoVo is not exists.");
}
CustomerVo customerVo = null;
try {
customerVo = customerCacheComponent.queryByCustomerId(customerId);
} catch (Exception e) {
logger.error(e.getMessage(), e);
customerVo = null;
}
if(null == customerVo) {
logger.error("非法访问，customerVo is not exists, customerId = {}", customerId);
throw new ServiceException(MetaCodeEnums.ERR_PARAM.getKey(), "parameter error, customerVo is not exists.");
}
if (null != keys && keys.length > 0) {
for (String key : keys) {
if (null == inputVO.getJsonElement(key)) {
logger.error("checkRequiredParam, reqId = {}, parameter param.{} is null", key);
throw new ServiceException(MetaCodeEnums.ERR_PARAM.getKey(), MessageFormat.format(MetaCodeEnums.ERR_PARAM.getValue(), "parameter param." + key + " is null"));
}
}
}
return outputVO;
}
}
------------------------------------------------------------分割线-----------------------------------------------------------------------------
回调接收数据：HttpServletRequest request
x-www-form-urlencoded格式接收方式
/**
* 动态遍历获取所有收到的参数,此步非常关键,因为收银宝以后可能会加字段,动态获取可以兼容由于收银宝加字段而引起的签名异常
* @param request
* @return
*/
private TreeMap getParams(HttpServletRequest request){
TreeMap map = new TreeMap();
Map reqMap = request.getParameterMap();
for(Object key : reqMap.keySet()){
String value = ((String[])reqMap.get(key))[0];
map.put(key.toString(),value);
}
return map;
}
//上下两种方法都OK
protected HashMap getRequestData(HttpServletRequest request){
HashMap notifMaps = new HashMap<>();
Map parameterMap = request.getParameterMap();
Set> entries = parameterMap.entrySet();
Iterator> iterator = entries.iterator();
while (iterator.hasNext()) {
Map.Entry next = iterator.next();
notifMaps.put(next.getKey(), next.getValue()[0]);
}
return notifMaps;
}
json格式接收方式
/**流读取http请求内容*/
public static String getHttpRequest(HttpServletRequest request) {
String body = "";
try {
ServletInputStream inputStream = request.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
while (true) {
String info = br.readLine();
if (info == null) {
break;
}
if (body == null || "".equals(body)) {
body = info;
} else {
body += info;
}
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return body;
}
ASP&period;NET Core 入门(2)(WebApi接口请求日志 Request和Response)
以前 .NET Framework WebApi 记录接口访问日志,一般是通过Filter的方式进行拦截,通过重写ActionFilterAttribute的OnActionExecuting实现拦截 ...
LoadRunner 获取接口请求响应信息
Action() { int nHttpRetCode; // 默认最大长度为256,get请求需注意缓存问题,需要根据content-length进行修改 web_set_max_html_para ...
&lbrack;转&rsqb; LoadRunner 获取接口请求响应信息
Action() { int nHttpRetCode; // 默认最大长度为256,get请求需注意缓存问题,需要根据content-length进行修改 web_set_max_html_para ...
django 获取request请求对象及response响应对象中的各种属性值
django request对象和HttpResponse对象 HttpRequest对象(除非特殊说明,所有属性都是只读,session属性是个例外) HttpRequest.scheme 请求方案 ...
Java Web之请求和响应
Servlet最主要作用就是处理客户端请求并作出回应,为此,针对每次请求,Web容器在调用service()之前都会创建两个对象,分别是HttpServletRequest和HttpServletRe ...
javaWeb中request请求转发和response重定向
1.访问资源 运用forward方法只能重定向到同一个Web应用程序中的一个资源. 而sendRedirect方法可以让你重定向到任何URL.  2.request.get Forward代码中的&q ...
Java web课程学习之Request和Response
request和response l HttpServletRequest l 请求转发 l HttpServletResponse l 请求重定向   请求流程 每次请求service(),都会由容 ...
DRF框架(一)——restful接口规范、基于规范下使用原生django接口查询和增加、原生Django CBV请求生命周期源码分析、drf请求生命周期源码分析、请求模块request、渲染模块render
DRF框架    全称:django-rest framework 知识点 1.接口:什么是接口.restful接口规范 2.CBV生命周期源码 - 基于restful规范下的CBV接口 3.请求组件 ...
第三篇 ：微信公众平台开发实战Java版之请求消息，响应消息以及事件消息类的封装
微信服务器和第三方服务器之间究竟是通过什么方式进行对话的? 下面,我们先看下图: 其实我们可以简单的理解: (1)首先,用户向微信服务器发送消息: (2)微信服务器接收到用户的消息处理之后,通过开发者 ...
随机推荐
Java 多线程编程
1.synchronized/wait/notify package javamultithread; import java.util.logging.Level; import java.util ...
【收藏】Java多线程&sol;并发编程大合集
(一).[Java并发编程]并发编程大合集-兰亭风雨    [Java并发编程]实现多线程的两种方法    [Java并发编程]线程的中断    [Java并发编程]正确挂起.恢复.终止线程    [ ...
&lbrack;bzoj2124&rsqb;等差子序列&lpar;hash&plus;树状数组&rpar;
我又来更博啦     2124: 等差子序列 Time Limit: 3 Sec  Memory Limit: 259 MBSubmit: 941  Solved: 348[Submit][Statu ...
ORACLE-RAC-11G-R2&lowbar;INSTALL
ORACLE 11.2.0.3 RAC INSTALL                                                                       20 ...
ASP&period;NET MVC DefaultModelBinder
转载自 Leo‘s Blog 看到很多ASP.NET MVC项目还在从request.querystring或者formContext里面获取数据,这实在是非常落后的做法.也有的项目建了大量的自定义的 ...
【转】linux服务器性能查看
转载自https://blog.csdn.net/achenyuan/article/details/78974729 1.1 cpu性能查看 1.查看物理cpu个数: cat /proc/cpuin ...
Activiti For Eclipse&lpar;Mars)插件配置
Activiti BPMN 2.0 designer : http://www.activiti.org/designer/update/
BZOJ3626 LNOI2014LCA(树链剖分&plus;主席树)
开店简化版. #include #include #include #include ...
qt 内置图标使用
QToolButton *button = new QToolButton(this); button->resize(100,30); button->setToolButtonStyl ...
&period;Net Core WebApi控制器接收原始请求正文内容
主要目标 在Asp.net Core控制器中,通过自定义格式化程序来映射自定义处理控制器中的“未知”内容. 简单案例 为了演示这个问题,我们用VS2017创建一个默认的Asp.net Core Web ...

背景：接口请求的时候如果是同步，那么有时业务逻辑处理时间很长，请求就会超时！

所以需要在接口请求过来时，就先响应，再去执行业务逻辑。


1.创建一个Controller类用来接收接口请求

@RestController

@RequestMapping("/test")

public class Controller {
private static Logger log = LoggerFactory.getLogger(WelfarepriceController.class);
//创建线程池
private static ScheduledExecutorService executor = Executors.newScheduledThreadPool(5)



@RequestMapping(value="init",method = RequestMethod.POST)
public AjaxResult init(@RequestBody String json){
AjaxResult result = new AjaxResult();


//方法加入到线程池中去执行
executor.execute(new ToServer(json)));
//返回响应结果

result.setRetcode(0);
result.setRetmsg("成功");

return result;
}


}



2.再建线程类

public class ToServer extends Thread {

    private String json;

    //需要什么参数就自己定义

    public ToServer(String json) {

        this.json = json;

    }

     /**

     * 执行定时请求

     */

    @Override

    public void run() {

         // 把run方法里的内容换成你要执行的内容               
  service.doService(json);      

    }

}

如果你是湖南的 欢迎加入 湖南人在深圳-Java群：557651502

前后端分离的开发模式中，或者与第三方接口交互，需要规范接口响应，下面是我在开发中的封装的一组响应实体类


响应实体父类， 父类中需要一个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);
	}
}

通过工具类简化后，基本上响应代码就只需要一行就可以了，大大简化了我们的代码。