Spring Boot应用使用Validation校验入参，现有注解不满足，我是怎么暴力扩展validation注解的

前言#

昨天，我开发的代码，又收获了一个bug，说是界面上列表查询时，正常情况下，可以根据某个关键字keyword模糊查询，后台会去数据库 %keyword%查询（非互联网项目，没有使用es，只能这样了）；但是，当输入%字符时，可以模糊匹配出所有的记录，就好像，好像这个条件没进行过滤一样。

原因很简单，当输入%时，最终出来的sql，就是%%%这样的。

我们用的mybatis plus，写法如下，看来这样是有问题的（bug警告）：

Copy
QueryWrapper<QueryUserListReqVO> wrapper = new QueryWrapper<>();
if (StringUtils.isNotBlank(reqVO.getIncidentNumber())) {
  // 如果传入的条件不为空，需要模糊查询
  wrapper.and(i -> i.like("i.incident_number", reqVO.getIncidentNumber()));
}
//根据wrapper去查询
return this.baseMapper.getAppealedNormalIncidentList( wrapper);

mapper层代码如下（以下仅为演示，单表肯定不直接写sql了，哈哈）：

Copy
public interface IncidentAppealInformationMapper extends BaseMapper<IncidentAppealInformation> {

    @Select("SELECT \n" +
            "  * \n"
            " FROM\n" +
            "  incident_appeal_information a ${ew.customSqlSegment}")
    List<GetAppealedNormalIncidentListRespVO> getAppealedNormalIncidentList(@Param(Constants.WRAPPER)QueryWrapper wrapper);

当输入的条件为%时，我们看看console打印的sql：

问题找到了，看看怎么改吧。

项目源码在（建议先看代码，再看本文，会容易一些）：
https://gitee.com/ckl111/all-simple-demo-in-work/tree/master/spring-boot-validation-demo

修改方法#

闲言少叙，我想的办法是，判断请求参数，正常情况下，请求参数里都不会有这种%字符。问题是，我们有很多地方的列表查询有这个问题，懒得一个一个写if/else，作为懒人，肯定要想想办法了，那就是使用java ee规范里的validation。

使用spring validation的demo，可以看看博主的码云：

https://gitee.com/ckl111/all-simple-demo-in-work/tree/master/spring-boot-validation-demo

简单的使用方法如下：

所以，我解决这个问题的办法就是，自定义一个注解，加在支持模糊查询的字段上，在该注解的处理handler中，判断是否包含了特殊字符%，如果包含了，直接给客户端抛错误码。

定了方向，说干就干，我这里没有第一时间去搜索答案，因为感觉也不是很难，好像自己可以搞定的样子，哈哈。

那就开始吧。

理顺原有逻辑，找准扩展方式#

因为，我知道这类validation注解，主要是在validation-api的包里，maven坐标：

Copy
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
        </dependency>

然后呢，这个包是java ee 规范的，只定义，不实现，实现的话，hibernate对这个进行了实现，spring-boot-starter-web里默认也引了这个依赖。

所以，大家可以这么理解，validation-api定义了基本的注解，然后hibernate-validator进行了实现，并且，扩展了一部分注解，我随便找了两个，比如

org.hibernate.validator.constraints.Length，校验字符串长度是否在指定的范围内

org.hibernate.validator.constraints.Email，校验指定字符串为一个有效的email地址

我本地工程都是maven管理，且下载了源码的，所以直接查找 org.hibernate.validator.constraints.Email的引用的地方，即发现了下面这个代码org.hibernate.validator.internal.metadata.core.ConstraintHelper：

所以，我们只要想办法，在这里面加上我们自己的一条记录就行了，最简单的办法是，把代码给它覆盖了，但是，我还是有底线的，能扩展就扩展，实在不行了，再覆盖。

分析了一下，这个地方，是org.hibernate.validator.internal.metadata.core.ConstraintHelper的构造函数里，先是new了一个hashmap，把这些注解和注解处理器put进去后，再用下面的代码赋给了类中的field：

Copy
// 一个map，key：注解class，value：能够处理该注解class的handler的描述符
@Immutable
private final Map<Class<? extends Annotation>, List<? extends ConstraintValidatorDescriptor<?>>> builtinConstraints;

public ConstraintHelper() {
	Map<Class<? extends Annotation>, List<ConstraintValidatorDescriptor<?>>> tmpConstraints = new HashMap<>();

	// Bean Validation constraints
	putConstraint( tmpConstraints, Email.class, EmailValidator.class );
	this.builtinConstraints = Collections.unmodifiableMap( tmpConstraints );
}

所以，我的思路是，等这个类的构造函数被调用后，修改下这个map。那，先得看看怎么操纵这个类的构造函数在哪被调用的？经过查找，发现是在org.hibernate.validator.internal.engine.ValidatorFactoryImpl#ValidatorFactoryImpl:

Copy
public ValidatorFactoryImpl(ConfigurationState configurationState) {
		ClassLoader externalClassLoader = getExternalClassLoader( configurationState );

		this.valueExtractorManager = new ValueExtractorManager( configurationState.getValueExtractors() );
		this.beanMetaDataManagers = new ConcurrentHashMap<>();
        // 这里new了一个上面类的实例
		this.constraintHelper = new ConstraintHelper();
}

继续追踪，发现在

Copy
## org.hibernate.validator.HibernateValidator
public class HibernateValidator implements ValidationProvider<HibernateValidatorConfiguration> {
	...
      
