org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate#org.apiguardian.api.API源码实例Demo

@API(status = API.Status.INTERNAL)
@ExceptionHandler(value = LocServiceException.class)
default ResponseEntity<Problem> handleHnServiceException(
    final LocServiceException hnServiceException, final NativeWebRequest request) {
  int code = hnServiceException.getCode();
  if(code < 0) {
    code *= -1;
  }

  if(code < 10000) {
    code += 10000;
  }
  return this.create(hnServiceException,
      ProblemUtil.createProblem(hnServiceException.getMsg(), code),
      request);
}
 

@API(status = EXPERIMENTAL)
default RoutingTree<A> merge(final RoutingTree<A> other) {
    final Map<A, Route> bindings = new LinkedHashMap<>(keySet().size() + other.keySet().size());

    keySet().forEach(attribute ->
            bindings.merge(attribute, get(attribute)
                    .orElseThrow(IllegalStateException::new), Route::merge));

    getWildcard().ifPresent(route ->
            bindings.merge(null, route, Route::merge));

    other.keySet().forEach(attribute ->
            bindings.merge(attribute, other.get(attribute)
                    .orElseThrow(IllegalStateException::new), Route::merge));

    other.getWildcard().ifPresent(route ->
            bindings.merge(null, route, Route::merge));

    return dispatch(getNavigator(), bindings.entrySet().stream()
            .map(e -> Binding.create(e.getKey(), e.getValue()))
            .collect(toList()));
}
 

@API(status = EXPERIMENTAL)
public static QueryFilter replaceQuery(
        final Predicate<String> predicate, final String replacement) {

    final Pattern pattern = compile("(?<name>[^&]*?)=(?:[^&]*)");

    return query -> {
        final Matcher matcher = pattern.matcher(query);
        final StringBuffer result = new StringBuffer(query.length());

        while (matcher.find()) {
            if (predicate.test(matcher.group("name"))) {
                matcher.appendReplacement(result, "${name}");
                result.append('=');
                result.append(replacement);
            } else {
                matcher.appendReplacement(result, "$0");
            }
        }
        matcher.appendTail(result);

        return result.toString();
    };
}
 

@API(status = EXPERIMENTAL)
public void prepare(
        final Precorrelation precorrelation,
        final HttpRequest request,
        final JsonGenerator generator) throws IOException {

    generator.writeStringField("origin",
            request.getOrigin() == LOCAL ? "local" : "remote");
    generator.writeStringField("type", "request");
    generator.writeStringField("correlation", precorrelation.getId());
    generator.writeStringField("protocol", request.getProtocolVersion());
    generator.writeStringField("remote", request.getRemote());
    generator.writeStringField("method", request.getMethod());
    generator.writeStringField("uri", reconstructUri(request));

    writeHeaders(request, generator);
    writeBody(request, generator);
}
 

@API(status = INTERNAL)
@ExceptionHandler
default Mono<ResponseEntity<Problem>> handleRequestMethodNotSupportedException(
        final MethodNotAllowedException exception,
        final ServerWebExchange request) {

    final Set<HttpMethod> methods = exception.getSupportedMethods();

    if (methods.isEmpty()) {
        return create(Status.METHOD_NOT_ALLOWED, exception, request);
    }

    final HttpHeaders headers = new HttpHeaders();
    headers.setAllow(methods);

    return create(Status.METHOD_NOT_ALLOWED, exception, request, headers);
}
 

@API(status = API.Status.INTERNAL)
@ExceptionHandler(value = ConstraintViolationException.class)
default ResponseEntity<Problem> handleConstraintViolationException(
    final ConstraintViolationException constraintViolationException,
    final NativeWebRequest request) {
  return this.create(constraintViolationException, ProblemUtil.createProblem(
      constraintViolationException.getConstraintViolations().stream()
          .map(ConstraintViolation::getMessage).collect(Collectors.joining(",")),
      CONSTRAINT_VIOLATION_ERROR_CODE), request);
}
 

@API(status = API.Status.INTERNAL)
@ExceptionHandler(value = BindException.class)
default ResponseEntity<Problem> handleBindException(final BindException bindException,
    final NativeWebRequest request) {
  List<FieldError> fieldErrors = bindException.getBindingResult().getFieldErrors();
  return this.create(bindException, ProblemUtil.createProblem(
      fieldErrors.stream().map(e -> e.getField() + ":" + e.getDefaultMessage())
          .collect(Collectors.joining(",")), BIND_ERROR_CODE), request);
}
 

