Adding Content-Type Headers to Java HTTP echo server
<p>I'm playing with HTTPservers and running into an issue. I need to add ContentType headers to the response, but when I do the client gets ERR_EMPTY_RESPONSE.</p>

<p>If I remove:</p>

<pre><code>headers.add("Content-Type", "text/html");
</code></pre>

<p>Then the server works fine, but I need to pass the CType headers for my app. What gives? How do I include Content-Type headers?</p>

<pre><code>/*
* EchoServer.java
* 
* Accept an HTTP request and echo it back as the HTTP response.
*
* Copyright (c) 2005 Sun Microsystems, Inc
* Copyright (c) 2008 Operational Dynamics Consulting, Pty Ltd
* 
* The code in this file is made available to you by its authors under the
* terms of the "GNU General Public Licence, version 2" See the LICENCE file
* for the terms governing usage and redistribution.
*/

/*
* This code is a simple derivation of the example in the package
* documentation for com.sun.net.httpserver, as found in file
* jdk/src/share/classes/com/sun/net/httpserver/package-info.java as shipped
* with the openjdk 1.6 b08 code drop. Used under the terms of the GPLv2.
*/

import static java.net.HttpURLConnection.HTTP_OK;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.URLDecoder;
import java.util.List;

import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpExchange.*;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

/**
* Echo the body of an HTTP request back as the HTTP response. This is merely
 * a simple exercise of the Secret Sun Web Server. As configured, the URL to
* access it is http://localhost:8000/echo.
* 
* @author Andrew Cowie
*/
public final class Test {
    public static void main(String[] args) throws IOException {
        final InetSocketAddress addr;
        final HttpServer server;

        addr = new InetSocketAddress(8000);

        server = HttpServer.create(addr, 10);
        server.createContext("/echo", new EchoHandler());
        server.start();
    }
}

class EchoHandler implements HttpHandler {
    public void handle(HttpExchange t) throws IOException {
        final InputStream is;
        final OutputStream os;
        StringBuilder buf;
        int b;
        final String request, response;

        buf = new StringBuilder();

    /*
     * Get the request body and decode it. Regardless of what you are
     * actually doing, it is apparently considered correct form to consume
     * all the bytes from the InputStream. If you don't, closing the
     * OutputStream will cause that to occur
     */

        is = t.getRequestBody();

        while ((b = is.read()) != -1) {
            buf.append((char) b);
        }

        is.close();

        if (buf.length() &gt; 0) {
            request = URLDecoder.decode(buf.toString(), "UTF-8");
        } else {
            request = null;
        }

    /*
     * Construct our response:
     */

        buf = new StringBuilder();
        buf.append("&lt;html&gt;&lt;head&gt;&lt;title&gt;HTTP echo server&lt;/title&gt;&lt;/head&gt;&lt;body&gt;");
        buf.append("&lt;p&gt;&lt;pre&gt;");
        buf.append(t.getRequestMethod() + " " + t.getRequestURI() + " " + t.getProtocol() + "\n");

    /*
     * Process the request headers. This is a bit involved due to the
     * complexity arising from the fact that headers can be repeated.
     */

        Headers headers = t.getRequestHeaders();

        for (String name : headers.keySet()) {
            List&lt;String&gt; values = headers.get(name);

            for (String value : values) {
                buf.append(name + ": " + value + "\n");
            }
        }

    /*
     * If there was an actual body to the request, add it:
     */

        if (request != null) {
            buf.append("\n");
            buf.append(request);
        }

        buf.append("&lt;/pre&gt;&lt;/p&gt;");
        buf.append("&lt;/body&gt;&lt;/html&gt;\n");

        response = buf.toString();
        System.out.println(response);

    /*
     * And now send the response. We could have instead done this
     * dynamically, using 0 as the response size (forcing chunked
     * encoding) and writing the bytes of the response directly to the
     * OutputStream, but building the String first allows us to know the
     * exact length so we can send a response with a known size. Better :)
     */

        headers.add("Content-Type", "text/html");
        t.sendResponseHeaders(HTTP_OK, response.length());

        os = t.getResponseBody();

        os.write(response.getBytes());

    /*
     * And we're done!
     */

        os.close();
        t.close();
    }
}
</code></pre>