	@Override
	public ValidatorFactory buildValidatorFactory(ConfigurationState configurationState) {
		// 这里new了该类的实例	
      	return new ValidatorFactoryImpl( configurationState );
	}
}

到这里，我们可以在上面这里，打个断点，看看什么场景下，会走到这里来了：

走到上图的最后一步时，会进入到单独的线程来做以上动作：

Copy
org.springframework.boot.autoconfigure.BackgroundPreinitializer.ValidationInitializer
/**
 * Early initializer for javax.validation.
 */
private static class ValidationInitializer implements Runnable {

  @Override
  public void run() {
    Configuration<?> configuration = Validation.byDefaultProvider().configure();
    configuration.buildValidatorFactory().getValidator();
  }

}

我们接着看，看什么情况会走到我们之前的

Copy
## org.hibernate.validator.HibernateValidator
public class HibernateValidator implements ValidationProvider<HibernateValidatorConfiguration> {
	...
      
	@Override
	public ValidatorFactory buildValidatorFactory(ConfigurationState configurationState) {
		// 这里new了该类的实例	
      	return new ValidatorFactoryImpl( configurationState );
	}
}

经过跟踪，发现在以下地方进入的：

Copy
	@Override
	public final ValidatorFactory buildValidatorFactory() {
      loadValueExtractorsFromServiceLoader();
      parseValidationXml();

      for ( ValueExtractorDescriptor valueExtractorDescriptor : valueExtractorDescriptors.values() ) {
        validationBootstrapParameters.addValueExtractorDescriptor( valueExtractorDescriptor );
      }

      ValidatorFactory factory = null;
      if ( isSpecificProvider() ) {
        factory = validationBootstrapParameters.getProvider().buildValidatorFactory( this );
      }
      else {
          //如果没有指定validator，则会进入该分支，一般默认都进入该分支了
          final Class<? extends ValidationProvider<?>> providerClass = validationBootstrapParameters.getProviderClass();
          if ( providerClass != null ) {
            for ( ValidationProvider<?> provider : providerResolver.getValidationProviders() ) {
              if ( providerClass.isAssignableFrom( provider.getClass() ) ) {
                factory = provider.buildValidatorFactory( this );
                break;
              }
            }
            if ( factory == null ) {
              throw LOG.getUnableToFindProviderException( providerClass );
            }
          }
          else {
            //进入这里，是因为，参数里没指定provider class，provider class可以在classpath下的META-			   INF/validation.xml中指定
            
            // 这里，providerResolver会去根据自己的规则，获取validationProvider class集合
            List<ValidationProvider<?>> providers = providerResolver.getValidationProviders();               // 取第一个集合中的provider，这里的providers.get(0)一般就会取到前面我们说的                         // HibernateValidator
            factory = providers.get( 0 ).buildValidatorFactory( this );
          }
        
      }

		return factory;
	}

这段逻辑，还是有点绕的，先说说，频繁出现的provider是啥意思？

我先来，其实，这就是个工厂。

然后，让api来话事，这个类，javax.validation.spi.ValidationProvider出现在validation-api包里。我们说了，这个包，只管定接口，不管实现。

Copy
public interface ValidationProvider<T extends Configuration<T>> {
	... 

