在项目开发过程中，很难避免返回各种各样的结果，就会导致前端渲染时造成混乱，怎么统一返回呢？

编写R.java Object

  1. /**
  2.  * @Author Joker DJ
  3.  * @Date 2021/8/7 20:58
  4.  * @Version 1.0
  5.  */
  7. public class R {
  8.     /**
  9.      *标识返回状态
  10.      */
  11.     private Integer code;
  13.     /**
  14.      * 标识返回内容
  15.      */
  16.     private Object data;
  17.     /**
  18.      * 标识返回消息
  19.      */
  20.     private String message;
  23.     /**
  24.      * 成功返回
  25.      * @param data
  26.      * @return
  27.      */
  28.     public static R ok(Object data){
  29.         return new R(RHttpStatusEnum.SUCCESS.getCode(),data,RHttpStatusEnum.SUCCESS.getMessage());
  30.     }
  32.     /**
  33.      * 成功返回
  34.      * @param data
  35.      * @return
  36.      */
  37.     public static R ok(Object data,String message){
  38.         return new R(RHttpStatusEnum.SUCCESS.getCode(),data,message);
  39.     }
  41.     /**
  42.      * 失败返回
  43.      * @param rHttpStatusEnum
  44.      * @return
  45.      */
  46.     public static R error(RHttpStatusEnum rHttpStatusEnum){
  47.         return new R(rHttpStatusEnum.getCode(),null,rHttpStatusEnum.getMessage());
  48.     }
  49.     public static R error(Integer code,String message){
  50.         R r = new R();
  51.         r.code(code);
  52.         r.data(null);
  53.         r.message(message);
  54.         return r;
  55.     }
  59.     public R() {
  61.     }
  63.     public R(Integer code, Object data, String message) {
  64.         this.code = code;
  65.         this.data = data;
  66.         this.message = message;
  67.     }
  69.     public Integer getCode() {
  70.         return code;
  71.     }
  73.     public R code(Integer code) {
  74.         this.code = code;
  75.         return this;
  76.     }
  78.     public Object getData() {
  79.         return data;
  80.     }
  82.     public R data(Object data) {
  83.         this.data = data;
  84.         return this;
  85.     }
  87.     public String getMessage() {
  88.         return message;
  89.     }
  91.     public R message(String message) {
  92.         this.message = message;
  93.         return this;
  94.     }
  95. }
  97. 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697

编写R.java 泛型

  1. package com.dj.rvo.Vo;
  3. /**
  4.  * @Author Joker DJ
  5.  * @Date 2021/8/7 20:58
  6.  * @Version 1.0
  7.  */
  9. public class RT<T> {
  10.     /**
  11.      * 标识返回状态
  12.      */
  13.     private Integer code;
  15.     /**
  16.      * 标识返回内容
  17.      */
  18.     private T data;
  19.     /**
  20.      * 标识返回消息
  21.      */
  22.     private String message;
  25.     /**
  26.      * 成功返回
  27.      *
  28.      * @param data
  29.      * @return
  30.      */
  31.     public static <T> RT ok(T data) {
  32.         return new RT(RHttpStatusEnum.SUCCESS.getCode(), data, RHttpStatusEnum.SUCCESS.getMessage());
  33.     }
  35.     /**
  36.      * 成功返回
  37.      *
  38.      * @param data
  39.      * @return
  40.      */
  41.     public static <T> RT ok(T data, String message) {
  42.         return new RT(RHttpStatusEnum.SUCCESS.getCode(), data, message);
  43.     }
  45.     /**
  46.      * 失败返回
  47.      *
  48.      * @param rHttpStatusEnum
  49.      * @return
  50.      */
  51.     public static RT error(RHttpStatusEnum rHttpStatusEnum) {
  52.         return new RT(rHttpStatusEnum.getCode(), null, rHttpStatusEnum.getMessage());
  53.     }
  54.     public static RT error(Integer code,String message){
  55.         RT r = new RT();
  56.         r.code(code);
  57.         r.data(null);
  58.         r.message(message);
  59.         return r;
  60.     }
  62.     public RT() {
  64.     }
  66.     public RT(Integer code, T data, String message) {
  67.         this.code = code;
  68.         this.data = data;
  69.         this.message = message;
  70.     }
  72.     public Integer getCode() {
  73.         return code;
  74.     }
  76.     public RT code(Integer code) {
  77.         this.code = code;
  78.         return this;
  79.     }
  81.     public Object getData() {
  82.         return data;
  83.     }
  85.     public RT data(T data) {
  86.         this.data = data;
  87.         return this;
  88.     }
  90.     public String getMessage() {
  91.         return message;
  92.     }
  94.     public RT message(String message) {
  95.         this.message = message;
  96.         return this;
  97.     }
  98. }
  100. 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899

