Spring Boot 实现接口的各种参数校验

雨点打透心脏的1/2处 2023-10-11 17:01 36阅读 0赞

在我们进行接口开发时，在对参数的接收时，我们需要冗余复杂的校验规则 来进行接口参数的校验，接下来推荐一个好用的校验工具Spring Validation。

> Java API规范 (JSR303) 定义了Bean校验的标准validation-api，但没有提供实现。hibernate validation是对这个规范的实现，并增加了校验注解如@Email、@Length等。

Spring Validation是对hibernate validation的二次封装，用于支持spring mvc参数自动校验。接下来，我们以spring-boot项目为例，介绍Spring Validation的使用。

## 1.添加依赖 ##

<dependency>
                <groupId>org.hibernate.validator</groupId>
                <artifactId>hibernate-validator</artifactId>
            </dependency>
         
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>

## 2.接口参数校验 ##

对于web服务来说，为防止非法参数对业务造成影响，在Controller层一定要做参数校验的！大部分情况下，请求参数分为如下两种形式：

*  POST、PUT请求，使用requestBody传递参数；
 *  GET请求，使用requestParam/PathVariable传递参数。

下面我们简单介绍下requestBody和requestParam/PathVariable的参数校验实战！

### 2.1 requestBody参数校验 ###

**POST**、**PUT**请求一般会使用requestBody传递参数，这种情况下，后端使用**DTO对象**进行接收。只要给 DTO 对象加上@Validated注解就能实现自动参数校验。

> 比如，有一个保存User的接口，要求userName长度是2-10，account和password字段长度是6-20。如果校验失败，会抛出MethodArgumentNotValidException异常，Spring默认会将其转为400（Bad Request）请求。

DTO 表示数据传输对象（Data Transfer Object），用于服务器和客户端之间交互传输使用的。在 spring-web 项目中可以表示用于接收请求参数的Bean对象。

我们只需要两步就可以实现刚刚对user对象参数的需求

*  1.在实体类上声明约束注解

import lombok.Data;
    import org.hibernate.validator.constraints.Length;
    import javax.validation.constraints.NotNull;
    
    @Data
    public class UserDTO {
        
    
        private Long userId;
    
        @NotNull
        @Length(min = 2, max = 10)
        private String userName;
    
        @NotNull
        @Length(min = 6, max = 20)
        private String account;
    
        @NotNull
        @Length(min = 6, max = 20)
        private String password;
    }

*  2.在接口方法参数上声明校验注解

import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class UserController {
        
    
        @PostMapping("/save")
        public Map<String, Object> saveUser(@RequestBody @Validated UserDTO userDTO) {
        
            Map<String, Object> result = new HashMap<>();
            result.put("code", 20000);
            return result;
        }
    }

接下来我们进行一下测试  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

我们可以看到密码位数不对时会转为400请求参数不对的错误

### 2.2 requestParam/PathVariable参数校验 ###

GET请求一般会使用requestParam/PathVariable传参。  
如果参数比较多 (比如超过 6 个)，还是推荐使用DTO对象接收。否则，推荐将一个个参数平铺到方法入参中。在这种情况下，必须在Controller类上标注@Validated注解，并在入参上声明约束注解 (如@Min等)。  
如果校验失败，会抛出ConstraintViolationException异常。代码示例如下：

