深入了解数据校验（Bean Validation）：基础类打点（ValidationProvider、ConstraintDescriptor、ConstraintValidator）【享学Java】（中）

public class ParameterMessageInterpolator extends AbstractMessageInterpolator {
  @Override
  public String interpolate(Context context, Locale locale, String term) {
    // 简单的说就是以$打头，就认为是EL表达式  啥都不处理
    if ( InterpolationTerm.isElExpression( term ) ) {
      return term;
    } else {
      // 核心处理方法是context.getConstraintDescriptor().getAttributes().get( parameter ) 拿到对应的值
      ParameterTermResolver parameterTermResolver = new ParameterTermResolver();
      return parameterTermResolver.interpolate( context, term );
    }
  }
}

public interface TraversableResolver {
  // 是否是可达的
  boolean isReachable(Object traversableObject,
            Node traversableProperty,
            Class<?> rootBeanType,
            Path pathToTraversableObject,
            ElementType elementType);
  // 是否是可级联的
  boolean isCascadable(Object traversableObject,
             Node traversableProperty,
             Class<?> rootBeanType,
             Path pathToTraversableObject,
             ElementType elementType);
}

public interface ConstraintValidatorFactory {
  <T extends ConstraintValidator<?, ?>> T getInstance(Class<T> key);
  // 释放方法是提供给Spring容器集成时 .destroyBean(instance);的
  void releaseInstance(ConstraintValidator<?, ?> instance);
}

public class ConstraintValidatorFactoryImpl implements ConstraintValidatorFactory {
  // NewInstance的run方法最终就是执行了这句话：clazz.getConstructor().newInstance()而已
  // 因此最终就是创建了一个key的实例而已~  Spring相关的会把它和Bean容器结合起来
  @Override
  public final <T extends ConstraintValidator<?, ?>> T getInstance(Class<T> key) {
    return run( NewInstance.action( key, "ConstraintValidator" ) );
  }
  @Override
  public void releaseInstance(ConstraintValidator<?, ?> instance) {
    // noop
  }
  // 入参是个函数式接口:java.security.PrivilegedAction
  private <T> T run(PrivilegedAction<T> action) {
    return System.getSecurityManager() != null ? AccessController.doPrivileged( action ) : action.run();
  }
}

public interface ParameterNameProvider {
  List<String> getParameterNames(Constructor<?> constructor);
  List<String> getParameterNames(Method method);
}

public class DefaultParameterNameProvider implements ParameterNameProvider {
  @Override
  public List<String> getParameterNames(Constructor<?> constructor) {
    return doGetParameterNames( constructor );
  }
  @Override
  public List<String> getParameterNames(Method method) {
    return doGetParameterNames( method );
  }
  // Executable是1.8提供的抽象类。两个子类刚好就是：Method和Constructor
  // 因此在Java8后一个方法搞定：executable.getParameters();
  private List<String> doGetParameterNames(Executable executable) {
    Parameter[] parameters = executable.getParameters();
    List<String> parameterNames = new ArrayList<>( parameters.length );
    for ( Parameter parameter : parameters ) {
      parameterNames.add( parameter.getName() );
    }
    return Collections.unmodifiableList( parameterNames );
  }
}

    public static void main(String[] args) {
        DefaultParameterNameProvider parameterNameProvider = new DefaultParameterNameProvider();
        // 拿到Person的无参构造和有参构造（@NoArgsConstructor和@AllArgsConstructor）
        Arrays.stream(Person.class.getConstructors()).forEach(c -> {
            List<String> parameterNames = parameterNameProvider.getParameterNames(c);
            System.out.println(parameterNames);
        });
        // Method此处我就省略不写了 
    }

public class DefaultClockProvider implements ClockProvider {
  public static final DefaultClockProvider INSTANCE = new DefaultClockProvider();
  // 单例的存在
  private DefaultClockProvider() {
  }
  @Override
  public Clock getClock() {
    return Clock.systemDefaultZone();
  }
}

public interface ValueExtractor<T> {
  // 从原始值originalValue提取到receiver里
  void extractValues(T originalValue, ValueReceiver receiver);
  // 提供一组方法，用于接收ValueExtractor提取出来的值
  // 必须将该值传递给与原始值类型对应的最佳方法。
  interface ValueReceiver {
    // 接收从对象中提取的值。
    void value(String nodeName, Object object);
    // 接收从未编入索引的可ITerable对象中提取的值，如List、Map、Iterable等
    void iterableValue(String nodeName, Object object);
    // 处理List
    void indexedValue(String nodeName, int i, Object object);
    // 处理Map
    void keyedValue(String nodeName, Object key, Object object);
  }
}

// 这种泛型的写法非常有意思~int @ExtractedValue[]代表int数组  并且还是使用了@ExtractedValue标注的
class IntArrayValueExtractor implements ValueExtractor<int @ExtractedValue[]> {
  static final ValueExtractorDescriptor DESCRIPTOR = new ValueExtractorDescriptor( new IntArrayValueExtractor() );
  private IntArrayValueExtractor() {
  }
  @Override
  public void extractValues(int[] originalValue, ValueReceiver receiver) {
    for ( int i = 0; i < originalValue.length; i++ ) {
      receiver.indexedValue( NodeImpl.ITERABLE_ELEMENT_NODE_NAME, i, originalValue[i] );
    }
  }
}
class IterableValueExtractor implements ValueExtractor<Iterable<@ExtractedValue ?>> {
  ...
  @Override
  public void extractValues(Iterable<?> originalValue, ValueReceiver receiver) {
    for ( Object object : originalValue ) {
      receiver.iterableValue( NodeImpl.ITERABLE_ELEMENT_NODE_NAME, object );
    }
  }
}
class OptionalValueExtractor implements ValueExtractor<Optional<@ExtractedValue ?>> {
  ...
  @Override
  public void extractValues(Optional<?> originalValue, ValueExtractor.ValueReceiver receiver) {
    receiver.value( null, originalValue.isPresent() ? originalValue.get() : null );
  }
}