编写返回枚举 RHttpStatusEnum

  1. package com.dj.rvo.Vo;
  3. /**
  4.  * @Author Joker DJ
  5.  * @Date 2021/8/7 21:16
  6.  * @Version 1.0
  7.  */
  8. public enum RHttpStatusEnum {
  10.     SUCCESS(200,"success"),
  11.     HTTP_NOT_FOUND(404,"未找到相关内容"),
  12.     SERVER_ERROR( 500, "服务器忙，请稍后在试");
  13.     private final int code;
  14.     private final String message;
  15.     RHttpStatusEnum(Integer code,String message){
  16.         this.code=code;
  17.         this.message=message;
  18.     }
  20.     public int getCode() {
  21.         return code;
  22.     }
  24.     public String getMessage() {
  25.         return message;
  26.     }
  28. }
  31. 123456789101112131415161718192021222324252627282930

测试

  1. /**
  2.      * 返回错误信息
  3.      * @return
  4.      */
  5.     public R test1(){
  6.         return R.error(RHttpStatusEnum.HTTP_NOT_FOUND);
  7.     }
  9.     /**
  10.      * 返回成功信息
  11.      * @return
  12.      */
  13.     public R test2() {
  14.         return R.ok("成功");
  15.     }
  16.     public R test3() {
  17.         return R.ok("数据","信息");
  18.     }
  19. 123456789101112131415161718

问题：如果都返回R类 太强制了；通过通知来封装R类

编写 ResultResponseHandler

  1. package com.dj.rvo.Handler;
  3. import com.dj.rvo.Utils.JsonUtil;
  4. import com.dj.rvo.Vo.R;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.core.MethodParameter;
  7. import org.springframework.http.MediaType;
  8. import org.springframework.http.converter.HttpMessageConverter;
  9. import org.springframework.http.server.ServerHttpRequest;
  10. import org.springframework.http.server.ServerHttpResponse;
  11. import org.springframework.web.bind.annotation.ControllerAdvice;
  12. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
  14. /**
  15.  * @Author Joker DJ
  16.  * @Date 2021/8/7 21:53
  17.  * @Version 1.0
  18.  */
  19. @ControllerAdvice(basePackages = "com.dj.rvo.Controller")// 绑定的Controller包的权限定名 例如:com.dj.Controller
  20. public class ResultResponseHandler implements ResponseBodyAdvice<Object> {
  21.     @Override
  22.     public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
  23.         return true;
  24.     }
  26.     @Override
  27.     public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
  28.         // 对请求的结果在这里统一返回和处理
  29.         if (o instanceof ErrorHandler) {
  30.             // 1、如果返回的结果是一个异常的结果，就把异常返回的结构数据倒腾到R.fail里面即可
  31.             ErrorHandler errorHandler = (ErrorHandler) o;
  32.             return R.error(errorHandler.getStatus(), errorHandler.getMessage());
  33.         } else if (o instanceof String) {
  34.             try {
  35.                 // 2、因为springmvc数据转换器对String是有特殊处理 StringHttpMessageConverter
  36.                 ObjectMapper objectMapper = new ObjectMapper();
  37.                 R r = R.ok(o);
  38.                 return objectMapper.writeValueAsString(r);
  39.             }catch ( Exception ex){
  40.                 ex.printStackTrace();
  41.             }
  42.         }
  43.         return R.ok(o);
  44.     }
  45. }
  48. 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647

