How to use

valueOf

method

in

io.netty.handler.codec.http.HttpMethod

return HttpMethod.valueOf(rawMethod);

  private static HttpMethod toNettyHttpMethod(HttpMethodName method) {
    return HttpMethod.valueOf(method.name());
  }
}

private FullHttpRequest createFullHttpRequest(HttpHeaders headers) {
  io.netty.handler.codec.http.HttpMethod nettyMethod =
      io.netty.handler.codec.http.HttpMethod.valueOf(this.method.name());
  String authority = this.uri.getRawAuthority();
  String path = this.uri.toString().substring(this.uri.toString().indexOf(authority) + authority.length());
  FullHttpRequest nettyRequest = new DefaultFullHttpRequest(
      HttpVersion.HTTP_1_1, nettyMethod, path, this.body.buffer());
  nettyRequest.headers().set(HttpHeaders.HOST, this.uri.getHost() + ":" + getPort(this.uri));
  nettyRequest.headers().set(HttpHeaders.CONNECTION, "close");
  headers.forEach((headerName, headerValues) -> nettyRequest.headers().add(headerName, headerValues));
  if (!nettyRequest.headers().contains(HttpHeaders.CONTENT_LENGTH) && this.body.buffer().readableBytes() > 0) {
    nettyRequest.headers().set(HttpHeaders.CONTENT_LENGTH, this.body.buffer().readableBytes());
  }
  return nettyRequest;
}

@Override
protected HttpMessage createMessage(String[] initialLine) throws Exception {
  return new DefaultHttpRequest(
      HttpVersion.valueOf(initialLine[2]),
      HttpMethod.valueOf(initialLine[0]), initialLine[1], validateHeaders);
}

@Override
public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri,
    Function<? super ClientHttpRequest, Mono<Void>> requestCallback) {
  if (!uri.isAbsolute()) {
    return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri));
  }
  return this.httpClient
      .request(io.netty.handler.codec.http.HttpMethod.valueOf(method.name()))
      .uri(uri.toString())
      .send((request, outbound) -> requestCallback.apply(adaptRequest(method, uri, request, outbound)))
      .responseConnection((res, con) -> Mono.just(adaptResponse(res, con.inbound(), con.outbound().alloc())))
      .next();
}

 @Override
 protected HttpMessage createMessage(String[] initialLine) {
  return new DefaultHttpRequest(
   HttpVersion.valueOf(initialLine[2]),
   HttpMethod.valueOf(initialLine[0]),
   initialLine[1],
   new VertxHttpHeaders());
 }
}

private FullHttpRequest createFullHttpRequest(HttpHeaders headers) {
  io.netty.handler.codec.http.HttpMethod nettyMethod =
      io.netty.handler.codec.http.HttpMethod.valueOf(this.method.name());
  String authority = this.uri.getRawAuthority();
  String path = this.uri.toString().substring(this.uri.toString().indexOf(authority) + authority.length());
  FullHttpRequest nettyRequest = new DefaultFullHttpRequest(
      HttpVersion.HTTP_1_1, nettyMethod, path, this.body.buffer());
  nettyRequest.headers().set(HttpHeaders.HOST, this.uri.getHost() + ":" + getPort(this.uri));
  nettyRequest.headers().set(HttpHeaders.CONNECTION, "close");
  headers.forEach((headerName, headerValues) -> nettyRequest.headers().add(headerName, headerValues));
  if (!nettyRequest.headers().contains(HttpHeaders.CONTENT_LENGTH) && this.body.buffer().readableBytes() > 0) {
    nettyRequest.headers().set(HttpHeaders.CONTENT_LENGTH, this.body.buffer().readableBytes());
  }
  return nettyRequest;
}

CharSequence contentType = headers.get(HttpHeaderNames.CONTENT_TYPE);
if (contentType != null) {
 io.netty.handler.codec.http.HttpMethod method = io.netty.handler.codec.http.HttpMethod.valueOf(headers.method().toString());
 String lowerCaseContentType = contentType.toString().toLowerCase();
 boolean isURLEncoded = lowerCaseContentType.startsWith(HttpHeaderValues.APPLICATION_X_WWW_FORM_URLENCODED.toString());

private HttpRequest buildOriginHttpRequest(final HttpRequestMessage zuulRequest) {
  final String method = zuulRequest.getMethod().toUpperCase();
  final String uri = pathAndQueryString(zuulRequest);
  customRequestProcessing(zuulRequest);
  final DefaultHttpRequest nettyReq = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(method), uri, false);
  // Copy headers across.
  for (final Header h : zuulRequest.getHeaders().entries()) {
    nettyReq.headers().add(h.getKey(), h.getValue());
  }
  return nettyReq;
}

@Override
public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri,
    Function<? super ClientHttpRequest, Mono<Void>> requestCallback) {
  if (!uri.isAbsolute()) {
    return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri));
  }
  return this.httpClient
      .request(io.netty.handler.codec.http.HttpMethod.valueOf(method.name()))
      .uri(uri.toString())
      .send((request, outbound) -> requestCallback.apply(adaptRequest(method, uri, request, outbound)))
      .responseConnection((res, con) -> Mono.just(adaptResponse(res, con.inbound(), con.outbound().alloc())))
      .next();
}

public FullHttpRequest toFullHttpRequest() {
  ByteBuf buffer = Unpooled.buffer();
  MessageContent content = getContent();
  if (content != null) {
    buffer.writeBytes(content.getContent());
  }
  QueryStringEncoder encoder = new QueryStringEncoder(uri);
  for (Map.Entry<String, String[]> entry : queries.entrySet()) {
    String[] values = entry.getValue();
    for (String value : values) {
      encoder.addParam(entry.getKey(), value);
    }
  }
  FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.valueOf(getVersion().text()),
      io.netty.handler.codec.http.HttpMethod.valueOf(method.name()), encoder.toString(), buffer);
  for (Map.Entry<String, String[]> entry : getHeaders().entrySet()) {
    String key = entry.getKey();
    for (String value : entry.getValue()) {
      request.headers().add(key, value);
    }
  }
  return request;
}

