title: HTTP Request using Netty
body: <p>I have just started netty and I am really disappointed with the documentation present on 
  their website. </p>
  
  <p>I am trying to connect to an URL using Netty.. I took the time client example from their website and changed it as per my requirement.. </p>
  
  <p>Code :</p>
  
  <pre><code>public class NettyClient {
  
        public static void main(String[] args) throws Exception {
            String host = "myUrl.com/v1/parma?param1=value";
              int port = 443;
              EventLoopGroup workerGroup = new NioEventLoopGroup();
  
              try {
                  Bootstrap b = new Bootstrap();             
                  b.group(workerGroup); 
                  b.channel(NioSocketChannel.class); 
                  b.option(ChannelOption.SO_KEEPALIVE, true); 
                  b.handler(new ChannelInitializer&lt;SocketChannel&gt;() {
                      @Override
                      public void initChannel(SocketChannel ch) throws Exception {
                          ch.pipeline().addLast(new ClientHandler());
                          ch.pipeline().addLast("encoder", new HttpRequestEncoder());
                      }
                  });
  
                  // Start the client.
                  ChannelFuture f = b.connect(host, port).sync(); 
  
                  // Wait until the connection is closed.
                  f.channel().closeFuture().sync();
              } finally {
                  workerGroup.shutdownGracefully();
              }
          }
  }
  </code></pre>
  
  <p>But the problem is that that it expects only the url without the query parameters.. How can I pass query parameters with the URL? 
  and please provide me some link of a good documentation for Netty 4..</p>
  
  <p>EDIT</p>
  
  <p>Client code after referring the example mentioned in the answer :</p>
  
  <pre><code>URI uri = new URI("myUrl.com/v1/parma?param1=value");          
             String scheme = uri.getScheme() == null? "http" : uri.getScheme();
             String host = "myUrl.com";
              int port = 443;
  
  
  
              boolean ssl = "https".equalsIgnoreCase(scheme);
  
           // Configure the client.
              EventLoopGroup group = new NioEventLoopGroup();
              try {
                  Bootstrap b = new Bootstrap();
                  b.group(group)
                   .channel(NioSocketChannel.class)
                   .handler(new NettyClientInitializer(ssl));
                  // Make the connection attempt.
                  Channel ch = b.connect(host, port).sync().channel();
                  // Prepare the HTTP request.
                  HttpRequest request = new DefaultHttpRequest(
                          HttpVersion.HTTP_1_1, HttpMethod.GET, uri.getRawPath());
                  request.headers().set(HttpHeaders.Names.HOST, host);
                  request.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
                  //request.headers().set(HttpHeaders.Names.ACCEPT_ENCODING, HttpHeaders.Values.GZIP);
  
                  /*// Set some example cookies.
                  request.headers().set(
                          HttpHeaders.Names.COOKIE,
                          ClientCookieEncoder.encode(
                                  new DefaultCookie("my-cookie", "foo"),
                                  new DefaultCookie("another-cookie", "bar")));
  */
                  // Send the HTTP request.
                  ch.writeAndFlush(request);
  
                  // Wait for the server to close the connection.
                  ch.closeFuture().sync();
              } finally {
                  // Shut down executor threads to exit.
                  group.shutdownGracefully();
              }
  </code></pre>
  
  <p>handler code :</p>
  
  <pre><code>public class ClientHandler extends SimpleChannelInboundHandler&lt;HttpObject&gt; {
  
      @Override
      public void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
          if (msg instanceof HttpResponse) {
              HttpResponse response = (HttpResponse) msg;
  
              System.out.println("STATUS: " + response.getStatus());
              System.out.println("VERSION: " + response.getProtocolVersion());
              System.out.println();
  
              if (!response.headers().isEmpty()) {
                  for (String name: response.headers().names()) {
                      for (String value: response.headers().getAll(name)) {
                          System.out.println("HEADER: " + name + " = " + value);
                      }
                  }
                  System.out.println();
              }
  
              if (HttpHeaders.isTransferEncodingChunked(response)) {
                  System.out.println("CHUNKED CONTENT {");
              } else {
                  System.out.println("CONTENT {");
              }
          }
          if (msg instanceof HttpContent) {
              HttpContent content = (HttpContent) msg;
  
              System.out.print(content.content().toString(CharsetUtil.UTF_8));
              System.out.flush();
  
              if (content instanceof LastHttpContent) {
                  System.out.println("} END OF CONTENT");
              }
          }
      }
  
      @Override
      public void exceptionCaught(
              ChannelHandlerContext ctx, Throwable cause) throws Exception {
          cause.printStackTrace();
          ctx.close();
      }
  
  
  }
  </code></pre>
  
  <p>initializer code :</p>
  
  <pre><code>public class NettyClientInitializer extends ChannelInitializer&lt;SocketChannel&gt; {
  
      private final boolean ssl;
  
      public NettyClientInitializer(boolean ssl) {
          this.ssl = ssl;
      }
  
      @Override
      public void initChannel(SocketChannel ch) throws Exception {
          // Create a default pipeline implementation.
          ChannelPipeline p = ch.pipeline();
  
          p.addLast("log", new LoggingHandler(LogLevel.INFO));
          // Enable HTTPS if necessary.
          /*
          if (ssl) {
              SSLEngine engine =
                  SecureChatSslContextFactory.getClientContext().createSSLEngine();
              engine.setUseClientMode(true);
  
              p.addLast("ssl", new SslHandler(engine));
          }
  */
          p.addLast("codec", new HttpClientCodec());
  
          // Remove the following line if you don't want automatic content decompression.
         // p.addLast("inflater", new HttpContentDecompressor());
  
          // Uncomment the following line if you don't want to handle HttpChunks.
          p.addLast("aggregator", new HttpObjectAggregator(1048576));
          p.addLast("handler", new ClientHandler());
      }
  }
  </code></pre>