package com.example.code.controller;
    
    import com.example.code.po.UserDTO;
    import org.hibernate.validator.constraints.Length;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class UserController {
        
        @GetMapping("{userId}")
        public Map<String, Object> detail(@PathVariable("userId") @Min(10000000000000000L) Long userId) {
        
            Map<String, Object> result = new HashMap<>();
            UserDTO userDTO = new UserDTO();
            userDTO.setUserId(userId);
            userDTO.setAccount("11111111111111111");
            userDTO.setUserName("xixi");
            userDTO.setAccount("11111111111111111");
            result.put("code", 20000);
            result.put("data", userDTO);
            return result;
        }
    
        @GetMapping("getByAccount")
        public Map<String, Object> getByAccount(@Length(min = 6, max = 20) @NotNull String account) {
        
            Map<String, Object> result = new HashMap<>();
            UserDTO userDTO = new UserDTO();
            userDTO.setUserId(10000000000000003L);
            userDTO.setAccount(account);
            userDTO.setUserName("xixi");
            userDTO.setAccount(account);
            result.put("code", 20000);
            result.put("data", userDTO);
            return result;
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

## 3.统一异常处理 ##

在我们刚刚的测试中会发现如果校验失败，会抛出MethodArgumentNotValidException或者ConstraintViolationException异常。  
但是在实际项目开发中，通常会用统一异常处理来返回一个更友好的提示。比如我们系统要求无论发送什么异常，http的状态码必须返回200，由业务码去区分系统的异常情况。

import org.springframework.http.HttpStatus;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.FieldError;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    import javax.validation.ConstraintViolationException;
    import java.util.HashMap;
    import java.util.Map;
    
    @RestControllerAdvice
    public class CommonExceptionHandler {
        
    
        @ExceptionHandler({
        MethodArgumentNotValidException.class})
        @ResponseStatus(HttpStatus.OK)
        @ResponseBody
        public Map<String, Object> handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
        
            Map<String, Object> result = new HashMap<>();
            BindingResult bindingResult = ex.getBindingResult();
            StringBuilder sb = new StringBuilder("校验失败:");
            for (FieldError fieldError : bindingResult.getFieldErrors()) {
        
                sb.append(fieldError.getField()).append("：").append(fieldError.getDefaultMessage()).append(", ");
            }
            String msg = sb.toString();
            result.put("code", 500);
            result.put("msg", msg);
            return result;
        }
    
        @ExceptionHandler({
        ConstraintViolationException.class})
        @ResponseStatus(HttpStatus.OK)
        @ResponseBody
        public Map<String, Object> handleConstraintViolationException(ConstraintViolationException ex) {
        
            Map<String, Object> result = new HashMap<>();
            result.put("code", 500);
            result.put("msg", ex.getMessage());
            return result;
        }
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

## 4.进阶使用 ##

### 4.1 分组校验 ###

在实际项目中，可能多个方法需要使用同一个DTO类来接收参数，而不同方法的校验规则很可能是不一样的。  
这个时候，简单地在DTO类的字段上加约束注解无法解决这个问题。因此，spring-validation支持了分组校验的功能，专门用来解决这类问题。  
还是继续使用上面的例子，比如保存User的时候，UserId是可空的，但是更新User的时候，UserId的值必须>=10000000000000000L；其它字段的校验规则在两种情况下一样。这个时候使用分组校验的代码示例如下：

import lombok.Data;
    import org.hibernate.validator.constraints.Length;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    
    @Data
    public class UserDTO_Groups {
        
        @Min(value = 10000000000000000L, groups = Update.class)
        private Long userId;
    
        @NotNull(groups = {
        Save.class, Update.class})
        @Length(min = 2, max = 10, groups = {
        Save.class, Update.class})
        private String userName;
    
        @NotNull(groups = {
        Save.class, Update.class})
        @Length(min = 6, max = 20, groups = {
        Save.class, Update.class})
        private String account;
    
        @NotNull(groups = {
        Save.class, Update.class})
        @Length(min = 6, max = 20, groups = {
        Save.class, Update.class})
        private String password;
    
    
        public interface Save {
        
        }
    
        public interface Update {
        
        }
    }

在@Validated注解上指定校验分组

import com.example.code.po.UserDTO;
    import com.example.code.po.UserDTO_Groups;
    import org.hibernate.validator.constraints.Length;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class UserController {
        
        @PostMapping("/save_group")
        public Map<String, Object> saveUser_Group(@RequestBody @Validated(UserDTO_Groups.Save.class) UserDTO_Groups userDTO) {
        
            Map<String, Object> result = new HashMap<>();
            result.put("code", 20000);
            result.put("data", userDTO);
            return result;
        }
    
        @PostMapping("/update_group")
        public Map<String, Object> updateUser(@RequestBody @Validated(UserDTO_Groups.Update.class) UserDTO_Groups userDTO) {
        
            Map<String, Object> result = new HashMap<>();
            result.put("code", 20000);
            result.put("data", userDTO);
            return result;
        }
    }

### 4.2 嵌套校验 ###

在实际开发中，我们保存User信息的时候同时还带有Job信息。需要注意的是，此时DTO类的对应字段必须标记@Valid注解。

import lombok.Data;
    import org.hibernate.validator.constraints.Length;
    
    import javax.validation.Valid;
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    
    /**
     * 嵌套校验
     */
    @Data
    public class UserDTO_Nest {
        
        @Min(value = 10000000000000000L, groups = Update.class)
        private Long userId;
    
        @NotNull(groups = {
        Save.class, Update.class})
        @Length(min = 2, max = 10, groups = {
        Save.class, Update.class})
        private String userName;
    
        @NotNull(groups = {
        Save.class, Update.class})
        @Length(min = 6, max = 20, groups = {
        Save.class, Update.class})
        private String account;
    
        @NotNull(groups = {
        Save.class, Update.class})
        @Length(min = 6, max = 20, groups = {
        Save.class, Update.class})
        private String password;
    
        @NotNull(groups = {
        Save.class, Update.class})
        @Valid
        private Job job;
    
        public interface Save {
        
        }
    
        public interface Update {
        
        }
    }

import lombok.Data;
    import org.hibernate.validator.constraints.Length;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    
    @Data
    public class Job {
        
    
        @Min(value = 1, groups = UserDTO_Nest.Update.class)
        private Long jobId;
    
        @NotNull(groups = {
        UserDTO_Nest.Save.class, UserDTO_Nest.Update.class})
        @Length(min = 2, max = 10, groups = {
        UserDTO_Nest.Save.class, UserDTO_Nest.Update.class})
        private String jobName;
    
        @NotNull(groups = {
        UserDTO_Nest.Save.class, UserDTO_Nest.Update.class})
        @Length(min = 2, max = 10, groups = {
        UserDTO_Nest.Save.class, UserDTO_Nest.Update.class})
        private String position;
    
    }

package com.example.code.controller;
    
    import com.example.code.po.UserDTO;
    import com.example.code.po.UserDTO_Groups;
    import com.example.code.po.UserDTO_Nest;
    import com.example.code.validate.ValidationList;
    import org.hibernate.validator.constraints.Length;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class UserController {
        
    
        @PostMapping("/save1")
        public Map<String, Object> save1(@RequestBody @Validated(UserDTO_Nest.Save.class) UserDTO_Nest userList) {
        
            Map<String, Object> result = new HashMap<>();
            result.put("code", 20000);
            result.put("data", userList);
            return result;
        }
    }

因为我们在代码中设置了嵌套校验要求job不能为空，所以:  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]

我们在job类汇总设置了position最小长度为2，所以：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]

