public class HttpServer
{
    private final String name;
	private final int port;
    private Channel channel;
    private InetSocketAddress socketAddress;

    public HttpServer(String name, int port)
    {
        this.name = name;
		this.port = port;
	}

    public void run(int selectorThreadCount, ThreadPoolConfig threadPoolConfig)
        throws BackEndException
	{
        ServerBootstrap bootstrap =
            new ServerBootstrap(new NioServerSocketChannelFactory(
                Executors.newFixedThreadPool(selectorThreadCount),
                new ThreadPoolExecutor(threadPoolConfig.getCorePoolSize(),
                    threadPoolConfig.getMaximumPoolSize(),
                    threadPoolConfig.getKeepAliveTime().to(TimeUnit.SECONDS),
                    TimeUnit.SECONDS, new SynchronousQueue<Runnable>())));
		bootstrap.setOption("child.tcpNoDelay", true);
        bootstrap.setOption("child.keepAlive", true);
        bootstrap.setOption("tcpNoDelay", true);
        bootstrap.setOption("keepAlive", true);
        bootstrap.setOption("receiveBufferSize", 1048576);
        bootstrap.setOption("backlog", 1000);
        bootstrap.setPipelineFactory(new HttpServerPipelineFactory());
        socketAddress = new InetSocketAddress(port);
        channel = bootstrap.bind(socketAddress);        
    }
}

public class HttpServerPipelineFactory implements ChannelPipelineFactory
{
	
    protected final HttpServerHandler handler = new HttpServerHandler();

	@Override
	public ChannelPipeline getPipeline() throws Exception {
		ChannelPipeline pipeline = Channels.pipeline();
		
        pipeline.addLast("decoder", new HttpRequestDecoder());
        pipeline.addLast("endcoder", new HttpResponseEncoder());		
        pipeline.addLast("handler", handler);
		
		return pipeline;
	}

}

public class HttpServerHandler extends SimpleChannelUpstreamHandler
{   
	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception
    {
        HttpRequest request = (HttpRequest)e.getMessage();
        boolean keepAlive = HttpHeaders.isKeepAlive(request);
        // Build the response object.
        HttpResponse response =
            new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        response.setContent(ChannelBuffers.copiedBuffer(
            "Hello from ServerHandler!", CharsetUtil.UTF_8));
        response.setHeader(HttpHeaders.Names.CONTENT_TYPE,
            "text/plain; charset=UTF-8");
//        HttpRequest request = (HttpRequest)message;        

        if (keepAlive)
        {
            // Add 'Content-Length' header only for a keep-alive connection.
            response.setHeader(HttpHeaders.Names.CONTENT_LENGTH,
                response.getContent().readableBytes());
            // Add keep alive header as per:
            // - http://www.w3.org/Protocols/HTTP/1.1/draft-ietf-http-v11-spec-01.html#Connection
            response.setHeader(HttpHeaders.Names.CONNECTION,
                HttpHeaders.Values.KEEP_ALIVE);
        }

        ChannelFuture future = e.getChannel().write(response);

        if (!keepAlive)
        {
            future.addListener(ChannelFutureListener.CLOSE);
        }
	}	
}