Springboot 使用自定义注解结合AOP方式校验接口参数

浅浅的花香味﹌ 2023-02-10 05:12 104阅读 0赞

# **前言** #

对于初学者们，对于接口的参数判空多多少少都是有些膈应，因为每次写个接口，拿那几个参，就得if else。

那么该篇教学，就可以一定程度解决这个问题。

# **正文** #

该篇文章涉及到的：

1.自定义注解 ，用于标注需要进行校验的参数

2.AOP配合自定义注解使用

3.实现公共的返回参

4.实现全局异常捕获

先看整体我们需要做的东西有什么：

![20200520134727586.png][]

*只要完成这两个文件夹里面的，那么到了新的项目，你只需要把这两个文件夹的东西直接丢进去即可。 *

接下来开始敲代码吧，

首先是pom.xml，一些相关的jar：

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.4</version>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>1.8.9</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.58</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>

新建自定义注解，ParamCheck.java ：

import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/5/14
     * @Description :
     **/
    
    @Target(ElementType.PARAMETER)
    @Retention(RetentionPolicy.RUNTIME)
    
    
    public @interface ParamCheck  {
        /**
         * 是否非空,默认不能为空
         */
        boolean notNull() default true;
    
        /**
         * 默认值
         * @return
         */
        String defaultValue() default "";
    }

简单描述：

ElementType.PARAMETER  使用于参数

boolean notNull() default true;  要求参数不为空，默认开启,可以自己传

String defaultValue() default ""; 默认值，默认设置 ""，可以自己传

接下来新建 参数校验的AOP实现类，ParamValidAop.java：

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    import org.springframework.util.StringUtils;
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/5/14
     * @Description :
     **/
    @Component
    @Aspect
    public class ParamValidAop {
    
    
    
        /**
         * 定义有一个切入点，范围为web包下的类
         */
        @Pointcut("execution(public * com.bsapple.vshop.controller..*.*(..))")
        public void checkParam() {
        }
    
        @Before("checkParam()")
        public void doBefore(JoinPoint joinPoint) {
        }
    
        /**
         * 检查参数是否为空
         */
        @Around("checkParam()")
        public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    
    
            MethodSignature signature = ((MethodSignature) pjp.getSignature());
            //得到拦截的方法
            Method method = signature.getMethod();
            //获取方法参数注解，返回二维数组是因为某些参数可能存在多个注解
            Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            if (parameterAnnotations == null || parameterAnnotations.length == 0) {
                return pjp.proceed();
            }
            //获取方法参数名
            String[] paramNames = signature.getParameterNames();
            //获取参数值
            Object[] paranValues = pjp.getArgs();
    
            //获取方法参数类型
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (int i = 0; i < parameterAnnotations.length; i++) {
                for (int j = 0; j < parameterAnnotations[i].length; j++) {
                    //如果该参数前面的注解不为空并且是ParamCheck的实例，并且notNull()=true,并且默认值为空，则进行非空校验
                    if (parameterAnnotations[i][j] != null && parameterAnnotations[i][j] instanceof ParamCheck && ((ParamCheck) parameterAnnotations[i][j]).notNull() && StringUtils.isEmpty(((ParamCheck)parameterAnnotations[i][j]).defaultValue())) {
                        paramIsNull(paramNames[i], paranValues[i], parameterTypes[i] == null ? null : parameterTypes[i].getName());
                        break;
                    }
                    //如果该参数前面的注解不为空并且是ParamCheck的实例，并且默认值不为空，并且参数值为空，则进行赋默认值
                    if(parameterAnnotations[i][j] != null && parameterAnnotations[i][j] instanceof ParamCheck && !StringUtils.isEmpty(((ParamCheck)parameterAnnotations[i][j]).defaultValue()) && (paranValues[i] == null || StringUtils.isEmpty(paranValues[i].toString()))){
                        paranValues[i] = putParam(((ParamCheck)parameterAnnotations[i][j]).defaultValue(), parameterTypes[i]);
                    }
                }
            }
            return pjp.proceed(paranValues);
    
        }
    
        /**
         * 在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
         *
         * @param joinPoint
         */
        @AfterReturning("checkParam()")
        public void doAfterReturning(JoinPoint joinPoint) {
        }
    
        /**
         * 参数非空校验，如果参数为空，则抛出ParamIsNullException异常
         * @param paramName
         * @param value
         * @param parameterType
         */
        private void paramIsNull(String paramName, Object value, String parameterType) {
            if (value == null || "".equals(value.toString().trim())) {
                throw new ParamIsNullException(paramName, parameterType,"参数为空");
            }
        }
    
    
        private Object putParam(Object value, Class<?> parameterType) {
            return CastValueTypeUtil.parseValue(parameterType, value.toString());
        }
    
    }