嵌套校验可以结合分组校验一起使用。  
嵌套集合校验会对集合里面的每一项都进行校验，例如List< Job>字段会对这个list里面的每一个Job对象都进行校验。

### 4.3 集合校验 ###

如果请求体直接传递了json数组给后台，并希望对数组中的每一项都进行参数校验。  
此时，如果我们直接使用java.util.Collection下的list或者set来接收数据，参数校验并不会生效！我们可以使用自定义list集合来接收参数：

*  1.包装List类型，并声明@Valid注解

package com.example.code.validate;
    
    import lombok.experimental.Delegate;
    
    import javax.validation.Valid;
    import java.util.ArrayList;
    import java.util.List;
    
    public class ValidationList<E> implements List<E> {
        
    
        @Delegate
        @Valid
        public List<E> list = new ArrayList<>();
    
        @Override
        public String toString() {
        
            return list.toString();
        }
    }

注意：@Delegate注解受lombok版本限制，1.18.6以上版本可支持。如果校验不通过，会抛出NotReadablePropertyException，同样可以使用统一异常进行处理。  
接下来我们开发接口，使其可以批量保存

import com.example.code.po.UserDTO;
    import com.example.code.po.UserDTO_Groups;
    import com.example.code.po.UserDTO_Nest;
    import com.example.code.validate.ValidationList;
    import org.hibernate.validator.constraints.Length;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class UserController {
        
        @PostMapping("/saveList")
        public Map<String, Object> saveList(@RequestBody @Validated(UserDTO_Nest.Save.class) ValidationList<UserDTO_Nest> userList) {
        
            Map<String, Object> result = new HashMap<>();
            result.put("code", 20000);
            result.put("data", userList);
            return result;
        }
    }