/**
 * @param publisher A publisher for the Http content
 * @return The Http request
 */
HttpRequest getStreamedRequest(Publisher<HttpContent> publisher) {
  String uriStr = resolveUriPath();
  io.netty.handler.codec.http.HttpMethod method = io.netty.handler.codec.http.HttpMethod.valueOf(httpMethod.name());
  HttpRequest req = publisher != null ? new DefaultStreamedHttpRequest(HttpVersion.HTTP_1_1, method, uriStr, publisher) :
    new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, method, uriStr);
  req.headers().setAll(headers.getNettyHeaders());
  return req;
}

/**
 * Create a new object to contain the request data.
 *
 * @param streamId The stream associated with the request
 * @param http2Headers The initial set of HTTP/2 headers to create the request with
 * @param validateHttpHeaders <ul>
 *        <li>{@code true} to validate HTTP headers in the http-codec</li>
 *        <li>{@code false} not to validate HTTP headers in the http-codec</li>
 *        </ul>
 * @return A new request object which represents headers for a chunked request
 * @throws Http2Exception see {@link #addHttp2ToHttpHeaders(int, Http2Headers, FullHttpMessage, boolean)}
 */
public static HttpRequest toHttpRequest(int streamId, Http2Headers http2Headers, boolean validateHttpHeaders)
        throws Http2Exception {
  // HTTP/2 does not define a way to carry the version identifier that is included in the HTTP/1.1 request line.
  final CharSequence method = checkNotNull(http2Headers.method(),
      "method header cannot be null in conversion to HTTP/1.x");
  final CharSequence path = checkNotNull(http2Headers.path(),
      "path header cannot be null in conversion to HTTP/1.x");
  HttpRequest msg = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(method.toString()),
      path.toString(), validateHttpHeaders);
  try {
    addHttp2ToHttpHeaders(streamId, http2Headers, msg.headers(), msg.protocolVersion(), false, true);
  } catch (Http2Exception e) {
    throw e;
  } catch (Throwable t) {
    throw streamError(streamId, PROTOCOL_ERROR, t, "HTTP/2 to HTTP/1.x headers conversion error");
  }
  return msg;
}

public FullHttpRequest mapMockServerResponseToHttpServletResponse(HttpRequest httpRequest) {
  // method
  HttpMethod httpMethod = HttpMethod.valueOf(httpRequest.getMethod("GET"));
  // the request
  FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, httpMethod, getURI(httpRequest), getBody(httpRequest));
  // headers
  setHeader(httpRequest, request);
  // cookies
  setCookies(httpRequest, request);
  return request;
}

final CharSequence path = checkNotNull(http2Headers.path(),
    "path header cannot be null in conversion to HTTP/1.x");
FullHttpRequest msg = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(method
        .toString()), path.toString(), alloc.buffer(), validateHttpHeaders);
try {

/**
 * @param content The {@link ByteBuf}
 * @return The http request
 */
HttpRequest getFullRequest(ByteBuf content) {
  String uriStr = resolveUriPath();
  io.netty.handler.codec.http.HttpMethod method = io.netty.handler.codec.http.HttpMethod.valueOf(httpMethod.name());
  DefaultFullHttpRequest req = content != null ? new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, method, uriStr, content) :
    new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, method, uriStr);
  req.headers().setAll(headers.getNettyHeaders());
  return req;
}

@Override
public void push(final String method, final String path, final Map<String, Object> headers) {
 ctx.channel().eventLoop().execute(() -> {
  AsciiString streamIdHeader = HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text();
  Http2Connection connection = encoder.connection();
  int nextStreamId = connection.local().incrementAndGetNextStreamId();
  Http2Headers h2headers = new DefaultHttp2Headers()
    .path(path)
    .method(method)
    .authority(authority)
    .scheme(scheme);
  headers.forEach((n, v) -> h2headers.add(n, v.toString()));
  encoder.writePushPromise(ctx, streamId, nextStreamId, h2headers, 0, ctx.newPromise());
  // TODO: Is there another way of handling a push promise?
  DefaultFullHttpRequest pushRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1,
    HttpMethod.valueOf(method.toUpperCase()), path, Unpooled.EMPTY_BUFFER,
    new DefaultHttpHeaders(false).set(streamIdHeader, nextStreamId),
    EmptyHttpHeaders.INSTANCE);
  ctx.pipeline().fireChannelRead(pushRequest);
  ctx.pipeline().fireChannelReadComplete();
 });
}

HttpMethod  method      = HttpMethod.valueOf(headers.getAsString(METHOD));
String      url         = headers.getAsString(PATH);
HttpVersion httpVersion = HttpVersion.valueOf(headers.getAsString(VERSION));

private HttpRequest buildOriginHttpRequest(final HttpRequestMessage zuulRequest) {
  final String method = zuulRequest.getMethod().toUpperCase();
  final String uri = pathAndQueryString(zuulRequest);
  customRequestProcessing(zuulRequest);
  final DefaultHttpRequest nettyReq = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(method), uri, false);
  // Copy headers across.
  for (final Header h : zuulRequest.getHeaders().entries()) {
    nettyReq.headers().add(h.getKey(), h.getValue());
  }
  return nettyReq;
}

FullHttpRequest request = new DefaultFullHttpRequest(HTTP_1_1, HttpMethod.valueOf(method), uri, getBody(message));