编写自定义异常返回ErrorHandler

  1. package com.dj.rvo.Handler;
  3. import com.dj.rvo.Vo.RHttpStatusEnum;
  4. /**
  5.  *
  6.  * 功能描述: 异常返回
  7.  *
  8.  * @param:
  9.  * @return:
  10.  * @auther: Joker
  11.  * @date: 2021/8/7 22:25
  12.  */
  13. public class ErrorHandler {
  14.     // ErrorHandler === R 答案：不想破坏R类。
  15.     // 异常的状态码，从枚举中获得
  16.     private Integer status;
  17.     // 异常的消息，写用户看得懂的异常，从枚举中得到
  18.     private String message;
  19.     // 异常的名字
  20.     private String exception;
  22.     /**
  23.      * 对异常处理进行统一封装
  24.      *
  25.      * @param resultCodeEnum 异常枚举
  26.      * @param throwable 出现异常
  27.      * @param message 异常的消息 null /by zero
  28.      * @return
  29.      */
  30.     public static ErrorHandler fail(RHttpStatusEnum resultCodeEnum, Throwable throwable, String message) {
  31.         ErrorHandler errorHandler = ErrorHandler.fail(resultCodeEnum, throwable);
  32.         errorHandler.setMessage(message);
  33.         return errorHandler;
  34.     }
  36.     /**
  37.      * 对异常枚举进行封装
  38.      *
  39.      * @param resultCodeEnum
  40.      * @param throwable
  41.      * @return
  42.      */
  43.     public static ErrorHandler fail(RHttpStatusEnum resultCodeEnum, Throwable throwable) {
  44.         ErrorHandler errorHandler = new ErrorHandler();
  45.         errorHandler.setMessage(resultCodeEnum.getMessage());
  46.         errorHandler.setStatus(resultCodeEnum.getCode());
  47.         errorHandler.setException(throwable.getClass().getName());
  48.         return errorHandler;
  49.     }
  51.     public Integer getStatus() {
  52.         return status;
  53.     }
  55.     public void setStatus(Integer status) {
  56.         this.status = status;
  57.     }
  59.     public String getMessage() {
  60.         return message;
  61.     }
  63.     public void setMessage(String message) {
  64.         this.message = message;
  65.     }
  67.     public String getException() {
  68.         return exception;
  69.     }
  71.     public void setException(String exception) {
  72.         this.exception = exception;
  73.     }
  74. }
  75. 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374