### 4.4 自定义校验 ###

在我们实际的业务开发中，我们的需求总是比框架提供的这些简单校验要复杂的多，我们可以通过自定义校验来满足我们的需求。

> 假设我们自定义加密id（由数字或者a-f的字母组成，32-256长度）校验，主要分为两步：

*  1.自定义约束注解

import javax.validation.Constraint;
    import javax.validation.Payload;
    import java.lang.annotation.Documented;
    import java.lang.annotation.Retention;
    import java.lang.annotation.Target;
    
    import static java.lang.annotation.ElementType.*;
    import static java.lang.annotation.RetentionPolicy.RUNTIME;
    
    @Target({
        METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
    @Retention(RUNTIME)
    @Documented
    @Constraint(validatedBy = {
        EncryptIdValidator.class})
    public @interface EncryptId {
        
    
        String message() default "加密id格式错误";
    
        Class<?>[] groups() default {
        };
    
        Class<? extends Payload>[] payload() default {
        };
    }

*  2.实现ConstraintValidator接口编写约束校验器

import javax.validation.ConstraintValidator;
    import javax.validation.ConstraintValidatorContext;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class EncryptIdValidator implements ConstraintValidator<EncryptId, String> {
        
    
        private static final Pattern PATTERN = Pattern.compile("^[a-f\\d]{32,256}$");
    
        @Override
        public boolean isValid(String value, ConstraintValidatorContext context) {
        
    
            if (value != null) {
        
                Matcher matcher = PATTERN.matcher(value);
                return matcher.find();
            }
            return true;
        }
    }

*  3.在实体类上的字段中进行使用

import com.example.code.validate.EncryptId;
    import lombok.Data;
    import org.hibernate.validator.constraints.Length;
    
    import javax.validation.constraints.NotNull;
    
    @Data
    public class UserDTO {
        
    
        private Long userId;
    
        @NotNull
        @Length(min = 2, max = 10)
        private String userName;
    
        @NotNull
        @Length(min = 6, max = 20)
        private String account;
    
        @NotNull
        @EncryptId
        private String password;
    }

*  4.测试

import com.example.code.validate.ValidationList;
    import org.hibernate.validator.constraints.Length;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.constraints.Min;
    import javax.validation.constraints.NotNull;
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class UserController {
        
        @PostMapping("/save2")
        public Map<String, Object> save2(@RequestBody @Validated UserDTO userDTO) {
        
            Map<String, Object> result = new HashMap<>();
            result.put("code", 20000);
            result.put("data", userDTO);
            return result;
        }
    }

结果如下：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]

我们可以看到自定义的校验已经应用成功了

## 5.快速失败 (Fail Fast) ##

Spring Validation默认会校验完所有字段，然后才抛出异常。此时如果需要校验字段过多则会影响前后端交互的速度，我们可以通过一些简单的配置，开启Fali Fast模式，一旦校验失败就立即返回。

import org.hibernate.validator.HibernateValidator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    import javax.validation.Validation;
    import javax.validation.Validator;
    import javax.validation.ValidatorFactory;
    
    @Component
    public class ValidatorConfig {
        
        @Bean
        public Validator validator() {
        
            ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
                    .configure()
    
                    .failFast(true)
                    .buildValidatorFactory();
            return validatorFactory.getValidator();
        }
    }

## 6.@Valid和@Validated区别 ##

<table> 
 <thead> 
  <tr> 
   <th>区别</th> 
   <th>@Valid</th> 
   <th>@Validated</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>提供者</td> 
   <td>JSR-303 规范</td> 
   <td>Spring</td> 
  </tr> 
  <tr> 
   <td>是否支持分组</td> 
   <td>不支持</td> 
   <td>支持</td> 
  </tr> 
  <tr> 
   <td>标注位置</td> 
   <td>METHOD, FIELD, CONSTRUCTOR, PARAMETER, TYPE_USE</td> 
   <td>TYPE, METHOD, PARAMETER</td> 
  </tr> 
  <tr> 
   <td>嵌套校验</td> 
   <td>支持</td> 
   <td>不支持</td> 
  </tr> 
 </tbody> 
</table>

## 7.实现原理 ##

### 7.1 requestBody参数校验实现原理 ###

> 在spring-mvc中，RequestResponseBodyMethodProcessor是用于解析@RequestBody标注的参数以及处理@ResponseBody标注方法的返回值的。显然，执行参数校验的逻辑肯定就在解析参数的方法resolveArgument()中：

于是我们看一下RequestResponseBodyMethodProcessor的resolveArgument()方法  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]

