Macula Boot Starter Web

<dependency>
   <groupId>dev.macula.boot</groupId>
   <artifactId>macula-boot-starter-web</artifactId>
   <version>${macula.version}</version>
</dependency> 

macula:
  web:
    exception-advice: true  # 统一异常处理器，默认true
    response-advice: true   # 统一响应处理器，默认true

{
  "success": false,
  "code": "10001",
  "msg": "异常说明",
  "cause": "具体的异常信息",
  "data": null
}

public class BizException extends MaculaException {

   private String code;
   private String msg;

   public BizException(ResultCode resultCode, String exceptionMessage) {
      this(resultCode.getCode(), resultCode.getMsg(), exceptionMessage);
   }

   public BizException(String code, String msg, String exceptionMessage) {
      // message用于用户设置抛出错误详情，例如：当前价格-5，小于0
      super(exceptionMessage);
      this.code = code;
      this.msg = msg;
   }

   public BizException(String exceptionMessage) {
      this(ApiResultCode.BIZ_ERROR, exceptionMessage);
   }

   public String getCode() {
      return this.code;
   }

   public String getMsg() {
      return this.msg;
   }
}

@Data
public class Result<T> implements Serializable {
   private boolean success;
   private String code;
   private String msg;
   private String cause;
   private T data;
}

public interface ResultCode {
   /**
    * 返回码
    */
   String getCode();

   /**
    * 返回消息
    */
   String getMsg();
}

@RestController
@AllArgsConstructor
@RequestMapping("/api/v1/consumer")
public class ConsumerController {

   @Autowired
   private Provider1Service provider1Service;

   @Autowired
   private GapiService gapiService;

   @Autowired
   private IpaasService ipaasService;

   @GetMapping("/echo")
   @NotControllerResponseAdvice
   // 该接口直接返回String
   public String echo() {
      return provider1Service.echo("consumer");
   }

   @PostMapping("/user")
   // 该接口返回的JSON是{sucess:true, code:xxx, msg: xxx, data: {UserResult}}
   public UserResult getUser() {
      return provider1Service.getUser();
   }
}

@Override public void addFormatters(FormatterRegistry registry){
        // 默认String没有办法转为java.util.Date类型
        registry.addConverter(new Converter<String, Date>(){
@Override public Date convert(String source){
        return DateUtil.parse(source.trim()).toJdkDate();
        }
        });

        DateTimeFormatterRegistrar registrar=new DateTimeFormatterRegistrar();
        registrar.setUseIsoFormat(true);
        registrar.registerFormatters(registry);
        }

enum ISO {
   /**
    * The most common ISO Date Format {@code yyyy-MM-dd} &mdash; for example,
    * "2000-10-31".
    */
   DATE,

   /**
    * The most common ISO Time Format {@code HH:mm:ss.SSSXXX} &mdash; for example,
    * "01:30:00.000-05:00".
    */
   TIME,

   /**
    * The most common ISO Date Time Format {@code yyyy-MM-dd'T'HH:mm:ss.SSSXXX}
    * &mdash; for example, "2000-10-31T01:30:00.000-05:00".
    */
   DATE_TIME
}

spring:
  jackson:
     date-format: yyyy-MM-dd HH:mm:ss        # 该配置只会影响java.util.Date类型

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") private LocalDateTime createTime;

// 转为LocalDateTime需要先把ZondeDateTime转为需要的时区，直接toLocalDateTime是没有换算时区的
LocalDateTime ldt=zdt.withZoneSameInstant(ZoneId.systemDefault()).toLocalDateTime();

public class UserVO {
   @NotNull(message = "age 不能为空")
   private Integer age;
}

// 注意这里的BindingResult参数可以不添加，如果不添加则validator有问题会抛出异常，由全局异常拦截器统一处理
public String add1(@Validated UserVO userVO,BindingResult result){
        List<FieldError> fieldErrors=result.getFieldErrors();
        if(!fieldErrors.isEmpty()){
        return fieldErrors.get(0).getDefaultMessage();
        }
        return"OK";
        }