编写异常通知类 GlobalRestExceptionHandler

  1. package com.dj.rvo.Handler;
  3. import com.dj.rvo.Vo.RHttpStatusEnum;
  4. import com.fasterxml.jackson.core.JsonProcessingException;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.validation.FieldError;
  7. import org.springframework.web.bind.MethodArgumentNotValidException;
  8. import org.springframework.web.bind.annotation.ExceptionHandler;
  9. import org.springframework.web.bind.annotation.RestControllerAdvice;
  11. import javax.servlet.http.HttpServletRequest;
  12. import java.util.ArrayList;
  13. import java.util.HashMap;
  14. import java.util.List;
  15. import java.util.Map;
  17. /**
  18.  *
  19.  * 功能描述: 统一异常处理
  20.  *
  21.  * @param:
  22.  * @return:
  23.  * @auther: Joker
  24.  * @date: 2021/8/7 22:30
  25.  */
  26. @RestControllerAdvice
  27. public class GlobalRestExceptionHandler {
  29.     /**
  30.      * 对服务器端出现500异常进行统一处理
  31.      * 缺点：不明确
  32.      * 场景：
  33.      */
  34.     @ExceptionHandler(Throwable.class)
  35.     public ErrorHandler makeExcepton(Throwable e, HttpServletRequest request) {
  36.         ErrorHandler errorHandler = ErrorHandler.fail(RHttpStatusEnum.SERVER_ERROR, e);
  37.         return errorHandler;
  38.     }
  40.     /**
  41.      * 对服务器端出现500异常进行统一处理
  42.      * 缺点：明确异常信息
  43.      */
  44.     @ExceptionHandler(BusinessException.class)
  45.     public ErrorHandler makeOrderException(BusinessException businessException, HttpServletRequest request) {
  46.         ErrorHandler errorHandler = new ErrorHandler();
  47.         errorHandler.setMessage(businessException.getMessage());
  48.         errorHandler.setStatus(businessException.getCode());
  49.         return errorHandler;
  50.     }
  52.     /**
  53.      * 对验证的统一异常进行统一处理
  54.      */
  55.     @ExceptionHandler(MethodArgumentNotValidException.class)
  56.     public ErrorHandler handlerValiator(MethodArgumentNotValidException e, HttpServletRequest request) throws JsonProcessingException {
  57.         // 1: 从MethodArgumentNotValidException提取验证失败的所有的信息。返回一个List<FieldError>
  58.         List<FieldError> fieldErrors = e.getBindingResult().getFieldErrors();
  59.         // 2: 把fieldErrors中，需要的部分提出出来进行返回
  60.         List<Map<String, String>> mapList = toValidatorMsg(fieldErrors);
  61.         // 3: 把需要的异常信息转换成json进行返回
  62.         ObjectMapper objectMapper = new ObjectMapper();
  63.         String mapJson = objectMapper.writeValueAsString(mapList);
  64.         ErrorHandler errorHandler = ErrorHandler.fail(RHttpStatusEnum.SERVER_ERROR, e, mapJson);
  65.         return errorHandler;
  66.     }
  69.     /**
  70.      * 对验证异常进行统一处理提取需要的部分
  71.      *
  72.      * @param fieldErrorList
  73.      * @return
  74.      */
  75.     private List<Map<String, String>> toValidatorMsg(List<FieldError> fieldErrorList) {
  76.         List<Map<String, String>> mapList = new ArrayList<>();
  77.         // 循环提取
  78.         for (FieldError fieldError : fieldErrorList) {
  79.             Map<String, String> map = new HashMap<>();
  80.             // 获取验证失败的属性
  81.             map.put("field", fieldError.getField());
  82.             // 获取验证失败的的提示信息
  83.             map.put("msg", fieldError.getDefaultMessage());
  85.             mapList.add(map);
  86.         }
  87.         return mapList;
  88.     }
  91. }
  92. 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091

自定义异常 BusinessException

  1. package com.dj.rvo.Handler;
  3. import com.dj.rvo.Vo.RHttpStatusEnum;
  4. /**
  5.  *
  6.  * 功能描述: 
  7.  *
  8.  * @param: 
  9.  * @return: 
  10.  * @auther: Joker
  11.  * @date: 2021/8/7 22:47
  12.  */
  13. public class BusinessException extends RuntimeException {
  14.     private Integer code;
  15.     private String message;
  16.     public BusinessException(RHttpStatusEnum resultCodeEnum) {
  17.         this.code = resultCodeEnum.getCode();
  18.         this.message = resultCodeEnum.getMessage();
  19.     }
  20.     public BusinessException(Integer code, String message) {
  21.         this.code = code;
  22.         this.message = message;
  23.     }
  25.     public Integer getCode() {
  26.         return code;
  27.     }
  29.     public void setCode(Integer code) {
  30.         this.code = code;
  31.     }
  33.     public String getMessage() {
  34.         return message;
  35.     }
  37.     public void setMessage(String message) {
  38.         this.message = message;
  39.     }
  40. }
  41. 1234567891011121314151617181920212223242526272829303132333435363738394041

测试

  1. /**
  2.  * @Author Joker DJ
  3.  * @Date 2021/8/7 22:45
  4.  * @Version 1.0
  5.  */
  6. @RestController
  7. public class Test {
  8.     @RequestMapping("/test1")
  9.     public Map<String,Object> test1(){
  10.         Map<String, Object> hashMap = new HashMap<>();
  11.         hashMap.put("username","JokerDJ");
  12.         return hashMap;
  13.     }
  15.     @RequestMapping("/test2")
  16.     public String test2(){
  17.         boolean flag = false;
  18.         System.out.println(1/0);
  19.         return "成功";
  20.     }
  22.     @RequestMapping("/test3")
  23.     public String test3(){
  24.         boolean flag = false;
  25.         if(!flag){
  26.             throw new BusinessException(500,"系统异常");
  27.         }
  28.         return "成功";
  29.     }
  30. }
  33. 1234567891011121314151617181920212223242526272829303132