需要注意，这个路径是你准备添加校验的controller的路径，改成你自己的:

![20200520131735389.png][]

然后是校验参数里面使用到的参数转换工具类，CastValueTypeUtil.java：

import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
      *转换object类型
     **/
    public class CastValueTypeUtil {
    
        public static Object parseValue(Class<?> parameterTypes, String value) {
    
            if(value==null || value.trim().length()==0){
                return null;
            }
            value = value.trim();
    
            if (Byte.class.equals(parameterTypes) || Byte.TYPE.equals(parameterTypes)) {
                return parseByte(value);
            } else if (Boolean.class.equals(parameterTypes) || Boolean.TYPE.equals(parameterTypes)) {
                return parseBoolean(value);
            }/* else if (Character.class.equals(fieldType) || Character.TYPE.equals(fieldType)) {
    			 return value.toCharArray()[0];
    		}*/ else if (String.class.equals(parameterTypes)) {
                return value;
            } else if (Short.class.equals(parameterTypes) || Short.TYPE.equals(parameterTypes)) {
                return parseShort(value);
            } else if (Integer.class.equals(parameterTypes) || Integer.TYPE.equals(parameterTypes)) {
                return parseInt(value);
            } else if (Long.class.equals(parameterTypes) || Long.TYPE.equals(parameterTypes)) {
                return parseLong(value);
            } else if (Float.class.equals(parameterTypes) || Float.TYPE.equals(parameterTypes)) {
                return parseFloat(value);
            } else if (Double.class.equals(parameterTypes) || Double.TYPE.equals(parameterTypes)) {
                return parseDouble(value);
            } else if (Date.class.equals(parameterTypes)) {
                return parseDate(value);
            } else {
                throw new RuntimeException("request illeagal type, type must be Integer not int Long not long etc, type=" + parameterTypes);
            }
        }
    
        public static Byte parseByte(String value) {
            try {
                value = value.replaceAll("　", "");
                return Byte.valueOf(value);
            } catch(NumberFormatException e) {
                throw new RuntimeException("parseByte but input illegal input=" + value, e);
            }
        }
    
        public static Boolean parseBoolean(String value) {
            value = value.replaceAll("　", "");
            if (Boolean.TRUE.toString().equalsIgnoreCase(value)) {
                return Boolean.TRUE;
            } else if (Boolean.FALSE.toString().equalsIgnoreCase(value)) {
                return Boolean.FALSE;
            } else {
                throw new RuntimeException("parseBoolean but input illegal input=" + value);
            }
        }
    
        public static Integer parseInt(String value) {
            try {
                value = value.replaceAll("　", "");
                return Integer.valueOf(value);
            } catch(NumberFormatException e) {
                throw new RuntimeException("parseInt but input illegal input=" + value, e);
            }
        }
    
        public static Short parseShort(String value) {
            try {
                value = value.replaceAll("　", "");
                return Short.valueOf(value);
            } catch(NumberFormatException e) {
                throw new RuntimeException("parseShort but input illegal input=" + value, e);
            }
        }
    
        public static Long parseLong(String value) {
            try {
                value = value.replaceAll("　", "");
                return Long.valueOf(value);
            } catch(NumberFormatException e) {
                throw new RuntimeException("parseLong but input illegal input=" + value, e);
            }
        }
    
        public static Float parseFloat(String value) {
            try {
                value = value.replaceAll("　", "");
                return Float.valueOf(value);
            } catch(NumberFormatException e) {
                throw new RuntimeException("parseFloat but input illegal input=" + value, e);
            }
        }
    
        public static Double parseDouble(String value) {
            try {
                value = value.replaceAll("　", "");
                return Double.valueOf(value);
            } catch(NumberFormatException e) {
                throw new RuntimeException("parseDouble but input illegal input=" + value, e);
            }
        }
    
        public static Date parseDate(String value) {
            try {
                String datePattern = "yyyy-MM-dd HH:mm:ss";
                SimpleDateFormat dateFormat = new SimpleDateFormat(datePattern);
                return dateFormat.parse(value);
            } catch(ParseException e) {
                throw new RuntimeException("parseDate but input illegal input=" + value, e);
            }
        }
    
    }

然后是新建一个自定义异常，专门用于校验参数为空的时候抛出，ParamIsNullException.java：

/**
     * @Author : JCccc
     * @CreateTime : 2020/5/14
     * @Description :
     **/
    public class ParamIsNullException extends RuntimeException {
        private final String parameterName;
        private final String parameterType;
        private final String message;
    
        public ParamIsNullException(String parameterName, String parameterType, String message) {
            super();
            this.parameterName = parameterName;
            this.parameterType = parameterType;
            this.message = message;
        }
    
        @Override
        public String getMessage() {
            return "请求参数类型：" + this.parameterType + "，参数名： \'" + this.parameterName + message;
        }
    
        public final String getParameterName() {
            return this.parameterName;
        }
    
        public final String getParameterType() {
            return this.parameterType;
        }
    }

