Java Middleware类代码示例

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
public static <T> Middleware<AsyncHandler<Response<T>>, AsyncHandler<Response<T>>> clientValidator(
    Supplier<List<String>> supplier) {
  return innerHandler -> requestContext -> {
    if (requestContext.request().header("User-Agent")
        // TODO: should the blacklist be a set so this lookup is O(1) instead of O(n) ?
        .map(header -> supplier.get().contains(header))
        .orElse(false)) {
      // TODO: fire some stats
      return
          completedFuture(Response.forStatus(Status.NOT_ACCEPTABLE.withReasonPhrase(
              "blacklisted client version, please upgrade")));
    } else {
      return innerHandler.invoke(requestContext);
    }
  };
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
public static <T> Middleware<AsyncHandler<Response<T>>, AsyncHandler<Response<T>>> exceptionHandler() {
  return innerHandler -> requestContext -> {
    try {
      return innerHandler.invoke(requestContext).handle((r, t) -> {
        if (t != null) {
          if (t instanceof ResponseException) {
            return ((ResponseException) t).getResponse();
          } else {
            throw new CompletionException(t);
          }
        } else {
          return r;
        }
      });
    } catch (ResponseException e) {
      return completedFuture(e.getResponse());
    }
  };
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
public static <T> Middleware<AsyncHandler<Response<T>>, AsyncHandler<Response<T>>> auditLogger() {
  return innerHandler -> requestContext -> {
    final Request request = requestContext.request();

    if (!"GET".equals(request.method())) {
      LOG.info("[AUDIT] {} {} by {} with headers {} parameters {} and payload {}",
               request.method(),
               request.uri(),
               auth(requestContext).user().map(idToken -> idToken.getPayload()
                   .getEmail())
                   .orElse("anonymous"),
               filterHeaders(request.headers()),
               request.parameters(),
               request.payload().map(ByteString::utf8).orElse("")
                   .replaceAll("\n", " "));
    }
    return innerHandler.invoke(requestContext);
  };
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
Stream<? extends Route<? extends AsyncHandler<? extends Response<ByteString>>>> routes() {
  final String base = "/rkt/image";

  final EntityMiddleware em =
      EntityMiddleware.forCodec(JacksonEntityCodec.forMapper(Json.OBJECT_MAPPER));

  final List<Route<AsyncHandler<Response<ByteString>>>> entityRoutes = Stream.of(
      Route.with(
          em.serializerResponse(CatManifestOutput.class),
          DEFAULT_HTTP_METHOD, base + "/cat-manifest/<id>",
          rc -> catManifest(getId(rc))),
      Route.with(
          em.serializerResponse(GcOutput.class),
          DEFAULT_HTTP_METHOD, base + "/gc",
          rc -> gc(rc.request())),
      Route.with(
          em.serializerResponse(ListOutput.class),
          DEFAULT_HTTP_METHOD, base + "/list",
          rc -> list()),
      Route.with(
          em.serializerResponse(RmOutput.class),
          DEFAULT_HTTP_METHOD, base + "/rm",
          rc -> rm(rc.request())),
      Route.with(
          em.serializerResponse(RmOutput.class),
          DEFAULT_HTTP_METHOD, base + "/rm/<id>",
          rc -> rm(getId(rc)))
  )
      .map(r -> r.withMiddleware(Middleware::syncToAsync))
      .collect(toList());

  return Api.prefixRoutes(entityRoutes, Api.Version.V0);
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
private static <T> Middleware<Requested<Authenticated<T>>, AsyncHandler<Response<ByteString>>> authed() {
  return ar -> jsonAsync().apply(requestContext -> {
    final T payload = ar
        .apply(requestContext)
        .apply(auth(requestContext));
    return completedFuture(Response.forPayload(payload));
  });
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
public static <T> Middleware<AsyncHandler<Response<T>>, AsyncHandler<Response<T>>> authValidator() {
  return h -> rc -> {
    if (!"GET".equals(rc.request().method())) {
      if (!auth(rc).user().isPresent()) {
        return completedFuture(
            Response.forStatus(Status.UNAUTHORIZED.withReasonPhrase("Unauthorized access")));
      }
    }

    return h.invoke(rc);
  };
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
public Stream<Route<AsyncHandler<Response<ByteString>>>> routes() {
  final EntityMiddleware em =
      EntityMiddleware.forCodec(JacksonEntityCodec.forMapper(Json.OBJECT_MAPPER));

  return Stream.of(
      Route.with(
          em.response(Event.class),
          "POST", BASE + "/events",
          rc -> this::injectEvent),
      Route.with(
          em.response(WorkflowInstance.class),
          "POST", BASE + "/trigger",
          rc -> this::triggerWorkflowInstance),
      Route.with(
          em.response(WorkflowInstance.class),
          "POST", BASE + "/retry",
          rc -> payload -> retryWorkflowInstanceAfter(rc, payload)),
      Route.with(
          em.response(WorkflowInstance.class),
          "POST", BASE + "/halt",
          rc -> this::haltWorkflowInstance),
      Route.with(
          em.response(WorkflowConfiguration.class, Workflow.class),
          "POST", BASE + "/workflows/<cid>",
          rc -> workflow -> createOrUpdateWorkflow(rc.pathArgs().get("cid"), workflow)),
      Route.with(
          em.serializerResponse(ByteString.class),
          "DELETE", BASE + "/workflows/<cid>/<wfid>",
          rc -> deleteWorkflow(rc.pathArgs().get("cid"), rc.pathArgs().get("wfid")))
  )

      .map(r -> r.withMiddleware(Middleware::syncToAsync));
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
Stream<? extends Route<? extends AsyncHandler<? extends Response<ByteString>>>> routes() {
  final String base = "/rkt";

  final EntityMiddleware em =
      EntityMiddleware.forCodec(JacksonEntityCodec.forMapper(Json.OBJECT_MAPPER));

  final List<Route<AsyncHandler<Response<ByteString>>>> entityRoutes = Stream.of(
      Route.with(
          em.serializerResponse(CatManifestOutput.class),
          DEFAULT_HTTP_METHOD, base + "/cat-manifest/<id>",
          rc -> catManifest(getId(rc))),
      Route.with(
          em.serializerResponse(ConfigOutput.class),
          DEFAULT_HTTP_METHOD, base + "/config",
          rc -> config()),
      Route.with(
          em.serializerResponse(FetchOutput.class),
          DEFAULT_HTTP_METHOD, base + "/fetch",
          rc -> fetch(rc.request())),
      Route.with(
          em.serializerResponse(GcOutput.class),
          DEFAULT_HTTP_METHOD, base + "/gc",
          rc -> gc(rc.request())),
      Route.with(
          em.serializerResponse(ListOutput.class),
          DEFAULT_HTTP_METHOD, base + "/list",
          rc -> list()),
      Route.with(
          em.response(PrepareOptions.class, PrepareOutput.class),
          DEFAULT_HTTP_METHOD, base + "/prepare",
          rc -> payload -> prepare(payload, rc.request())),
      Route.with(
          em.serializerResponse(RmOutput.class),
          DEFAULT_HTTP_METHOD, base + "/rm",
          rc -> rm(rc.request())),
      Route.with(
          em.serializerResponse(RmOutput.class),
          DEFAULT_HTTP_METHOD, base + "/rm/<id>",
          rc -> rm(getId(rc))),
      Route.with(
          em.response(RunOptions.class, RunOutput.class),
          DEFAULT_HTTP_METHOD, base + "/run",
          rc -> payload -> run(rc.request(), payload)),
      Route.with(
          em.serializerResponse(RunOutput.class),
          DEFAULT_HTTP_METHOD, base + "/run-prepared/<id>",
          rc -> runPrepared(getId(rc), rc.request())),
      Route.with(
          em.serializerResponse(StatusOutput.class),
          DEFAULT_HTTP_METHOD, base + "/status/<id>",
          rc -> status(getId(rc), rc.request())),
      Route.with(
          em.serializerResponse(StopOutput.class),
          DEFAULT_HTTP_METHOD, base + "/stop",
          rc -> stop(rc.request())),
      Route.with(
          em.serializerResponse(StopOutput.class),
          DEFAULT_HTTP_METHOD, base + "/stop/<id>",
          rc -> stop(getId(rc), rc.request())),
      Route.with(
          em.serializerResponse(TrustOutput.class),
          DEFAULT_HTTP_METHOD, base + "/trust",
          rc -> trust(rc.request())),
      Route.with(
          em.serializerResponse(VersionOutput.class),
          DEFAULT_HTTP_METHOD, base + "/version",
          rc -> version())
  )
      .map(r -> r.withMiddleware(Middleware::syncToAsync))
      .collect(toList());

  return Api.prefixRoutes(entityRoutes, Api.Version.V0);
}
 

import com.spotify.apollo.route.Middleware; //导入依赖的package包/类
public static Middleware<SyncHandler<? extends Response<?>>, AsyncHandler<Response<ByteString>>>
    json() {
  return innerHandler -> jsonAsync().apply(Middleware.syncToAsync(innerHandler));
}