下面列出了 io.netty.handler.codec.http.HttpRequest # method ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void handleHttpRequest(ChannelHandlerContext ctx, HttpRequest req)
throws Exception {
// Handle a bad request.
if (!req.decoderResult().isSuccess()) {
sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, BAD_REQUEST));
return;
}
// Allow only GET methods.
if (req.method() != GET) {
sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, FORBIDDEN));
return;
}
// Handshake
WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
getWebSocketLocation(req), null, false, Integer.MAX_VALUE);
handshaker = wsFactory.newHandshaker(req);
if (handshaker == null) {
WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
} else {
handshaker.handshake(ctx.channel(), req);
}
}
public static HttpRequest adapter(HttpRequest httpRequest) {
if (httpRequest instanceof DefaultHttpRequest) {
HttpVer version;
if (httpRequest.protocolVersion().minorVersion() == 0) {
version = HttpVer.HTTP_1_0;
} else {
version = HttpVer.HTTP_1_1;
}
HttpHeadsInfo httpHeadsInfo = new HttpHeadsInfo();
for (Entry<String, String> entry : httpRequest.headers()) {
httpHeadsInfo.set(entry.getKey(), entry.getValue());
}
return new HttpRequestInfo(version, httpRequest.method(), httpRequest.uri(),
httpHeadsInfo, null);
}
return httpRequest;
}
public RequestInfoImpl(@NotNull HttpRequest request) {
this(
request.uri(),
request.method(),
request.headers(),
HttpUtils.extractTrailingHeadersIfPossible(request),
null,
HttpUtils.extractCookies(request),
null,
HttpUtils.extractContentChunks(request),
request.protocolVersion(),
HttpUtil.isKeepAlive(request),
(request instanceof FullHttpRequest),
HttpPostRequestDecoder.isMultipart(request)
);
}
/**
* 获取请求参数 Map
*/
private Map<String, List<String>> getParamMap(){
Map<String, List<String>> paramMap = new HashMap<String, List<String>>();
Object msg = DataHolder.getRequest();
HttpRequest request = (HttpRequest) msg;
HttpMethod method = request.method();
if(method.equals(HttpMethod.GET)){
String uri = request.uri();
QueryStringDecoder queryDecoder = new QueryStringDecoder(uri, Charset.forName(CharEncoding.UTF_8));
paramMap = queryDecoder.parameters();
}else if(method.equals(HttpMethod.POST)){
FullHttpRequest fullRequest = (FullHttpRequest) msg;
paramMap = getPostParamMap(fullRequest);
}
return paramMap;
}
@Override
public boolean accept(ChannelHandlerContext ctx, HttpRequest req) {
if (req.method() == HttpMethod.POST && req.uri().startsWith(handlerUri)) {
try {
User superAdmin = AuthHeadersBaseHttpHandler.validateAuth(userDao, req);
if (superAdmin != null) {
ctx.channel().attr(AuthHeadersBaseHttpHandler.USER).set(superAdmin);
queryStringDecoder = new QueryStringDecoder(req.uri());
return true;
}
} catch (IllegalAccessException e) {
//return 403 and stop processing.
ctx.writeAndFlush(Response.forbidden(e.getMessage()));
return true;
}
}
return false;
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof HttpRequest) {
final HttpRequest req = (HttpRequest) msg;
final HttpMethod requestMethod = req.method();
final QueryStringDecoder queryDecoder = new QueryStringDecoder(req.uri());
final String requestPath = queryDecoder.path();
boolean disconnect = queryDecoder.parameters().containsKey(DISCONNECT);
if (disconnect) {
if (log.isDebugEnabled())
log.debug("Received HTTP disconnect request: {} {} from channel: {}", requestMethod, requestPath, ctx.channel());
final String sessionId = PipelineUtils.getSessionId(requestPath);
final Packet disconnectPacket = new Packet(PacketType.DISCONNECT, sessionId);
disconnectPacket.setOrigin(PipelineUtils.getOrigin(req));
ctx.fireChannelRead(disconnectPacket);
ReferenceCountUtil.release(msg);
return;
}
}
ctx.fireChannelRead(msg);
}
private boolean possibleRedirect(HttpRequest request, String index, String digest) {
HttpMethod method = request.method();
if (method.equals(HttpMethod.GET) ||
method.equals(HttpMethod.HEAD) ||
(method.equals(HttpMethod.PUT) &&
HttpUtil.is100ContinueExpected(request))) {
String redirectAddress;
try {
redirectAddress = blobService.getRedirectAddress(index, digest);
} catch (MissingHTTPEndpointException ex) {
simpleResponse(request, HttpResponseStatus.BAD_GATEWAY);
return true;
}
if (redirectAddress != null) {
LOGGER.trace("redirectAddress: {}", redirectAddress);
sendRedirect(request, activeScheme + redirectAddress);
return true;
}
}
return false;
}
private void handleBlobRequest(HttpRequest request, @Nullable HttpContent content) throws IOException {
if (possibleRedirect(request, index, digest)) {
return;
}
HttpMethod method = request.method();
if (method.equals(HttpMethod.GET)) {
get(request, index, digest);
reset();
} else if (method.equals(HttpMethod.HEAD)) {
head(request, index, digest);
} else if (method.equals(HttpMethod.PUT)) {
put(request, content, index, digest);
} else if (method.equals(HttpMethod.DELETE)) {
delete(request, index, digest);
} else {
simpleResponse(request, HttpResponseStatus.METHOD_NOT_ALLOWED);
}
}
public void channelRead(ChannelHandlerContext ctx, Object msg) {
if (this.logger.isEnabled(this.internalLevel)) {
HttpRequest request = (HttpRequest) msg;
String log = request.method() + " " + request.uri() + " " + request.protocolVersion() + "\n" +
CONTENT_TYPE + ": " + request.headers().get(CONTENT_TYPE) + "\n" +
CONTENT_LENGTH + ": " + request.headers().get(CONTENT_LENGTH) + "\n";
this.logger.log(this.internalLevel,ctx.channel().toString() + " READ \n" + log);
}
ctx.fireChannelRead(msg);
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, HttpObject httpObject) {
SessionContext sctx = serverContext.getSessionContextGroup().getSessionByChannel(ctx);
long now = Calendar.getInstance().getTimeInMillis();
long last = sctx.getLastRecvTime();
sctx.setLastRecvTime(now);
if ((now - last) < serverContext.getConfig().getColdDownMs()) {
serverContext.getSessionHandlerGroup().sendTooFastMsg(sctx);
}
sctx.setHeartCount(0);
try {
if (httpObject instanceof HttpRequest) {
httpRequest = (HttpRequest) httpObject;
if (!httpRequest.decoderResult().isSuccess()) {
return;
}
String uri = httpRequest.uri();
if (uri == null) {
return;
}
sctx.setSessionId(parseSessionId(httpRequest.headers().get(HttpHeaderNames.COOKIE)));
sctx.setRealAddress(ForwardedAddressUtil.parse(httpRequest.headers().get(ForwardedAddressUtil.KEY)));
HttpMethod method = httpRequest.method();
if (HttpMethod.GET.equals(method)) {
doGet(ctx, sctx);
} else if (HttpMethod.POST.equals(method)) {
postRequestDecoder = new HttpPostRequestDecoder(factory, httpRequest);
processHttpContent(ctx, sctx, (HttpContent) httpObject);
} else {
log.warn("not found request method[{}]", method.name());
}
} else if (httpObject instanceof HttpContent) {
processHttpContent(ctx, sctx, (HttpContent) httpObject);
}
} catch (Exception e) {
log.error(e.getMessage(), e);
serverContext.getSessionHandlerGroup().unableParseMsg(sctx);
}
}
@Nullable
@Override
public String getRequestHttpMethod(@Nullable HttpRequest request) {
if (request == null) {
return null;
}
HttpMethod method = request.method();
if (method == null) {
return null;
}
return method.name();
}
protected @NotNull String getFallbackSpanName(@NotNull HttpRequest downstreamRequest) {
try {
HttpMethod method = downstreamRequest.method();
String methodName = (method == null) ? null : method.name();
return HttpRequestTracingUtils.getFallbackSpanNameForHttpRequest("async_downstream_call", methodName);
}
catch (Throwable t) {
logger.error(
"An unexpected error occurred while trying to extract fallback span name from Netty HttpRequest. "
+ "A hardcoded fallback name will be used as a last resort, however this error should be investigated "
+ "as it shouldn't be possible.", t
);
return "async_downstream_call-UNKNOWN_HTTP_METHOD";
}
}
@NotNull String determineFallbackOverallRequestSpanName(@NotNull HttpRequest nettyRequest) {
try {
HttpMethod method = nettyRequest.method();
String methodName = (method == null) ? null : method.name();
return HttpRequestTracingUtils.getFallbackSpanNameForHttpRequest(null, methodName);
}
catch (Throwable t) {
logger.error(
"An unexpected error occurred while trying to extract fallback span name from Netty HttpRequest. "
+ "A hardcoded fallback name will be used as a last resort, however this error should be investigated "
+ "as it shouldn't be possible.", t
);
return "UNKNOWN_HTTP_METHOD";
}
}
public URIDecoder(HttpRequest httpRequest, Map<String, String> extractedParams) {
super(httpRequest.uri());
this.paths = path().split("/");
if (httpRequest.method() == HttpMethod.PUT || httpRequest.method() == HttpMethod.POST) {
if (httpRequest instanceof HttpContent) {
this.contentType = httpRequest.headers().get(HttpHeaderNames.CONTENT_TYPE);
if (contentType != null && contentType.equals(MediaType.APPLICATION_FORM_URLENCODED)) {
this.decoder = new HttpPostRequestDecoder(new DefaultHttpDataFactory(false), httpRequest);
} else {
this.bodyData = ((HttpContent) httpRequest).content();
}
}
}
this.pathData = extractedParams;
}
private HandlerHolder lookupHandler(HttpRequest req) {
for (HandlerWrapper handler : handlers) {
if (handler.httpMethod == req.method()) {
Matcher matcher = handler.uriTemplate.matcher(req.uri());
if (matcher.matches()) {
Map<String, String> extractedParams = handler.uriTemplate.extractParameters(matcher);
return new HandlerHolder(handler, extractedParams);
}
}
}
return null;
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof HttpRequest) {
final HttpRequest req = (HttpRequest) msg;
final HttpMethod requestMethod = req.method();
final QueryStringDecoder queryDecoder = new QueryStringDecoder(req.uri());
final String requestPath = queryDecoder.path();
if (!requestPath.startsWith(handshakePath)) {
log.warn("Received HTTP bad request: {} {} from channel: {}", requestMethod, requestPath, ctx.channel());
HttpResponse res = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.BAD_REQUEST);
ChannelFuture f = ctx.channel().writeAndFlush(res);
f.addListener(ChannelFutureListener.CLOSE);
ReferenceCountUtil.release(req);
return;
}
if (HttpMethod.GET.equals(requestMethod) && requestPath.equals(handshakePath)) {
if (log.isDebugEnabled())
log.debug("Received HTTP handshake request: {} {} from channel: {}", requestMethod, requestPath, ctx.channel());
handshake(ctx, req, queryDecoder);
ReferenceCountUtil.release(req);
return;
}
}
super.channelRead(ctx, msg);
}
public boolean accept(ChannelHandlerContext ctx, HttpRequest req) {
return req.method() == HttpMethod.POST && req.uri().startsWith(handlerUri);
}
/**
* Sends the provided {@code httpRequest} and verifies that the response is as expected.
* @param channel the {@link EmbeddedChannel} to send the request over.
* @param httpRequest the {@link HttpRequest} that has to be sent
* @param uri, Uri to be used for the request
* @param headers {@link HttpHeaders} that is set in the request to be used for verification purposes
* @param testErrorCase true if error case has to be tested, false otherwise
* @param sslUsed true if SSL was used for this request.
*/
private void sendRequestCheckResponse(EmbeddedChannel channel, HttpRequest httpRequest, String uri,
HttpHeaders headers, boolean testErrorCase, boolean chunkedResponse, boolean sslUsed) throws Exception {
channel.writeInbound(httpRequest);
if (uri.equals(EchoMethodHandler.DISCONNECT_URI)) {
channel.disconnect();
} else {
channel.writeInbound(new DefaultLastHttpContent());
}
String lastLogEntry = publicAccessLogger.getLastPublicAccessLogEntry();
// verify remote host, http method and uri
String subString = testErrorCase ? "Error" : "Info" + ":embedded" + " " + httpRequest.method() + " " + uri;
Assert.assertTrue("Public Access log entry doesn't have expected remote host/method/uri ",
lastLogEntry.startsWith(subString));
// verify SSL-related info
subString = "SSL ([used=" + sslUsed + "]";
if (sslUsed) {
subString += ", [principal=" + PEER_CERT.getSubjectX500Principal() + "]";
subString += ", [san=" + PEER_CERT.getSubjectAlternativeNames() + "]";
}
subString += ")";
Assert.assertTrue("Public Access log entry doesn't have SSL info set correctly", lastLogEntry.contains(subString));
// verify request headers
verifyPublicAccessLogEntryForRequestHeaders(lastLogEntry, headers, httpRequest.method(), true);
// verify response
subString = "Response (";
for (String responseHeader : RESPONSE_HEADERS.split(",")) {
if (headers.contains(responseHeader)) {
subString += "[" + responseHeader + "=" + headers.get(responseHeader) + "] ";
}
}
subString += "[isChunked=" + chunkedResponse + "]), status=" + HttpResponseStatus.OK.code();
if (!testErrorCase) {
Assert.assertTrue("Public Access log entry doesn't have response set correctly",
lastLogEntry.contains(subString));
} else {
Assert.assertTrue("Public Access log entry doesn't have error set correctly ",
lastLogEntry.contains(": Channel closed while request in progress."));
}
}
public static boolean isWriteFromBrowserWithoutOrigin(HttpRequest request) {
HttpMethod method = request.method();
return StringUtil.isEmpty(getOrigin(request)) && isRegularBrowser(request) && (method == HttpMethod.POST || method == HttpMethod.PATCH || method == HttpMethod.PUT || method == HttpMethod.DELETE);
}