到这里，其实可以看到自定义注解以及AOP已经实现完毕。

接下来是做一下，统一的返回参以及全局异常捕获，

新建接口BaseErrorInfoInterface.java：

/**
     * @Author：JCccc
     * @Description：此接口用于返回码枚举使用
     * @Date： created in 15:11 2019/5/3
     */
    
    public interface BaseErrorInfoInterface {
        /** 错误码*/
        String getResultCode();
    
        /** 错误描述*/
        String getResultMsg();
    }

返回码的枚举类，CommonEnum.java：

/**
     * @Author：JCccc
     * @Description：
     * @Date： created in 15:13 2019/5/3
     */
    public enum CommonEnum implements BaseErrorInfoInterface {
    
        // 数据操作错误定义
        SUCCESS("200", "成功!"),
        BODY_NOT_MATCH("400", "请求的数据格式不符!"),
        SIGNATURE_NOT_MATCH("401", "请求的数字签名不匹配!"),
        NOT_FOUND("404", "未找到该资源!"),
        INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
        SERVER_BUSY("503", "服务器正忙，请稍后再试!"),
        REQUEST_METHOD_SUPPORT_ERROR("40001","当前请求方法不支持");
        /**
         * 错误码
         */
        private String resultCode;
        /**
         * 错误描述
         */
        private String resultMsg;
    
        CommonEnum(String resultCode, String resultMsg) {
            this.resultCode = resultCode;
            this.resultMsg = resultMsg;
        }
    
        @Override
        public String getResultCode() {
            return resultCode;
        }
    
        @Override
        public String getResultMsg() {
            return resultMsg;
        }
    }

然后是一个简单的返回体专用类，ResultBody.java：

import com.alibaba.fastjson.JSONObject;
    
    /**
     * @Author：JCccc
     * @Description：
     * @Date： created in 15:19 2019/5/3
     */
    
    public class ResultBody {
        /**
         * 响应代码
         */
        private String code;
    
        /**
         * 响应消息
         */
        private String message;
    
        /**
         * 响应结果
         */
        private Object result;
    
        public ResultBody() {
        }
    
        public ResultBody(BaseErrorInfoInterface errorInfo) {
            this.code = errorInfo.getResultCode();
            this.message = errorInfo.getResultMsg();
        }
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
        public Object getResult() {
            return result;
        }
    
        public void setResult(Object result) {
            this.result = result;
        }
    
        /**
         * 成功
         *
         * @return
         */
        public static ResultBody success() {
            return success(null);
        }
    
        /**
         * 成功
         * @param data
         * @return
         */
        public static ResultBody success(Object data) {
            ResultBody rb = new ResultBody();
            rb.setCode(CommonEnum.SUCCESS.getResultCode());
            rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
            rb.setResult(data);
            return rb;
        }
    
    
    
    
    
        /**
         * 失败
         */
        public static ResultBody error(BaseErrorInfoInterface errorInfo) {
            ResultBody rb = new ResultBody();
            rb.setCode(errorInfo.getResultCode());
            rb.setMessage(errorInfo.getResultMsg());
            rb.setResult(null);
            return rb;
        }
    
        /**
         * 失败
         */
        public static ResultBody error(String code, String message) {
            ResultBody rb = new ResultBody();
            rb.setCode(code);
            rb.setMessage(message);
            rb.setResult(null);
            return rb;
        }
    
        /**
         * 失败
         */
        public static ResultBody error( String message) {
            ResultBody rb = new ResultBody();
            rb.setCode("-1");
            rb.setMessage(message);
            rb.setResult(null);
            return rb;
        }
    
        @Override
        public String toString() {
            return JSONObject.toJSONString(this);
        }
    
    }

最后是自定义的业务异常类，和全局异常捕获类，

BizException.java

