J'ai essayé d'utiliser le FW de validation qui peut ajouter des restrictions d'entrée par une annotation basée sur des annotations appelée OVal. Prenez note de l'exemple de code à ce moment-là.
pom.xml
<!-- https://mvnrepository.com/artifact/net.sf.oval/oval -->
<dependency>
<groupId>net.sf.oval</groupId>
<artifactId>oval</artifactId>
<version>1.90</version>
</dependency>
build.gradle
// https://mvnrepository.com/artifact/net.sf.oval/oval
compile group: 'net.sf.oval', name: 'oval', version: '1.90'
net.sf.oval.integration.spring.SpringValidator
«Il semble implémenter org.springframework.validation.Validator».
Je ne l'ai pas encore utilisé, alors je le signalerai à nouveau lorsque je l'essayerai.
Classe de haricots
public class SampleBean{
/** ID */
@Assert(expr = "null!=_value&&''!=_value", lang = "js"
//lang =Est"bsh" / "beanshell", "groovy", or "js" / "javascript".Choisissez celui que vous aimez et utilisez-le
//S'il s'agissait de ça@J'aurais peut-être dû utiliser NotEmpty ...
,message="L'ID n'est pas entré")
private String id;
/** No */
private Integer no;
/**Date d'inscription*/
@Assert(expr = "null!=_value&&''!=_value", lang = "js"
,message="La date d'enregistrement n'a pas été saisie")
@MatchPattern(pattern=DateUtil.DATE_MATCH_PATTERN
,message="Le format de la date d'enregistrement est étrange"
,when="js:null!=_value&&''!=_value")
@DateRange(format=DateUtil.DATE_HH_MM_FORMAT,message="La plage de dates de la date d'enregistrement est étrange")
@ValidateWithMethod(methodName="isValidDate", parameterType=String.class)
,message="Veuillez saisir la date de décembre")
private String abcTime;
//getter,setter omis
private boolean isValidDate(String arg){//Je reviendrai vrai seulement en décembre
if(arg.matches("\d{4}/12/.*")){
return true;
}else{
return false;
}
}
}
Comment équilibrer
net.sf.oval.Validator validator = new net.sf.oval.Validator();
List<ConstraintViolation> clist = validator.validate( validatedObject );
Dans ce cas, ce n'est pas une fonction standard, alors créez votre propre annotation de validation et méthode de contrôle. C'est plus intelligent d'écrire en java8, mais comme je ne peux utiliser que l'environnement java7 (T-T), c'est le code java7.
ValidateWithStaticMethod.java(Annotation)
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.sf.oval.ConstraintTarget;
import net.sf.oval.ConstraintViolation;
import net.sf.oval.configuration.annotation.Constraint;
import net.sf.oval.configuration.annotation.Constraints;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD, ElementType.TYPE })
@Constraint(checkWith = ValidateWithStaticMethodCheck.class)
public @interface ValidateWithStaticMethod {
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD, ElementType.TYPE })
@Constraints
public @interface List {
ValidateWithStaticMethod[] value();
String when() default "";
}
ConstraintTarget[] appliesTo() default ConstraintTarget.CONTAINER;
String errorCode() default "net.sf.oval.constraint.ValidateWithMethod";
boolean ignoreIfNull() default true;
boolean ignoreIfNullOrEmpty() default true;
String message() default "Le message n'est pas défini(ValidateWithStaticMethod)";
Class<?> clazz();
String methodName();
String[] profiles() default {};
int severity() default 0;
String target() default "";
String when() default "";
}
ValidateWithStaticMethodCheck.java(Vérifier la logique)
import static net.sf.oval.Validator.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import net.sf.oval.ConstraintTarget;
import net.sf.oval.Validator;
import net.sf.oval.configuration.annotation.AbstractAnnotationCheck;
import net.sf.oval.context.OValContext;
import net.sf.oval.exception.ReflectionException;
/**
*Vérifier par méthode statique
*/
public class ValidateWithStaticMethodCheck extends AbstractAnnotationCheck<ValidateWithStaticMethod> {
private static final long serialVersionUID = 1L;
private final Map<Class<?>, Method> validationMethodsByClass = new WeakHashMap<Class<?>, Method>();
private boolean ignoreIfNull;
private boolean ignoreIfNullOrEmpty;
private Class<?> clazz;
private String methodName;
@Override
public void configure(final ValidateWithStaticMethod constraintAnnotation) {
super.configure(constraintAnnotation);
setMethodName(constraintAnnotation.methodName());
setClazz(constraintAnnotation.clazz());
setIgnoreIfNull(constraintAnnotation.ignoreIfNull());
setIgnoreIfNullOrEmpty(constraintAnnotation.ignoreIfNullOrEmpty());
}
@Override
protected Map<String, String> createMessageVariables() {
final Map<String, String> messageVariables = getCollectionFactory().createMap(4);
messageVariables.put("ignoreIfNull", Boolean.toString(ignoreIfNull));
messageVariables.put("ignoreIfNullOrEmpty", Boolean.toString(ignoreIfNullOrEmpty));
messageVariables.put("methodName", methodName);
return messageVariables;
}
@Override
protected ConstraintTarget[] getAppliesToDefault() {
return new ConstraintTarget[] { ConstraintTarget.VALUES };
}
public String getMethodName() {
return methodName;
}
public boolean isIgnoreIfNull() {
return ignoreIfNull;
}
public boolean isSatisfied(final Object validatedObject, final Object valueToValidate, final OValContext context, final Validator validator)
throws ReflectionException {
if (valueToValidate == null && ignoreIfNull)
return true;
if(ignoreIfNullOrEmpty){
if (valueToValidate == null)
return true;
//Si vous souhaitez ajouter une condition de jugement vide, veuillez l'ajouter ici
if ( valueToValidate instanceof String && "".equals(valueToValidate) )
return true;
if ( valueToValidate instanceof Object[] && 0==((Object[])valueToValidate).length )
return true;
if ( valueToValidate instanceof List && 0==((List<?>)valueToValidate).size() )
return true;
}
boolean result;
Method method;
try {
Class<?> parameterType = valueToValidate.getClass();
method = clazz.getMethod(methodName, parameterType);
result = (boolean)method.invoke(null, valueToValidate);
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new ReflectionException( e );
}
return result;
}
public void setIgnoreIfNull(final boolean ignoreIfNull) {
this.ignoreIfNull = ignoreIfNull;
requireMessageVariablesRecreation();
}
public void setIgnoreIfNullOrEmpty(final boolean ignoreIfNullOrEmpty) {
this.ignoreIfNullOrEmpty = ignoreIfNullOrEmpty;
requireMessageVariablesRecreation();
}
public Class<?> getClazz() {
return clazz;
}
public void setClazz(Class<?> clazz) {
this.clazz = clazz;
}
public void setMethodName(final String methodName) {
this.methodName = methodName;
synchronized (validationMethodsByClass) {
validationMethodsByClass.clear();
}
requireMessageVariablesRecreation();
}
}
Comment annoter
//ValidationMethods.isFormatTelNo(String str)Exemple de code lors de l'utilisation
@ValidateWithStaticMethod(clazz=ValidationMethods.class
,methodName="isFormatTelNo"
,message="Le numéro de téléphone est incorrect. .. ..")
private String telNo;
Il semble que vous devriez écrire comme ça.
@ValidateWithStaticMethod.List(value={
@ValidateWithStaticMethod(clazz=ValidationMethods.class
,methodName="isFormatTelNo"
,message="Le format du numéro de téléphone est étrange"),
@ValidateWithStaticMethod(clazz=ValidationMethods.class
,methodName="isOkTelNumberSize"
,message="Le nombre de chiffres du numéro de téléphone est incorrect")
})
private String telNo;