相关工具

  1. package com.dj.rvo.Utils;
  3. import org.codehaus.jackson.map.DeserializationConfig;
  4. import org.codehaus.jackson.map.ObjectMapper;
  5. import org.codehaus.jackson.map.SerializationConfig;
  6. import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
  7. import org.codehaus.jackson.type.JavaType;
  8. import org.codehaus.jackson.type.TypeReference;
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11. import org.springframework.util.StringUtils;
  13. import java.text.SimpleDateFormat;
  15. /**
  16.  * by mofeng
  17.  * <dependency>
  18.  * <groupId>com.fasterxml.jackson.dataformat</groupId>
  19.  * <artifactId>jackson-dataformat-avro</artifactId>
  20.  * </dependency>
  21.  *
  22.  * <dependency>
  23.  * <groupId>org.apache.commons</groupId>
  24.  * <artifactId>commons-lang3</artifactId>
  25.  * <version>3.6</version>
  26.  * </dependency>
  27.  */
  28. public class JsonUtil {
  30.     private static ObjectMapper objectMapper = new ObjectMapper();
  31.     private static Logger log = LoggerFactory.getLogger(JsonUtil.class);
  33.     static {
  34.         // 对象的所有字段全部列入
  35.         objectMapper.setSerializationInclusion(Inclusion.ALWAYS);
  37.         // 取消默认转换timestamps形式
  38.         objectMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, false);
  40.         // 忽略空Bean转json的错误
  41.         objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
  43.         // 所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
  44.         objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
  46.         // 忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
  47.         objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  49.         // 精度的转换问题
  50.         objectMapper.configure(DeserializationConfig.Feature.USE_BIG_DECIMAL_FOR_FLOATS, true);
  52.         objectMapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
  53.     }
  56.     public static <T> String obj2String(T obj) {
  57.         if (obj == null) {
  58.             return null;
  59.         }
  60.         try {
  61.             return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
  62.         } catch (Exception e) {
  63.             log.warn("Parse Object to String error", e);
  64.             return null;
  65.         }
  66.     }
  68.     public static <T> String obj2StringPretty(T obj) {
  69.         if (obj == null) {
  70.             return null;
  71.         }
  72.         try {
  73.             return obj instanceof String ? (String) obj
  74.                     : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
  75.         } catch (Exception e) {
  76.             log.warn("Parse Object to String error", e);
  77.             return null;
  78.         }
  79.     }
  81.     public static <T> T string2Obj(String str, Class<T> clazz) {
  82.         if (StringUtils.isEmpty(str) || clazz == null) {
  83.             return null;
  84.         }
  86.         try {
  87.             return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
  88.         } catch (Exception e) {
  89.             log.warn("Parse String to Object error", e);
  90.             return null;
  91.         }
  92.     }
  94.     public static <T> T string2Obj(String str, TypeReference<T> typeReference) {
  95.         if (StringUtils.isEmpty(str) || typeReference == null) {
  96.             return null;
  97.         }
  98.         try {
  99.             return (T) (typeReference.getType().equals(String.class) ? str
  100.                     : objectMapper.readValue(str, typeReference));
  101.         } catch (Exception e) {
  102.             log.warn("Parse String to Object error", e);
  103.             return null;
  104.         }
  105.     }
  107.     public static <T> T string2Obj(String str, Class<?> collectionClass, Class<?>... elementClasses) {
  108.         JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
  109.         try {
  110.             return objectMapper.readValue(str, javaType);
  111.         } catch (Exception e) {
  112.             log.warn("Parse String to Object error", e);
  113.             return null;
  114.         }
  115.     }
  117.     public static void main(String[] args) {
  118.         //String json = "{\"name\":\"Geely\",\"color\":\"blue\",\"id\":1274670369972846594}";
  119.         /*
  120.          * User user = new User(); user.setId(2);
  121.          * user.setAccount("geely@happymmall.com"); user.setCreateTime(new Date());
  122.          * String userJsonPretty = JsonUtil.obj2StringPretty(user);
  123.          * log.info("userJson:{}",userJsonPretty);
  124.          *
  125.          *
  126.          * User user2 = JsonUtil.string2Obj(userJsonPretty, User.class);
  127.          * System.out.println(user2);
  128.          */
  130.     }
  132. }

