关于Controller 层返回值的公共包装类的问题
短信预约 -IT技能 免费直播动态提醒
场景：在微服务中，一般返回数据都会有个返回码、返回信息和返回消息体，但是每次返回时候调用或者是封装，太过麻烦，有没有什么办法不用每次都封装呢？
答案是有的。
返回值对象 ResponseData
package com.study.auth.comm;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.annotation.JSONField;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.io.Serializable;
public final class ResponseData<T> implements Serializable {
private static final long serialVersionUID = 7824278330465676943L;
private static final String SUCCESS_CODE = "1000";
private static final String SUCCESS_MSG = "success";
@JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 1)
private String code;
@JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 2)
private String msg;
@JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 10)
private T data;
public static ResponseData success() {
return initData(SUCCESS_CODE, SUCCESS_MSG, null);
}
public static ResponseData error(String code) {
String msg = PropertiesReaderUtil.getProperty(code, null);
return initData(code, msg, null);
}
public static ResponseData error(String code, String msg) {
return initData(code, msg, null);
}
public static <T> ResponseData success(T t) {
return initData(SUCCESS_CODE, SUCCESS_MSG, t);
}
public static <T> ResponseData errorData(String code, T data) {
String msg = PropertiesReaderUtil.getProperty(code, null);
return initData(code, msg, data);
}
public static <T> ResponseData errorData(String code, String msg, T data) {
return initData(code, msg, data);
}
private static <T> ResponseData initData(String code, String msg, T t) {
ResponseData data = new ResponseData(SUCCESS_CODE);
if (!isBlank(msg)) {
data.setMsg(msg);
}
if (!isBlank(code)) {
data.setCode(code);
}
if (t != null) {
data.setData(t);
}
return data;
}
private static boolean isBlank(CharSequence cs) {
int strLen;
if (cs != null && (strLen = cs.length()) != 0) {
for (int i = 0; i < strLen; ++i) {
if (!Character.isWhitespace(cs.charAt(i))) {
return false;
}
}
return true;
} else {
return true;
}
}
public ResponseData() {
}
public ResponseData(String code) {
this.code = code;
}
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;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
@Override
public String toString() {
return JSON.toJSONString(this);
}
}
如上图的包装，还是太繁琐了。
装饰者模式使用-增强类InitializingAdviceDecorator通过实现InitializingBean和装饰者模式对Controller层的返回值进行包装，大致思路：
通过RequestMappingHandlerAdapter获取所有的返回值处理对象HandlerMethodReturnValueHandler创建一个新的集合存储上一步获取的集合（因为上一步的结果是unmodifiableList类型的）遍历该集合找到HandlerMethodReturnValueHandler对象，将这个位置的handler替换程自定义的handler将新获到的集合重新设置到RequestMappingHandlerAdapter的setReturnValueHandlers方法中
package com.study.auth.config;
import com.study.auth.comm.ResponseData;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.MethodParameter;
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;
@Configuration
public class InitializingAdviceDecorator implements InitializingBean {
@Autowired
private RequestMappingHandlerAdapter adapter;
@Override
public void afterPropertiesSet() {
//获取所有的handler对象
List<HandlerMethodReturnValueHandler> returnValueHandlers = adapter.getReturnValueHandlers();
//因为上面返回的是unmodifiableList，所以需要新建list处理
List<HandlerMethodReturnValueHandler> handlers = new ArrayList(returnValueHandlers);
this.decorateHandlers(handlers);
//将增强的返回值回写回去
adapter.setReturnValueHandlers(handlers);
}
private void decorateHandlers(List<HandlerMethodReturnValueHandler> handlers) {
for (HandlerMethodReturnValueHandler handler : handlers) {
if (handler instanceof RequestResponseBodyMethodProcessor) {
//找到返回值的handler并将起包装成自定义的handler
ControllerReturnValueHandler decorator = new ControllerReturnValueHandler((RequestResponseBodyMethodProcessor) handler);
int index = handlers.indexOf(handler);
handlers.set(index, decorator);
break;
}
}
}
private class ControllerReturnValueHandler implements HandlerMethodReturnValueHandler {
//持有一个被装饰者对象
private HandlerMethodReturnValueHandler handler;
ControllerReturnValueHandler(RequestResponseBodyMethodProcessor handler) {
this.handler = handler;
}
@Override
public boolean supportsReturnType(MethodParameter returnType) {
return true;
}
@Override
public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
//如果已经封装了结构体就直接放行
if (returnValue instanceof ResponseData) {
handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
return;
}
//正常返回success
ResponseData success = ResponseData.success(returnValue);
handler.handleReturnValue(success, returnType, mavContainer, webRequest);
}
}
}配置文件读取类PropertiesReaderUtil
package com.study.auth.comm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Properties;
public final class PropertiesReaderUtil {
private static final String ENCODING = "UTF-8";
private static final Logger logger = LoggerFactory.getLogger(PropertiesReaderUtil.class);
private static Properties propsZH;
private static Properties propsCN;
private static String name = null;
static {
//加载英文
//loadProps(false);
//加载中文
loadProps(true);
}
synchronized static private void loadProps(boolean isZh) {
logger.debug("start loading properties");
InputStream in = null;
if (isZh) {
propsZH = new Properties();
name = "properties/message_ZH.properties";
in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream(name);
} else {
propsCN = new Properties();
name = "properties/message_EN.properties";
in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream(name);
}
try {
if (isZh) {
propsZH.load(new InputStreamReader(in, ENCODING));
} else {
propsCN.load(new InputStreamReader(in, ENCODING));
}
} catch (Exception e) {
logger.debug("loading properties error :{}", e);
} finally {
try {
if (null != in) {
in.close();
}
} catch (IOException e) {
logger.debug("closing properties io error :{}", e);
}
}
}
public static String getProperty(String key) {
return getPropertyZH(key);
}
public static String getProperty(String key, String defaultValue) {
return getPropertyZH(key, defaultValue);
}
public static String getPropertyZH(String key) {
if (null == propsZH) {
loadProps(true);
}
return propsZH.getProperty(key);
}
public static String getPropertyZH(String key, String defaultValue) {
if (null == propsZH) {
loadProps(true);
}
return propsZH.getProperty(key, defaultValue);
}
public static String getPropertyCN(String key) {
if (null == propsCN) {
loadProps(false);
}
return propsCN.getProperty(key);
}
public static String getPropertyCN(String key, String defaultValue) {
if (null == propsCN) {
loadProps(false);
}
return propsCN.getProperty(key, defaultValue);
}
}配置文件message_ZH.properties路径为：properties/message_ZH.properties
也可添加国家化英文或者是其他语言配置
1001=用户未登录
#====非业务返回码=========
1100=服务器内部错误
1101=空指针异常
1102=数据类型转换异常
1103=IO异常
1104=该方法找不到异常
1105=数组越界异常
1106=请求体缺失异常
1107=类型匹配异常
1108=请求参数缺失异常
1109=请求方法不支持异常
1110=请求头类型不支持异常
1111=参数解析异常
1112=必要参数不能为空
#=======================
统一异常捕捉类RestfulExceptionHandler此时，基本能保证增强Controller层的返回值了，如果有需要的话，可能通过@RestControllerAdvice注解，针对抛出的异常使用返回值对象进行包装
package com.study.auth.exception;
import com.alibaba.fastjson.JSONException;
import com.study.auth.comm.PropertiesReaderUtil;
import com.study.auth.comm.ResponseData;
import com.study.auth.constant.CommonConstant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.TypeMismatchException;
import org.springframework.boot.json.JsonParseException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.security.auth.login.AccountException;
import java.io.IOException;
import java.sql.SQLException;
@Slf4j
@RestControllerAdvice
public class RestfulExceptionHandler {
private ResponseData responseData(String code, Exception e) {
log.error("异常代码:{},异常描述:{},异常堆栈:", code, PropertiesReaderUtil.getProperty(code), e);
return ResponseData.error(code);
}
private ResponseData<String> responseData(String code, String message, Exception e) {
log.error("异常代码:{},异常描述:{},异常堆栈:", code, message, e);
return ResponseData.error(code, message);
}
@ExceptionHandler(Exception.class)
public ResponseData runtimeExceptionHandler(Exception e) {
return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e);
}
@ExceptionHandler(SQLException.class)
public ResponseData<String> sqlException(SQLException e) {
return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
}
@ExceptionHandler(CustomMessageException.class)
public ResponseData<String> customerMessageException(CustomMessageException e) {
return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
}
@ExceptionHandler(AccountException.class)
public ResponseData<String> accountException(AccountException e) {
return responseData(e.getMessage(), e);
}
//---------------------------------------jdk/spring自带的异常----------------------------------
@ExceptionHandler(IllegalArgumentException.class)
public ResponseData<String> illegalArgumentException(IllegalArgumentException e) {
return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
}
@ResponseStatus
@ExceptionHandler(NullPointerException.class)
public ResponseData nullPointerExceptionHandler(NullPointerException e) {
return responseData(CommonConstant.EX_NULL_POINTER_EXCEPTION, e);
}
@ExceptionHandler(ClassCastException.class)
public ResponseData classCastExceptionHandler(ClassCastException e) {
return responseData(CommonConstant.EX_CLASS_CAST_EXCEPTION, e);
}
@ExceptionHandler(IOException.class)
public ResponseData iOExceptionHandler(IOException e) {
return responseData(CommonConstant.EX_IO_EXCEPTION, e);
}
@ExceptionHandler(NoSuchMethodException.class)
public ResponseData noSuchMethodExceptionHandler(NoSuchMethodException e) {
return responseData(CommonConstant.EX_NO_SUCH_METHOD_EXCEPTION, e);
}
@ExceptionHandler(IndexOutOfBoundsException.class)
public ResponseData indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException e) {
return responseData(CommonConstant.EX_INDEX_OUT_OF_BOUNDS_EXCEPTION, e);
}
@ExceptionHandler({HttpMessageNotReadableException.class})
public ResponseData requestNotReadable(HttpMessageNotReadableException e) {
return responseData(CommonConstant.EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION, e);
}
@ExceptionHandler({TypeMismatchException.class})
public ResponseData requestTypeMismatch(TypeMismatchException e) {
return responseData(CommonConstant.EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION, e);
}
@ExceptionHandler({HttpRequestMethodNotSupportedException.class})
public ResponseData methodNotSupported(HttpRequestMethodNotSupportedException e) {
return responseData(CommonConstant.EX_HTTP_REQUEST_METHOD_NOT_SUPPORTED_EXCEPTION, e);
}
@ExceptionHandler({HttpMediaTypeNotSupportedException.class})
public ResponseData mediaTypeNotAcceptable(HttpMediaTypeNotSupportedException e) {
return responseData(CommonConstant.EX_HTTP_MEDIA_TYPE_NOT_ACCEPTABLE_EXCEPTION, e);
}
@ExceptionHandler(JSONException.class)
public ResponseData runtimeExceptionHandler(JSONException e) {
return responseData(CommonConstant.PARAMS_PARSE_EXCEPTION, e);
}
@ExceptionHandler(JsonParseException.class)
public ResponseData runtimeExceptionHandler(JsonParseException e) {
return responseData(CommonConstant.PARAMS_PARSE_EXCEPTION, e);
}
@ExceptionHandler({MissingServletRequestParameterException.class})
public ResponseData requestMissingServletRequest(MissingServletRequestParameterException e) {
return responseData(CommonConstant.EX_MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION, e);
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseData exceptionHandler(MethodArgumentNotValidException e) {
return responseData(CommonConstant.PARAMS_IS_NULL, e);
}
}常量类 CommonConstant
package com.study.auth.constant;
public final class CommonConstant {
public static final String C_CURRENT_ACCOUNT = "current_account";
public static final String EX_NO_TOKEN_EXCEPTION = "1001";
//--------------------------------非业务返回码---------------------------------------
public static final String EX_RUN_TIME_EXCEPTION = "1100";
public static final String EX_NULL_POINTER_EXCEPTION = "1101";
public static final String EX_CLASS_CAST_EXCEPTION = "1102";
public static final String EX_IO_EXCEPTION = "1103";
public static final String EX_NO_SUCH_METHOD_EXCEPTION = "1104";
public static final String EX_INDEX_OUT_OF_BOUNDS_EXCEPTION = "1105";
public static final String EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION = "1106";
public static final String EX_TYPE_MISMATCH_EXCEPTION = "1107";
public static final String EX_MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION = "1108";
public static final String EX_HTTP_REQUEST_METHOD_NOT_SUPPORTED_EXCEPTION = "1109";
public static final String EX_HTTP_MEDIA_TYPE_NOT_ACCEPTABLE_EXCEPTION = "1110";
public static final String PARAMS_PARSE_EXCEPTION = "1111";
public static final String PARAMS_IS_NULL = "1112";
//-----------------------------------------------------------------------------------
}自定义异常类 CustomMessageException
package com.study.auth.exception;
public class CustomMessageException extends RuntimeException {
public CustomMessageException() {
super();
}
public CustomMessageException(String message) {
super(message);
}
public CustomMessageException(String message, Throwable cause) {
super(message, cause);
}
public CustomMessageException(Throwable cause) {
super(cause);
}
protected CustomMessageException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}所需依赖因为使用了阿里的fastJson工具类还需要进入该类的依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.58</version>
</dependency>至此，可以愉快的使用该返回值的增强类了，在为服务中，还以将该代码重构到comm中，供多个服务共同使用，避免重复早轮子
到此这篇关于关于Controller 层返回值的公共包装类的问题的文章就介绍到这了,更多相关Controller 层返回值包装类内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！
免责声明：
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