/**
     * @Author：JCccc
     * @Description：
     * @Date： created in 15:18 2019/5/3
     */
    
    public class BizException extends RuntimeException {
    
        private static final long serialVersionUID = 1L;
    
        /**
         * 错误码
         */
        protected String errorCode;
        /**
         * 错误信息
         */
        protected String errorMsg;
    
        public BizException() {
            super();
        }
    
        public BizException(BaseErrorInfoInterface errorInfoInterface) {
            super(errorInfoInterface.getResultCode());
            this.errorCode = errorInfoInterface.getResultCode();
            this.errorMsg = errorInfoInterface.getResultMsg();
        }
    
        public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
            super(errorInfoInterface.getResultCode(), cause);
            this.errorCode = errorInfoInterface.getResultCode();
            this.errorMsg = errorInfoInterface.getResultMsg();
        }
    
        public BizException(String errorMsg) {
            super(errorMsg);
            this.errorMsg = errorMsg;
        }
    
        public BizException(String errorCode, String errorMsg) {
            super(errorCode);
            this.errorCode = errorCode;
            this.errorMsg = errorMsg;
        }
    
        public BizException(String errorCode, String errorMsg, Throwable cause) {
            super(errorCode, cause);
            this.errorCode = errorCode;
            this.errorMsg = errorMsg;
        }
    
    
        public String getErrorCode() {
            return errorCode;
        }
    
        public void setErrorCode(String errorCode) {
            this.errorCode = errorCode;
        }
    
        public String getErrorMsg() {
            return errorMsg;
        }
    
        public void setErrorMsg(String errorMsg) {
            this.errorMsg = errorMsg;
        }
    
        public String getMessage() {
            return errorMsg;
        }
    
        @Override
        public Throwable fillInStackTrace() {
            return this;
        }
    
    }

GlobalExceptionHandler.java：

import com.bsapple.vshop.wholeConfig.paramCheck.ParamIsNullException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.HttpRequestMethodNotSupportedException;
    import org.springframework.web.bind.MissingServletRequestParameterException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * @Author：JCccc
     * @Description：
     * @Date： created in 15:29 2019/5/3
     */
    
    @RestControllerAdvice
    public class GlobalExceptionHandler {
        private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
        /**
         * 处理自定义的业务异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value = BizException.class)
        @ResponseBody
        public ResultBody bizExceptionHandler(HttpServletRequest req, BizException e){
            logger.error("发生业务异常！原因是：{}",e.getErrorMsg());
            return ResultBody.error(e.getErrorCode(),e.getErrorMsg());
        }
    
    
        /**
         * 处理空指针的异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value =NullPointerException.class)
        @ResponseBody
        public ResultBody exceptionHandler(HttpServletRequest req, NullPointerException e){
            logger.error("发生空指针异常！原因是:",e);
            return ResultBody.error(CommonEnum.BODY_NOT_MATCH);
        }
    
        /**
         * 处理请求方法不支持的异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class)
        @ResponseBody
        public ResultBody exceptionHandler2(HttpServletRequest req, HttpRequestMethodNotSupportedException e){
            logger.error("发生请求方法不支持异常！原因是:",e);
            return ResultBody.error(CommonEnum.REQUEST_METHOD_SUPPORT_ERROR);
        }
    
    
        /**
         * 处理请求方法不支持的异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value = {ParamIsNullException.class,MissingServletRequestParameterException.class})
        @ResponseBody
        public ResultBody exceptionHandler3(HttpServletRequest req, Exception  e){
            logger.error("参数为空！原因是:",e);
            return ResultBody.error(CommonEnum.SIGNATURE_NOT_MATCH.getResultCode(),e.getMessage());
        }
    
    
    
    
        /**
         * 处理其他异常
         * @param req
         * @param e
         * @return
         */
        @ExceptionHandler(value =Exception.class)
        @ResponseBody
        public ResultBody exceptionHandler(HttpServletRequest req, Exception e){
            logger.error("未知异常！原因是:",e);
            return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
        }
    
    
    
    }

好了，接下来看看这套实现的东西，效果如何：

给需要的校验的参数加上我们的自定义注解即可，如：

@GetMapping("/hello1")
        public ResultBody hello1(@ParamCheck  String name) {
    
            return ResultBody.success();
        }

正常访问该接口，

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70][]

那么我们试试不传参数name：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1][]

那么我再试试，自定义注解里面默认值的使用：

![20200520133726305.png][]

然后再调用接口，不传name，可以看到默认值赋予成功：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2][]

最后再试试，同时用上注解   @RequestParam("userName")  给参数name起了个别名，然后也用上我们的自定义参数校验注解，如：

![20200520134113195.png][]

调用接口，正常访问：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3][]

可以回顾看下我们AOP实现类里面的代码，没错，就是二维数组可以接受这个参数的多个注解：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4][]

简单的测试效果就到此吧，自己打个debug断点看一看就ok，该篇就到此吧。

[20200520134727586.png]: https://img-blog.csdnimg.cn/20200520134727586.png
[20200520131735389.png]: https://img-blog.csdnimg.cn/20200520131735389.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200520133523191.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200520133559916.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[20200520133726305.png]: https://img-blog.csdnimg.cn/20200520133726305.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200520133835164.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[20200520134113195.png]: https://img-blog.csdnimg.cn/20200520134113195.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020052013413210.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200520134254863.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70