Anotación de Java Anotación de verificación de parámetros personalizados de chat

Después de leer los artículos anteriores, debe tener cierta comprensión de las anotaciones y debería poder utilizar fácilmente las anotaciones en su trabajo. En los últimos días, encontré un problema de verificación en el proyecto. Por cierto, escribí una nota simple para compartir con ustedes.

Como mencioné anteriormente, en el marco Spring, en el controlador, todos usan anotaciones para recibir parámetros json, y los parámetros generalmente se anotan con @NotNull, etc., de modo que los parámetros se hayan verificado cuando ingresan al método.

Hay muchas reglas de verificación encapsuladas en el paquete jar relacionado, que básicamente pueden servir para la mayor parte de la verificación. Pero, ¿qué debo hacer si de repente quiero expandirme de vez en cuando? No se preocupe, estos mecanismos de verificación tienen interfaces que los usuarios pueden ampliar, al igual que el marco de Spring, y muchas implementaciones pueden implementarse por sí mismas.

Implementemos la verificación de un número de tarjeta de identificación.

Primero defina un comentario. El método de escritura es este modo. Si desea utilizar el código de verificación de otras personas, naturalmente se ajustará a las reglas del autor original.

package com.example.demoproject.valid;

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = ConstraintImpl.class)
public @interface ValidIDCard {
    String message();
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default { };
}

Para implementar la verificación de anotaciones, debe implementar una interfaz ConstraintValidator, el código es el siguiente

 

package com.example.demoproject.valid;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.regex.Pattern;

public class ConstraintImpl implements ConstraintValidator<ValidIDCard,Object> {

    private static final String IDCard18 = "[1-9]\\d{5}(18|19|([23]\\d))\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]";
    private static final String IDCard15 = "[1-9]\\d{5}\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{2}";

    @Override
    public void initialize(ValidIDCard constraintAnnotation) {
        // 获取注解值中的value，如果有需要的话可以进行处理，比如Max,Min 就需要
        System.out.println("校验身份证号初始化~~~");
    }

    @Override
    public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {
        Pattern pattern ;
        if(o instanceof  String){
            String str = (String)o;
            if(str.length()==18){
                pattern = Pattern.compile(IDCard18);
                return pattern.matcher(str).matches();
            }
            if(str.length()==15){
                pattern = Pattern.compile(IDCard15);
                return pattern.matcher(str).matches();
            }
        }
        return false;
    }
}

De esta manera, se realiza una verificación periódica en el método. Bueno, escribamos una prueba de método.

Crea un objeto

package com.example.demoproject.dto;

import com.example.demoproject.valid.ValidIDCard;
import lombok.Data;

import javax.validation.constraints.NotNull;

@Data
public class ValidDTO {

    @NotNull(message = "名称不能为空")
    String name;

    @ValidIDCard(message = "身份证号格式不对~")
    String idCard;

    String age;

}

Escriba una prueba de método a continuación:

    @PostMapping(value = "test-valid")
    public String testValid(@RequestBody @Valid ValidDTO validDTO){

        return JSON.toJSONString(validDTO);
    }

Si el número de ID en el parámetro de solicitud no puede coincidir con la regularidad, naturalmente se informará un error. Este error no se capturó ni procesó, y se publicó directamente

 "errors": [
        {
            "codes": [
                "ValidIDCard.validDTO.idCard",
                "ValidIDCard.idCard",
                "ValidIDCard.java.lang.String",
                "ValidIDCard"
            ],
            "arguments": [
                {
                    "codes": [
                        "validDTO.idCard",
                        "idCard"
                    ],
                    "arguments": null,
                    "defaultMessage": "idCard",
                    "code": "idCard"
                }
            ],
            "defaultMessage": "身份证号格式不对~",
            "objectName": "validDTO",
            "field": "idCard",
            "rejectedValue": "341282199175",
            "bindingFailure": false,
            "code": "ValidIDCard"
        }
    ],

 

No diré nada en profundidad. Hoy escribo esto principalmente por dos palabras: ¡práctico! Espero que pueda ser útil para todos.

                       

¡¡¡Sin sacrificio no hay victoria!!!