public interface Update extends Default{
}
public class UserVO {
    @NotBlank(message = "name 不能为空",groups = Update.class)
    private String name;
    // 省略其他代码...
}
@PostMapping("update")
public ResultInfo update(@Validated({Update.class}) UserVO userVO) {
    return new ResultInfo().success(userVO);
}

/**
 * Default Jakarta Bean Validation group.
 * <p>
 * Unless a list of groups is explicitly defined:
 * <ul>
 *     <li>constraints belong to the {@code Default} group</li>
 *     <li>validation applies to the {@code Default} group</li>
 * </ul>
 * Most structural constraints should belong to the default group.
 *
 * @author Emmanuel Bernard
 */
public interface Default {
}

{
    "status": 400,
    "message": "客户端请求参数错误",
    "response": [
        "name 不能为空",
        "age 不能为空",
        "email 不能为空"
    ]
}

{
    "status": 400,
    "message": "客户端请求参数错误",
    "response": [
        "name 不能为空"
    ]
}

public class OrderVO {
   @NotNull
   private Long id;
   @NotBlank(message = "itemName 不能为空")
   private String itemName;
   // 省略其他代码...
}

public class UserVO {
   @NotBlank(message = "name 不能为空", groups = Update.class)
   private String name;
   //需要递归校验的OrderVO
   @Valid
   private OrderVO orderVO;
   // 省略其他代码...
}   

@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {HaveNoBlankValidator.class})// 标明由哪个类执行校验逻辑
public @interface HaveNoBlank {
    
    // 校验出错时默认返回的消息
    String message() default "字符串中不能含有空格";

    Class<?>[] groups() default { };

    Class<? extends Payload>[] payload() default { };

    /**
     * 同一个元素上指定多个该注解时使用
     */
    @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
    @Retention(RUNTIME)
    @Documented
    public @interface List {
        NotBlank[] value();
    }
}
public class HaveNoBlankValidator implements ConstraintValidator<HaveNoBlank, String> {
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        // null 不做检验
        if (value == null) {
            return true;
        }
        if (value.contains(" ")) {
            // 校验失败
            return false;
        }
        // 校验成功
        return true;
    }
}

@Data
public class DemoDto {

   @NotEmpty
   private String password;

   @Length(min = 5, max = 25, message = "{key.length}")
   private String key;

   @Pattern(regexp = "[012]", message = "无效的状态标志")
   private String state;

   @Sensitive(value = Sensitive.Type.MOBILE)
   private String mobile;

}

/**
 * {@code Sensitvie} 脱敏的JSON注解
 *
 * @author rain
 * @since 2022/7/28 23:48
 */
@Target({ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = SensitiveSerializer.class)
public @interface Sensitive {

   /**
    * 脱敏的类型,默认手机号
    *
    * @return 返回脱敏类型
    */
   Type value();

   /**
    * CUSTOM_HIDE/CUSTOM_OVERLAY 时生效
    *
    * @return 开始位置（包含）
    */
   int startInclude() default 0;

   /**
    * CUSTOM_HIDE/CUSTOM_OVERLAY 时生效
    *
    * @return 结束位置（不包含）
    */
   int endExclude() default 0;

   /**
    * CUSTOM_OVERLAY 时生效
    *
    * @return *重复的次数
    */
   int overlayRepeat() default 4;

		...
}

@Bean
@ConditionalOnMissingBean
public JsonMapperBuilderCustomizer customizer() {
    return builder -> {
        builder.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        builder.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        SimpleModule module = new SimpleModule("customJacksonModule");
        module.addSerializer(Long.class, ToStringSerializer.instance);
        builder.addModule(module);
    };
}

<dependencies>
   <dependency>
      <groupId>dev.macula.boot</groupId>
      <artifactId>macula-boot-commons</artifactId>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
   </dependency>
</dependencies>