Java HttpResponse.from方法代码示例

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
/**
 * Resolves all {@link ProjectRole}s of the current user and puts them into {@link RequestContext}
 * attributes.
 */
@Override
public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception {

    final User user = AuthenticationUtil.currentUser(ctx);

    final CompletionStage<Map<String, ProjectRole>> future;
    if (user instanceof UserWithToken) {
        future = mds.findRole(((UserWithToken) user).secret());
    } else {
        future = mds.findRoles(user);
    }

    return HttpResponse.from(future.thenApplyAsync(map -> {
        try {
            ctx.attr(ROLE_MAP).set(map::get);
            return delegate().serve(ctx, req);
        } catch (Exception e) {
            return Exceptions.throwUnsafely(e);
        }
    }, ctx.contextAwareEventLoop()));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
protected HttpResponse doPost(ServiceRequestContext ctx, HttpRequest req) {
    CompletableFuture<HttpResponse> responseFuture = new CompletableFuture<>();
    HttpResponse res = HttpResponse.from(responseFuture);
    req.subscribe(new StreamConsumer(ctx.eventLoop(), slow) {
        @Override
        public void onError(Throwable cause) {
            responseFuture.complete(
                    HttpResponse.of(
                            HttpStatus.INTERNAL_SERVER_ERROR,
                            MediaType.PLAIN_TEXT_UTF_8,
                            Throwables.getStackTraceAsString(cause)));
        }

        @Override
        public void onComplete() {
            responseFuture.complete(
                    HttpResponse.of(
                            HttpStatus.OK, MediaType.PLAIN_TEXT_UTF_8, "%d", numReceivedBytes()));
        }
    });
    return res;
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
protected HttpResponse doPost(ServiceRequestContext ctx, HttpRequest req) {

    final SerializationFormat serializationFormat = determineSerializationFormat(req);
    if (serializationFormat == null) {
        return HttpResponse.of(HttpStatus.UNSUPPORTED_MEDIA_TYPE,
                               MediaType.PLAIN_TEXT_UTF_8, PROTOCOL_NOT_SUPPORTED);
    }

    if (!validateAcceptHeaders(req, serializationFormat)) {
        return HttpResponse.of(HttpStatus.NOT_ACCEPTABLE,
                               MediaType.PLAIN_TEXT_UTF_8, ACCEPT_THRIFT_PROTOCOL_MUST_MATCH_CONTENT_TYPE);
    }

    CompletableFuture<HttpResponse> responseFuture = new CompletableFuture<>();
    HttpResponse res = HttpResponse.from(responseFuture);
    ctx.logBuilder().serializationFormat(serializationFormat);
    ctx.logBuilder().deferRequestContent();
    req.aggregate().handle(voidFunction((aReq, cause) -> {
        if (cause != null) {
            responseFuture.complete(
                    HttpResponse.of(
                            HttpStatus.INTERNAL_SERVER_ERROR,
                            MediaType.PLAIN_TEXT_UTF_8, Throwables.getStackTraceAsString(cause)));
            return;
        }

        decodeAndInvoke(ctx, aReq, serializationFormat, responseFuture);
    })).exceptionally(CompletionActions::log);
    return res;
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
protected HttpResponse doExecute(ClientRequestContext ctx, HttpRequest req) throws Exception {
    final CompletableFuture<HttpResponse> responseFuture = new CompletableFuture<>();
    final HttpResponse res = HttpResponse.from(responseFuture);
    final HttpRequestDuplicator reqDuplicator = new HttpRequestDuplicator(req, 0, ctx.eventLoop());
    doExecute0(ctx, reqDuplicator, responseFuture);
    return res;
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception {
    return HttpResponse.from(authorize(req, ctx).handleAsync((result, t) -> {
        try {
            if (t != null || !result) {
                return onFailure(ctx, req, t);
            } else {
                return onSuccess(ctx, req);
            }
        } catch (Exception e) {
            return Exceptions.throwUnsafely(e);
        }
    }, ctx.contextAwareEventLoop()));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
protected final HttpResponse doPost(ServiceRequestContext ctx, HttpRequest req) {
    return HttpResponse.from(req.aggregate()
       .thenApply(this::echo)
       .exceptionally(CompletionActions::log));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception {
    final HttpHeaders clientHeaders = req.headers();
    final MediaType contentType = clientHeaders.contentType();
    if (contentType == null) {
        // All gRPC requests, whether framed or non-framed, must have content-type. If it's not sent, let
        // the delegate return its usual error message.
        return delegate().serve(ctx, req);
    }

    for (SerializationFormat format : GrpcSerializationFormats.values()) {
        if (format.isAccepted(contentType)) {
            // Framed request, so just delegate.
            return delegate().serve(ctx, req);
        }
    }

    String methodName = GrpcRequestUtil.determineMethod(ctx);
    MethodDescriptor<?, ?> method = methodName != null ? methodsByName.get(methodName) : null;
    if (method == null) {
        // Unknown method, let the delegate return a usual error.
        return delegate().serve(ctx, req);
    }

    if (method.getType() != MethodType.UNARY) {
        return HttpResponse.of(HttpStatus.BAD_REQUEST,
                               MediaType.PLAIN_TEXT_UTF_8,
                               "Only unary methods can be used with non-framed requests.");
    }

    HttpHeaders grpcHeaders = HttpHeaders.copyOf(clientHeaders);

    final MediaType framedContentType;
    if (contentType.is(MediaType.PROTOBUF)) {
        framedContentType = GrpcSerializationFormats.PROTO.mediaType();
    } else if (contentType.is(MediaType.JSON_UTF_8)) {
        framedContentType = GrpcSerializationFormats.JSON.mediaType();
    } else {
        return HttpResponse.of(HttpStatus.UNSUPPORTED_MEDIA_TYPE,
                               MediaType.PLAIN_TEXT_UTF_8,
                               "Unsupported media type. Only application/protobuf is supported.");
    }
    grpcHeaders.contentType(framedContentType);

    if (grpcHeaders.get(GrpcHeaderNames.GRPC_ENCODING) != null) {
        return HttpResponse.of(HttpStatus.UNSUPPORTED_MEDIA_TYPE,
                               MediaType.PLAIN_TEXT_UTF_8,
                               "gRPC encoding is not supported for non-framed requests.");
    }

    // All clients support no encoding, and we don't support gRPC encoding for non-framed requests, so just
    // clear the header if it's present.
    grpcHeaders.remove(GrpcHeaderNames.GRPC_ACCEPT_ENCODING);

    final CompletableFuture<HttpResponse> responseFuture = new CompletableFuture<>();
    final HttpResponse res = HttpResponse.from(responseFuture);
    req.aggregate().whenCompleteAsync(
            (clientRequest, t) -> {
                if (t != null) {
                    responseFuture.completeExceptionally(t);
                } else {
                    frameAndServe(ctx, grpcHeaders, clientRequest, responseFuture);
                }
            },
            ctx.eventLoop());
    return res;
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
protected HttpResponse doPut(ServiceRequestContext ctx, HttpRequest req) throws Exception {
    return HttpResponse.from(
            updateHealthStatus(ctx, req).thenApply(HttpResponse::of)
                                        .exceptionally(HttpResponse::ofFailure));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception {
    return HttpResponse.from(delegate.serve(ctx, req));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Get("/resp1")
public HttpResponse httpResponse(ServiceRequestContext ctx, HttpRequest req) {
    return HttpResponse.from(raiseExceptionImmediately());
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Get("/resp2")
@ExceptionHandler(NoExceptionHandler.class)
@ExceptionHandler(AnticipatedExceptionHandler2.class)
public HttpResponse asyncHttpResponse(ServiceRequestContext ctx, HttpRequest req) {
    return HttpResponse.from(completeExceptionallyLater(ctx));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Get("/bad1")
public HttpResponse bad1(ServiceRequestContext ctx, HttpRequest req) {
    return HttpResponse.from(completeExceptionallyLater(ctx));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Get("/bad2")
@ExceptionHandler(BadExceptionHandler2.class)
public HttpResponse bad2(ServiceRequestContext ctx, HttpRequest req) {
    return HttpResponse.from(completeExceptionallyLater(ctx));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Get("/handler3")
public HttpResponse handler3(ServiceRequestContext ctx, HttpRequest req) {
    return HttpResponse.from(completeExceptionallyLater(ctx));
}
 

import com.linecorp.armeria.common.HttpResponse; //导入方法依赖的package包/类
@Override
protected final HttpResponse doPost(ServiceRequestContext ctx, HttpRequest req) {
    return HttpResponse.from(req.aggregate()
                                .thenApply(this::echo)
                                .exceptionally(CompletionActions::log));
}