@API(status = API.Status.INTERNAL)
@ExceptionHandler(value = MethodArgumentNotValidException.class)
default ResponseEntity<Problem> handleMethodArgumentNotValidException(
    final MethodArgumentNotValidException methodArgumentNotValidException,
    final NativeWebRequest request) {
  List<FieldError> fieldErrors = methodArgumentNotValidException.getBindingResult().getFieldErrors();
  return this.create(methodArgumentNotValidException, ProblemUtil.createProblem(
      fieldErrors.stream().map(e -> e.getField() + ":" + e.getDefaultMessage())
          .collect(Collectors.joining(",")), METHOD_ARGUMENT_NOT_VALID_ERROR_CODE), request);
}
 

@API(status = INTERNAL)
@ExceptionHandler
default ResponseEntity<Problem> handleServletRequestBinding(
        final ServletRequestBindingException exception,
        final NativeWebRequest request) {
    return create(Status.BAD_REQUEST, exception, request);
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(TagPropagation.class)
@ConditionalOnProperty(
        name = "opentracing.proxy.tag-propagation.enabled",
        havingValue = "true",
        matchIfMissing = true)
public TagPropagation tagPropagation(final ProxyProperties properties) {
    return new TagPropagation(properties.getTagPropagation().getKeys());
}
 

@API(status = INTERNAL)
MetricsCircuitBreakerListener(
        final MeterRegistry registry,
        final String metricName,
        final ImmutableList<Tag> defaultTags) {

    this(registry, metricName, defaultTags,
            new AtomicReference<>(start(registry)));
}
 

@API(status = EXPERIMENTAL)
public static BodyFilter oauthRequest() {
    final Set<String> properties = new HashSet<>();
    properties.add("client_secret");
    properties.add("password");
    return replaceFormUrlEncodedProperty(properties, "XXX");
}
 

/**
 * Creates a {@link BodyFilter} that replaces the properties in the form url encoded body with given replacement.
 *
 * @param properties  query names properties to replace
 * @param replacement String to replace the properties values
 * @return BodyFilter generated
 */
@API(status = EXPERIMENTAL)
public static BodyFilter replaceFormUrlEncodedProperty(final Set<String> properties, final String replacement) {
    final Predicate<String> formUrlEncoded = MediaTypeQuery.compile("application/x-www-form-urlencoded");

    final QueryFilter delegate =
            replaceQuery(properties::contains, replacement);

    return (contentType, body) -> formUrlEncoded.test(contentType) ? delegate.filter(body) : body;
}
 

@API(status = INTERNAL)
@ExceptionHandler
default ResponseEntity<Problem> handleInvalidRequest(
        final InvalidRequestException exception,
        final NativeWebRequest request) {

    return newConstraintViolationProblem(exception, request, exception.getValidationReport());
}
 

@API(status = EXPERIMENTAL)
public static QueryFilter removeQuery(final String name) {
    final Predicate<String> predicate = name::equals;
    final Pattern pattern = compile("&?(?<name>[^&]+?)=(?:[^&]*)");

    return query -> {
        final Matcher matcher = pattern.matcher(query);
        final StringBuffer result = new StringBuffer(query.length());

        while (matcher.find()) {
            if (predicate.test(matcher.group("name"))) {
                matcher.appendReplacement(result, "");
            } else {
                matcher.appendReplacement(result, "$0");
            }
        }
        matcher.appendTail(result);

        final String output = result.toString();

        if (output.startsWith("&")) {
            // ideally this case would be covered by the regex, but
            // I wasn't able to make it work
            return output.substring(1);
        }

        return output;
    };
}
 

@API(status = MAINTAINED)
public static <T extends HttpMessage> BodyReplacer<T> stream() {
    final Predicate<T> contentTypes = contentType(
            "application/json-seq", // https://tools.ietf.org/html/rfc7464
            "application/x-json-stream", // https://en.wikipedia.org/wiki/JSON_Streaming#Line_delimited_JSON
            "application/stream+json", // https://tools.ietf.org/html/draft-snell-activity-streams-type-01
            "text/event-stream" // https://tools.ietf.org/html/rfc6202
    );
    return replaceBody(contentTypes, "<stream>");
}
 

@API(status = INTERNAL)
@ExceptionHandler
default ResponseEntity<Problem> handleMultipart(
        final MultipartException exception,
        final NativeWebRequest request) {
    return create(Status.BAD_REQUEST, exception, request);
}
 

@API(status = INTERNAL)
@ExceptionHandler
default ResponseEntity<Problem> handleSocketTimeout(
        final SocketTimeoutException exception,
        final NativeWebRequest request) {
    return create(Status.GATEWAY_TIMEOUT, exception, request);
}
 

@API(status = INTERNAL)
@ExceptionHandler
default ResponseEntity<Problem> handleMessageNotReadableException(
        final HttpMessageNotReadableException exception,
        final NativeWebRequest request) {
    return create(Status.BAD_REQUEST, exception, request);
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(Logbook.class)
public Logbook logbook(
        final Predicate<HttpRequest> condition,
        final CorrelationId correlationId,
        final List<HeaderFilter> headerFilters,
        final List<PathFilter> pathFilters,
        final List<QueryFilter> queryFilters,
        final List<BodyFilter> bodyFilters,
        final List<RequestFilter> requestFilters,
        final List<ResponseFilter> responseFilters,
        final Strategy strategy,
        final Sink sink) {

    return Logbook.builder()
            .condition(mergeWithExcludes(mergeWithIncludes(condition)))
            .correlationId(correlationId)
            .headerFilters(headerFilters)
            .queryFilters(queryFilters)
            .pathFilters(pathFilters)
            .bodyFilters(bodyFilters)
            .requestFilters(requestFilters)
            .responseFilters(responseFilters)
            .strategy(strategy)
            .sink(sink)
            .build();
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(AutoTagging.class)
@ConditionalOnProperty(
        name = "opentracing.proxy.auto-tagging.enabled",
        havingValue = "true",
        matchIfMissing = true)
public AutoTagging autoTagging(final ProxyProperties properties) {
    final List<String> keys = properties.getAutoTagging().getKeys();
    final Map<String, String> mapping = keys.stream()
            .collect(toMap(identity(), identity()));

    return new AutoTagging(mapping);
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(HeaderFilter.class)
public HeaderFilter headerFilter() {
    final Set<String> headers = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
    headers.addAll(properties.getObfuscate().getHeaders());

    return headers.isEmpty() ?
            HeaderFilters.defaultValue() :
            replaceHeaders(headers, "XXX");
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(BodyFilter.class)
public BodyFilter bodyFilter() {
    final LogbookProperties.Write write = properties.getWrite();
    final int maxBodySize = write.getMaxBodySize();

    if (maxBodySize < 0) {
        return defaultValue();
    }

    return BodyFilter.merge(defaultValue(), truncate(maxBodySize));
}
 

@API(status = INTERNAL)
@ExceptionHandler
default ResponseEntity<Problem> handleMethodArgumentNotValid(
        final MethodArgumentNotValidException exception,
        final NativeWebRequest request) {
    return newConstraintViolationProblem(exception, createViolations(exception.getBindingResult()), request);
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(Strategy.class)
@ConditionalOnProperty(name = "logbook.strategy", havingValue = "without-body")
public Strategy withoutBody() {
    return new WithoutBodyStrategy();
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(Sink.class)
public Sink sink(
        @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection") final HttpLogFormatter formatter,
        final HttpLogWriter writer) {
    return new DefaultSink(formatter, writer);
}
 

@API(status = INTERNAL)
@Bean
@Primary
@ConditionalOnBean(Sink.class)
@ConditionalOnProperty("logbook.write.chunk-size")
public Sink chunkingSink(final Sink sink) {
    return new ChunkingSink(sink, properties.getWrite().getChunkSize());
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(HttpLogFormatter.class)
@ConditionalOnProperty(name = "logbook.format.style", havingValue = "http")
public HttpLogFormatter httpFormatter() {
    return new DefaultHttpLogFormatter();
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(HttpLogFormatter.class)
@ConditionalOnProperty(name = "logbook.format.style", havingValue = "curl")
public HttpLogFormatter curlFormatter() {
    return new CurlHttpLogFormatter();
}
 

@API(status = INTERNAL)
@Bean
@ConditionalOnMissingBean(HttpLogFormatter.class)
@ConditionalOnProperty(name = "logbook.format.style", havingValue = "splunk")
public HttpLogFormatter splunkHttpLogFormatter() {
    return new SplunkHttpLogFormatter();
}