可以看到调用了validateIfApplicable()进行参数校验，我们在看看validateIfApplicable()具体是如何校验的  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]

我们可以看到真正的校验，无论是@Validated、@Valid都是通过binder.validate(validationHints);实现，所以我们在接着往下看看WebDataBinder.validate()实现  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]

最终发现底层最终还是调用了Hibernate Validator进行真正的校验处理

### 7.2 方法级别的参数校验实现原理 ###

上面提到的将参数一个个平铺到方法参数中，然后在每个参数前面声明约束注解的校验方式，就是方法级别的参数校验,如下图所示：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]

实际上，这种方式可用于任何Spring Bean的方法上，比如Controller/Service等。其底层实现原理就是**AOP**，具体来说是通过MethodValidationPostProcessor动态注册AOP切面，然后使用MethodValidationInterceptor对切点方法织入增强。  
我们看一下MethodValidationPostProcessor中源码的实现  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]

最终调用的是MethodValidationInterceptor()，那么我们进入到该类看一下  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]

实际上，不管是requestBody参数校验还是方法级别的校验，最终都是调用Hibernate Validator执行校验，Spring Validation只是做了一层封装。  
**至此对于接口参数的校验就到此结束了，有问题欢迎大家来下方讨论，谢谢。**

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/3a3905ee01c747019d49df1071618c1e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/0e503ff562694bff973cf9f41e13c5c5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: https://img-blog.csdnimg.cn/a02de7be1b4c442e816d1d05e60ac489.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: https://img-blog.csdnimg.cn/1211d7068a414e63ae7f1cf48234df5f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]: https://img-blog.csdnimg.cn/b222d5b305c94563bc7bbd572dbe2a4c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]: https://img-blog.csdnimg.cn/4ba0ae880cf04bbfa37a4c26e97de0ca.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]: https://img-blog.csdnimg.cn/a0d7147b73354b2f9a11eb897b8dc074.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]: https://img-blog.csdnimg.cn/6e6e15d881a244c4a25bed30fdbd30b1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]: https://img-blog.csdnimg.cn/aa6e9044e5b64ff9a0549b71fe9e5459.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]: https://img-blog.csdnimg.cn/d4987ed407704af39f1622108a8693e2.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]: https://img-blog.csdnimg.cn/15d8b19c25f44d8f9ec84d428c557f77.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]: https://img-blog.csdnimg.cn/167fffc008704ed6931ab5231e2de3ba.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center