分界

为什么使用

项目中我们会将响应封装成JSON返回，一般我们会将所有接口的数据格式统一， 使前端对数据的操作更一致、轻松。 一般情况下，统一返回数据格式没有固定的格式，只要能描述清楚返回的数据状态以及要返回的具体数 据就可以。但是一般会包含状态码、返回消息、数据这几部分内容

一. 统一返回数据格式

  1. {
  2.  "success": 布尔, //响应是否成功
  3.  "code": 数字, //响应码
  4.  "message": 字符串, //返回消息
  5.  "data": HashMap //返回数据，放在键值对中
  6. }
  7. 123456

二 . 创建统一结果返回类

  • 抽取出来作为公共部分

1. 创建公共部分模块Common

2. 创建接口定义返回码 也可使用枚举 也可以不定义,直接写入

  1. public interface ResultCode {
  2.      public static Integer SUCCESS = 20000;
  3.      public static Integer ERROR = 20001;
  4. }
  5. 1234

3. 创建结果类

  1. //统一返回结果的类
  2. @Data
  3. public class R {
  5.     @ApiModelProperty(value = "是否成功")
  6.     private Boolean success;
  8.     @ApiModelProperty(value = "返回码")
  9.     private Integer code;
  11.     @ApiModelProperty(value = "返回消息")
  12.     private String message;
  14.     @ApiModelProperty(value = "返回数据")
  15.     private Map<String, Object> data = new HashMap<String, Object>();
  17.     //把构造方法私有   不让别人new该类
  18.     private R() {}
  19.     //实现链式编程
  20.     //R.ok().code().message().data();
  22.     //成功静态方法
  23.     public static R ok() {
  24.         R r = new R();
  25.         r.setSuccess(true);
  26.         r.setCode(ResultCode.SUCCESS);
  27.         r.setMessage("成功");
  28.         return r;
  29.     }
  31.     //失败静态方法
  32.     public static R error() {
  33.         R r = new R();
  34.         r.setSuccess(false);
  35.         r.setCode(ResultCode.ERROR);
  36.         r.setMessage("失败");
  37.         return r;
  38.     }
  40.     public R success(Boolean success){
  41.         this.setSuccess(success);
  42.         return this;   //返回this  实现链式编程
  43.     }
  45.     //实现链式编程
  46.     //R.ok().code().message().data();
  48.     public R message(String message){
  49.         this.setMessage(message);
  50.         return this;
  51.     }
  53.     public R code(Integer code){
  54.         this.setCode(code);
  55.         return this;
  56.     }
  58.     public R data(String key, Object value){
  59.         this.data.put(key, value);
  60.         return this;
  61.     }
  63.     public R data(Map<String, Object> map){
  64.         this.setData(map);
  65.         return this;
  66.     }
  67. }
  69. 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768

4. 项目结构

image-20210712223051406

三. 使用

1.在使用的包中先导依赖

2.接口方法返回结果都改为R(导包时记得引对)

  1. // 1 查询所有数据
  2.     @GetMapping("findAll")
  3.     public R findAllTeacher(){
  4.         //调用service的方法实现查询所有的操作
  5.         List<EduTeacher> list = teacherService.list(null);
  6.         return R.ok().data("items",list); //链式编程
  7.     }
  8. // 2. 逻辑删除方法
  9.     @DeleteMapping("{id}")
  10.     public R removeTeacher(@PathVariable String id){
  11.         boolean flag = teacherService.removeById(id);
  12.         if(flag){
  13.             return R.ok();
  14.         }else
  15.             return R.error();
  16.     }