	/**
	 * 构造一个ValidatorFactory并返回
	 * 
	 * Build a {@link ValidatorFactory} using the current provider implementation.
	 * <p>
	 * The {@code ValidatorFactory} is assembled and follows the configuration passed
	 * via {@link ConfigurationState}.
	 * <p>
	 * The returned {@code ValidatorFactory} is properly initialized and ready for use.
	 *
	 * @param configurationState the configuration descriptor
	 * @return the instantiated {@code ValidatorFactory}
	 * @throws ValidationException if the {@code ValidatorFactory} cannot be built
	 */
	ValidatorFactory buildValidatorFactory(ConfigurationState configurationState);
}

既然说了，这个接口，只管接口，不管实现；那么实现在哪指定呢？

这个是利用了SPI机制，javax.validation.spi.ValidationProvider的实现在下面这个地方指定：

然后，我再画个图来说，前面查找provider的简易流程：

所以，大家如果对SPI机制有了解的话，那么我们可以在classpath下，自定义一个ValidationProvider，比如像下面这样：

通过SPI机制扩展ValidationProvider#

这里看看我们是怎么自定义com.example.webdemo.config.CustomHibernateValidator的：

Copy
package com.example.webdemo.config;

import lombok.extern.slf4j.Slf4j;
import org.hibernate.validator.HibernateValidator;
import org.hibernate.validator.internal.engine.ValidatorFactoryImpl;

import javax.validation.ValidatorFactory;
import javax.validation.spi.ConfigurationState;
import java.lang.reflect.Field;

@Slf4j
public class CustomHibernateValidator extends HibernateValidator{

    @Override
    public ValidatorFactory buildValidatorFactory(ConfigurationState configurationState) {
        ValidatorFactoryImpl validatorFactory = new ValidatorFactoryImpl(configurationState);
        // 修改validatorFactory中原有的ConstraintHelper
        CustomConstraintHelper customConstraintHelper = new CustomConstraintHelper();
        try {
            Field field = validatorFactory.getClass().getDeclaredField("constraintHelper");
            field.setAccessible(true);
            field.set(validatorFactory,customConstraintHelper);
        } catch (IllegalAccessException | NoSuchFieldException e) {
            log.error("{}",e);
        }
        // 我们自定义的CustomConstraintHelper，继承了原有的
        // org.hibernate.validator.internal.metadata.core.ConstraintHelper,这里对
        // 原有类中的注解--》注解处理器map进行修改，放进我们自定义的注解和注解处理器
        customConstraintHelper.moidfy();

        return validatorFactory;
    }
}

自定义的CustomConstraintHelper#

Copy
package com.example.webdemo.config;

import com.example.webdemo.annotation.SpecialCharNotAllowed;
import com.example.webdemo.annotation.SpecialCharValidator;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorDescriptor;
import org.hibernate.validator.internal.metadata.core.ConstraintHelper;

import javax.validation.ConstraintValidator;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
public class CustomConstraintHelper extends ConstraintHelper {

    public CustomConstraintHelper() {
        super();
    }

    void moidfy(){
        Field field = null;
        try {
            field = this.getClass().getSuperclass().getDeclaredField("builtinConstraints");
            field.setAccessible(true);

            Object o = field.get(this);

            // 因为field被定义为了private final，且实际类型为
            // this.builtinConstraints = Collections.unmodifiableMap( tmpConstraints );
            // 因为不能修改，所以我这里只能拷贝到一个新的hashmap，再反射设置回去
            Map<Class<? extends Annotation>, List<? extends ConstraintValidatorDescriptor<?>>> modifiedMap = new HashMap<>();
            modifiedMap.putAll((Map<? extends Class<? extends Annotation>, ? extends List<? extends ConstraintValidatorDescriptor<?>>>) o);
            // 在这里注册我们自定义的注解和注解处理器
            modifiedMap.put( SpecialCharNotAllowed.class,
                    Collections.singletonList( ConstraintValidatorDescriptor.forClass( SpecialCharValidator.class, SpecialCharNotAllowed.class ) ) );

            /**
             * 设置回field
             */
            field.set(this,modifiedMap);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            log.error("{}",e);
        }

    }


    private static <A extends Annotation> void putConstraint(Map<Class<? extends Annotation>, List<ConstraintValidatorDescriptor<?>>> validators,
                                                             Class<A> constraintType, Class<? extends ConstraintValidator<A, ?>> validatorType) {
        validators.put( constraintType, Collections.singletonList( ConstraintValidatorDescriptor.forClass( validatorType, constraintType ) ) );
    }
}

自定义的注解和处理器#

Copy
package com.example.webdemo.annotation;

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)
public @interface SpecialCharNotAllowed {
//    String message() default "{javax.validation.constraints.Min.message}";
    String message() default "special char like '%' is illegal";

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

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

}

Copy
package com.example.webdemo.annotation;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;


public class SpecialCharValidator implements ConstraintValidator<SpecialCharNotAllowed, Object> {

    @Override
    public boolean isValid(Object object, ConstraintValidatorContext constraintValidatorContext) {
        if (object == null) {
            return true;
        }
        if (object instanceof String) {
            String str = (String) object;
            if (str.contains("%")) {
                return false;
            }
        }
        return true;
    }
}