Since Java SE 6, there's a builtin HTTP server inSun Oracle JRE. The Java 9 module name isjdk.httpserver. Thecom.sun.net.httpserver package summary outlines the involved classes and contains examples.

Here's a kickoff examplecopypasted from their docs. You can just copy'n'paste'n'run it on Java 6+.
_{(to all people trying to edit it nonetheless, because it's an ugly piece of code, please don't, this is a copy paste, not mine, moreover you should never edit quotations unless they have changed in the original source)}

package com.stackoverflow.q3732109;import java.io.IOException;import java.io.OutputStream;import java.net.InetSocketAddress;import com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpHandler;import com.sun.net.httpserver.HttpServer;public class Test {    public static void main(String[] args) throws Exception {        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);        server.createContext("/test", new MyHandler());        server.setExecutor(null); // creates a default executor        server.start();    }    static class MyHandler implements HttpHandler {        @Override        public void handle(HttpExchange t) throws IOException {            String response = "This is the response";            t.sendResponseHeaders(200, response.length());            OutputStream os = t.getResponseBody();            os.write(response.getBytes());            os.close();        }    }}

Noted should be that theresponse.length() part in their example is bad, it should have beenresponse.getBytes().length. Even then, thegetBytes() method must explicitly specify the charset which you then specify in the response header. Alas, albeit misguiding to starters, it's after all just a basic kickoff example.

Execute it and go to http://localhost:8000/test and you'll see the following response:

This is the response

As to usingcom.sun.* classes, do note that this is, in contrary to what some developers think, absolutely not forbidden by the well known FAQWhy Developers Should Not Write Programs That Call 'sun' Packages. That FAQ concerns thesun.* package (such assun.misc.BASE64Encoder) for internal usage by the Oracle JRE (which would thus kill your application when you run it on a different JRE), not thecom.sun.* package. Sun/Oracle also just develop software on top of the Java SE API themselves like as every other company such as Apache and so on. Moreover, this specificHttpServer must be present in every JDK so there is absolutely no means of "portability" issue like as would happen withsun.* package. Usingcom.sun.* classes is onlydiscouraged (but notforbidden) when it concerns animplementation of a certain Java API, such as GlassFish (Java EE impl), Mojarra (JSF impl), Jersey (JAX-RS impl), etc.

Check outNanoHttpd

NanoHTTPD is a light-weight HTTP server designed for embedding in other applications, released under a Modified BSD licence.

It is being developed on Github and uses Apache Maven for builds & unit testing"

Thecom.sun.net.httpserver solution is not portable across JREs. Its better to use the official webservices API injavax.xml.ws to bootstrap a minimal HTTP server...

import java.io._import javax.xml.ws._import javax.xml.ws.http._import javax.xml.transform._import javax.xml.transform.stream._@WebServiceProvider@ServiceMode(value=Service.Mode.PAYLOAD) class P extends Provider[Source] {  def invoke(source: Source) = new StreamSource( new StringReader("<p>Hello There!</p>"));}val address = "http://127.0.0.1:8080/"Endpoint.create(HTTPBinding.HTTP_BINDING, new P()).publish(address)println("Service running at "+address)println("Type [CTRL]+[C] to quit!")Thread.sleep(Long.MaxValue)

EDIT: this actually works! The above code looks like Groovy or something. Here is a translation to Java which I tested:

import java.io.*;import javax.xml.ws.*;import javax.xml.ws.http.*;import javax.xml.transform.*;import javax.xml.transform.stream.*;@WebServiceProvider@ServiceMode(value = Service.Mode.PAYLOAD)public class Server implements Provider<Source> {    public Source invoke(Source request) {        return  new StreamSource(new StringReader("<p>Hello There!</p>"));    }    public static void main(String[] args) throws InterruptedException {        String address = "http://127.0.0.1:8080/";        Endpoint.create(HTTPBinding.HTTP_BINDING, new Server()).publish(address);        System.out.println("Service running at " + address);        System.out.println("Type [CTRL]+[C] to quit!");        Thread.sleep(Long.MAX_VALUE);    }}

I like this question because this is an area where there's continuous innovation and there's always a need to have a light server especially when talking about embedded servers in small(er) devices. I think answers fall into two broad groups.

1. Thin-server: server-up static content with minimal processing, context or session processing.
2. Small-server: ostensibly a has many httpD-like server qualities with as small a footprint as you can get away with.

While I might consider HTTP libraries like:Jetty,Apache Http Components,Netty and others to be more like a raw HTTP processing facilities. The labelling is very subjective, and depends on the kinds of thing you've been call-on to deliver for small-sites. I make this distinction in the spirit of the question, particularly the remark about...

• "...without writing code to manually parse HTTP requests and manually format HTTP responses..."

These raw tools let you do that (as described in other answers). They don't really lend themselves to a ready-set-go style of making a light, embedded or mini-server. A mini-server is something that can give you similar functionality to a full-function web server (like say,Tomcat) without bells and whistles, low volume, good performance 99% of the time. A thin-server seems closer to the original phrasing just a bit more than raw perhaps with a limited subset functionality, enough to make you look good 90% of the time. My idea of raw would be makes me look good 75% - 89% of the time without extra design and coding. I think if/when you reach the level of WAR files, we've left the "small" for bonsi servers that looks like everything a big server does smaller.

Thin-server options

• Grizzly
• UniRest (multiple-languages)
• NanoHTTPD (just one file)

Mini-server options:

• Spark Java ... Good things are possible with lots of helper constructs like Filters, Templates, etc.
• MadVoc ... aims to be bonsai and could well be such ;-)

Among the other things to consider, I'd include authentication, validation, internationalisation, using something likeFreeMaker or other template tool to render page output. Otherwise managing HTML editing and parameterisation is likely to make working with HTTP look like noughts-n-crosses. Naturally it all depends on how flexible you need to be. If it's a menu-driven FAX machine it can be very simple. The more interactions, the 'thicker' your framework needs to be. Good question, good luck!

Have a look at the "Jetty" web serverJetty. Superb piece of Open Source software that would seem to meet all your requirments.

If you insist on rolling your own then have a look at the "httpMessage" class.

Once upon a time I was looking for something similar - a lightweight yet fully functional HTTP server that I could easily embed and customize. I found two types of potential solutions:

• Full servers that are not all that lightweight or simple (for an extreme definition of lightweight.)
• Truly lightweight servers that aren't quite HTTP servers, but glorified ServerSocket examples that are not even remotely RFC-compliant and don't support commonly needed basic functionality.

So... I set out to writeJLHTTP - The Java Lightweight HTTP Server.

You can embed it in any project as a single (if rather long) source file, or as a ~50K jar (~35K stripped) with no dependencies. It strives to be RFC-compliant and includes extensive documentation and many useful features while keeping bloat to a minimum.

Features include: virtual hosts, file serving from disk, mime type mappings via standard mime.types file, directory index generation, welcome files, support for all HTTP methods, conditional ETags and If-* header support, chunked transfer encoding, gzip/deflate compression, basic HTTPS (as provided by the JVM), partial content (download continuation), multipart/form-data handling for file uploads, multiple context handlers via API or annotations, parameter parsing (query string or x-www-form-urlencoded body), etc.

I hope others find it useful :-)

JEP 408: Simple Web Server

Starting inJava 18, you can create simple web servers with Java standard library:

class Main {    public static void main(String[] args) {        var port = 8000;        var rootDirectory = Path.of("C:/Users/Mahozad/Desktop/");        var outputLevel = OutputLevel.VERBOSE;        var server = SimpleFileServer.createFileServer(                new InetSocketAddress(port),                rootDirectory,                outputLevel        );        server.start();    }}

This will, by default, show a directory listing of the root directory you specified. You can place anindex.html file (and other assets like CSS and JS files) in that directory to show them instead.

Sidenote

For Java standard library HTTPclient, see the postJava 11 new HTTP Client API and alsoJEP 321.

Spark is the simplest, here is a quick start guide:http://sparkjava.com/

All the above answers details about Single main threaded Request Handler.

setting:

 server.setExecutor(java.util.concurrent.Executors.newCachedThreadPool());

Allows multiple request serving via multiple threads using executor service.

So the end code will be something like below:

import java.io.IOException;import java.io.OutputStream;import java.net.InetSocketAddress;import com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpHandler;import com.sun.net.httpserver.HttpServer;public class App {    public static void main(String[] args) throws Exception {        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);        server.createContext("/test", new MyHandler());        //Thread control is given to executor service.        server.setExecutor(java.util.concurrent.Executors.newCachedThreadPool());        server.start();    }    static class MyHandler implements HttpHandler {        @Override        public void handle(HttpExchange t) throws IOException {            String response = "This is the response";            long threadId = Thread.currentThread().getId();            System.out.println("I am thread " + threadId );            response = response + "Thread Id = "+threadId;            t.sendResponseHeaders(200, response.length());            OutputStream os = t.getResponseBody();            os.write(response.getBytes());            os.close();        }    }}

It's possible to create an httpserver that provides basic support for J2EE servlets with just the JDK and the servlet api in a just a few lines of code.

I've found this very useful for unit testing servlets, as it starts much faster than other lightweight containers (we use jetty for production).

Most very lightweight httpservers do not provide support for servlets, but we need them, so I thought I'd share.

The below example provides basic servlet support, or throws and UnsupportedOperationException for stuff not yet implemented. It uses the com.sun.net.httpserver.HttpServer for basic http support.

import java.io.*;import java.lang.reflect.*;import java.net.InetSocketAddress;import java.util.*;import javax.servlet.*;import javax.servlet.http.*;import com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpHandler;import com.sun.net.httpserver.HttpServer;@SuppressWarnings("deprecation")public class VerySimpleServletHttpServer {    HttpServer server;    private String contextPath;    private HttpHandler httpHandler;    public VerySimpleServletHttpServer(String contextPath, HttpServlet servlet) {        this.contextPath = contextPath;        httpHandler = new HttpHandlerWithServletSupport(servlet);    }    public void start(int port) throws IOException {        InetSocketAddress inetSocketAddress = new InetSocketAddress(port);        server = HttpServer.create(inetSocketAddress, 0);        server.createContext(contextPath, httpHandler);        server.setExecutor(null);        server.start();    }    public void stop(int secondsDelay) {        server.stop(secondsDelay);    }    public int getServerPort() {        return server.getAddress().getPort();    }}final class HttpHandlerWithServletSupport implements HttpHandler {    private HttpServlet servlet;    private final class RequestWrapper extends HttpServletRequestWrapper {        private final HttpExchange ex;        private final Map<String, String[]> postData;        private final ServletInputStream is;        private final Map<String, Object> attributes = new HashMap<>();        private RequestWrapper(HttpServletRequest request, HttpExchange ex, Map<String, String[]> postData, ServletInputStream is) {            super(request);            this.ex = ex;            this.postData = postData;            this.is = is;        }        @Override        public String getHeader(String name) {            return ex.getRequestHeaders().getFirst(name);        }        @Override        public Enumeration<String> getHeaders(String name) {            return new Vector<String>(ex.getRequestHeaders().get(name)).elements();        }        @Override        public Enumeration<String> getHeaderNames() {            return new Vector<String>(ex.getRequestHeaders().keySet()).elements();        }        @Override        public Object getAttribute(String name) {            return attributes.get(name);        }        @Override        public void setAttribute(String name, Object o) {            this.attributes.put(name, o);        }        @Override        public Enumeration<String> getAttributeNames() {            return new Vector<String>(attributes.keySet()).elements();        }        @Override        public String getMethod() {            return ex.getRequestMethod();        }        @Override        public ServletInputStream getInputStream() throws IOException {            return is;        }        @Override        public BufferedReader getReader() throws IOException {            return new BufferedReader(new InputStreamReader(getInputStream()));        }        @Override        public String getPathInfo() {            return ex.getRequestURI().getPath();        }        @Override        public String getParameter(String name) {            String[] arr = postData.get(name);            return arr != null ? (arr.length > 1 ? Arrays.toString(arr) : arr[0]) : null;        }        @Override        public Map<String, String[]> getParameterMap() {            return postData;        }        @Override        public Enumeration<String> getParameterNames() {            return new Vector<String>(postData.keySet()).elements();        }    }    private final class ResponseWrapper extends HttpServletResponseWrapper {        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();        final ServletOutputStream servletOutputStream = new ServletOutputStream() {            @Override            public void write(int b) throws IOException {                outputStream.write(b);            }        };        private final HttpExchange ex;        private final PrintWriter printWriter;        private int status = HttpServletResponse.SC_OK;        private ResponseWrapper(HttpServletResponse response, HttpExchange ex) {            super(response);            this.ex = ex;            printWriter = new PrintWriter(servletOutputStream);        }        @Override        public void setContentType(String type) {            ex.getResponseHeaders().add("Content-Type", type);        }        @Override        public void setHeader(String name, String value) {            ex.getResponseHeaders().add(name, value);        }        @Override        public javax.servlet.ServletOutputStream getOutputStream() throws IOException {            return servletOutputStream;        }        @Override        public void setContentLength(int len) {            ex.getResponseHeaders().add("Content-Length", len + "");        }        @Override        public void setStatus(int status) {            this.status = status;        }        @Override        public void sendError(int sc, String msg) throws IOException {            this.status = sc;            if (msg != null) {                printWriter.write(msg);            }        }        @Override        public void sendError(int sc) throws IOException {            sendError(sc, null);        }        @Override        public PrintWriter getWriter() throws IOException {            return printWriter;        }        public void complete() throws IOException {            try {                printWriter.flush();                ex.sendResponseHeaders(status, outputStream.size());                if (outputStream.size() > 0) {                    ex.getResponseBody().write(outputStream.toByteArray());                }                ex.getResponseBody().flush();            } catch (Exception e) {                e.printStackTrace();            } finally {                ex.close();            }        }    }    public HttpHandlerWithServletSupport(HttpServlet servlet) {        this.servlet = servlet;    }    @SuppressWarnings("deprecation")    @Override    public void handle(final HttpExchange ex) throws IOException {        byte[] inBytes = getBytes(ex.getRequestBody());        ex.getRequestBody().close();        final ByteArrayInputStream newInput = new ByteArrayInputStream(inBytes);        final ServletInputStream is = new ServletInputStream() {            @Override            public int read() throws IOException {                return newInput.read();            }        };        Map<String, String[]> parsePostData = new HashMap<>();        try {            parsePostData.putAll(HttpUtils.parseQueryString(ex.getRequestURI().getQuery()));            // check if any postdata to parse            parsePostData.putAll(HttpUtils.parsePostData(inBytes.length, is));        } catch (IllegalArgumentException e) {            // no postData - just reset inputstream            newInput.reset();        }        final Map<String, String[]> postData = parsePostData;        RequestWrapper req = new RequestWrapper(createUnimplementAdapter(HttpServletRequest.class), ex, postData, is);        ResponseWrapper resp = new ResponseWrapper(createUnimplementAdapter(HttpServletResponse.class), ex);        try {            servlet.service(req, resp);            resp.complete();        } catch (ServletException e) {            throw new IOException(e);        }    }    private static byte[] getBytes(InputStream in) throws IOException {        ByteArrayOutputStream out = new ByteArrayOutputStream();        byte[] buffer = new byte[1024];        while (true) {            int r = in.read(buffer);            if (r == -1)                break;            out.write(buffer, 0, r);        }        return out.toByteArray();    }    @SuppressWarnings("unchecked")    private static <T> T createUnimplementAdapter(Class<T> httpServletApi) {        class UnimplementedHandler implements InvocationHandler {            @Override            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                throw new UnsupportedOperationException("Not implemented: " + method + ", args=" + Arrays.toString(args));            }        }        return (T) Proxy.newProxyInstance(UnimplementedHandler.class.getClassLoader(),                new Class<?>[] { httpServletApi },                new UnimplementedHandler());    }}

An example of a very basic HTTP server on TCP sockets level:

import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.InetAddress;import java.net.ServerSocket;import java.net.Socket;public class NaiveHttpServer {  public static void main(String[] args) throws IOException {    String hostname = InetAddress.getLocalHost().getHostName();    ServerSocket serverSocket = new ServerSocket(8089);    while (true) {      Socket clientSocket = serverSocket.accept();      PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);      BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));      String s = in.readLine();      System.out.println(s);      while ("\r\n".equals(in.readLine()));       if ("GET /hostname HTTP/1.1".equals(s)) {        out.println("HTTP/1.1 200 OK");        out.println("Connection: close");        out.println("Content-Type: text/plain");        out.println("Content-Length:" + hostname.length());        out.println();        out.println(hostname);      } else {        out.println("HTTP/1.1 404 Not Found");        out.println("Connection: close");        out.println();          }      out.flush();    }  }}

The example serves the hostname of the computer.

You may also have a look at some NIO application framework such as:

1. Netty:http://jboss.org/netty
2. Apache Mina:http://mina.apache.org/ or its subproject AsyncWeb:http://mina.apache.org/asyncweb/

This code is better than ours, you only need to add 2 libs:javax.servelet.jar andorg.mortbay.jetty.jar.

Class Jetty:

package jetty;import java.util.logging.Level;import java.util.logging.Logger;import org.mortbay.http.SocketListener;import org.mortbay.jetty.Server;import org.mortbay.jetty.servlet.ServletHttpContext;public class Jetty {    public static void main(String[] args) {        try {            Server server = new Server();            SocketListener listener = new SocketListener();                  System.out.println("Max Thread :" + listener.getMaxThreads() + " Min Thread :" + listener.getMinThreads());            listener.setHost("localhost");            listener.setPort(8070);            listener.setMinThreads(5);            listener.setMaxThreads(250);            server.addListener(listener);                        ServletHttpContext context = (ServletHttpContext) server.getContext("/");            context.addServlet("/MO", "jetty.HelloWorldServlet");            server.start();            server.join();        /*//We will create our server running at http://localhost:8070        Server server = new Server();        server.addListener(":8070");        //We will deploy our servlet to the server at the path '/'        //it will be available at http://localhost:8070        ServletHttpContext context = (ServletHttpContext) server.getContext("/");        context.addServlet("/MO", "jetty.HelloWorldServlet");        server.start();        */        } catch (Exception ex) {            Logger.getLogger(Jetty.class.getName()).log(Level.SEVERE, null, ex);        }    }}

Servlet class:

package jetty;import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class HelloWorldServlet extends HttpServlet{    @Override    protected void doGet(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException    {        String appid = httpServletRequest.getParameter("appid");        String conta = httpServletRequest.getParameter("conta");        System.out.println("Appid : "+appid);        System.out.println("Conta : "+conta);        httpServletResponse.setContentType("text/plain");        PrintWriter out = httpServletResponse.getWriter();        out.println("Hello World!");        out.close();    }}

I can strongly recommend looking intoSimple, especially if you don't need Servlet capabilities but simply access to the request/reponse objects. If you need REST you can put Jersey on top of it, if you need to output HTML or similar there's Freemarker. I really love what you can do with this combination, and there is relatively little API to learn.

checkoutSimple. its a pretty simple embeddable server with built in support for quite a variety of operations. I particularly love its threading model..

Amazing!

Check outtakes. Look athttps://github.com/yegor256/takes for quick info

Try thishttps://github.com/devashish234073/Java-Socket-Http-Server/blob/master/README.md

This API has creates an HTTP server using sockets.

1. It gets a request from the browser as text
2. Parses it to retrieve URL info, method, attributes, etc.
3. Creates dynamic response using the URL mapping defined
4. Sends the response to the browser.

For example the here's how the constructor in theResponse.java class converts a raw response into an http response:

public Response(String resp){    Date date = new Date();    String start = "HTTP/1.1 200 OK\r\n";    String header = "Date: "+date.toString()+"\r\n";    header+= "Content-Type: text/html\r\n";    header+= "Content-length: "+resp.length()+"\r\n";    header+="\r\n";    this.resp=start+header+resp;}

How about Apache CommonsHttpCore project?

From the web site:...HttpCore Goals

• Implementation of the most fundamental HTTP transport aspects
• Balance between good performance and the clarity & expressiveness ofAPI
• Small (predictable) memory footprint
• Self contained library (no external dependencies beyond JRE)

You can write a pretty simpleembedded Jetty Java server.

Embedded Jetty means that the server (Jetty) shipped together with the application as opposed of deploying the application on external Jetty server.

So if in non-embedded approach your webapp built into WAR file which deployed to some external server (Tomcat / Jetty / etc), in embedded Jetty, you write the webapp and instantiate the jetty server in the same code base.

An example for embedded Jetty Java server you cangit clone and use:https://github.com/stas-slu/embedded-jetty-java-server-example

The oldcom.sun.net.httpserver is again a public and accepted API, since Java 11. You can get it asHttpServer class, available as part ofjdk.httpserver module. Seehttps://docs.oracle.com/en/java/javase/11/docs/api/jdk.httpserver/com/sun/net/httpserver/HttpServer.html

This class implements a simple HTTP server. A HttpServer is bound to an IP address and port number and listens for incoming TCP connections from clients on this address. The sub-class HttpsServer implements a server which handles HTTPS requests.

So, apart from its limitations, there is no reason to avoid its use anymore.

I use it to publish a control interface in server applications. Reading theUser-agent header from a client request I even respond intext/plain to CLI tools likecurl or in more elegant HTML way to any other browser.

Cool and easy.

Here is my simple webserver, used in JMeter for testing webhooks (that's why it will close and end itself after request is received).

import java.io.IOException;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;public class HttpServer {    private static int extractContentLength(StringBuilder sb) {        int length = 0;        String[] lines = sb.toString().split("\\n");        for (int i = 0; i < lines.length; i++) {            String s = lines[i];            if (s.toLowerCase().startsWith("Content-Length:".toLowerCase()) && i <= lines.length - 2) {                String slength = s.substring(s.indexOf(":") + 1, s.length()).trim();                length = Integer.parseInt(slength);                System.out.println("Length = " + length);                return length;            }        }        return 0;    }    public static void main(String[] args) throws IOException {                        int port = Integer.parseInt(args[0]);        System.out.println("starting HTTP Server on port " + port);        StringBuilder outputString = new StringBuilder(1000);        ServerSocket serverSocket = new ServerSocket(port);        serverSocket.setSoTimeout(3 * 60 * 1000); // 3 minutes timeout        while (true) {            outputString.setLength(0); // reset buff            Socket clientSocket = serverSocket.accept(); // blocking            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);            try {                boolean isBodyRead = false;                int dataBuffer;                while ((dataBuffer = clientSocket.getInputStream().read()) != -1) {                    if (dataBuffer == 13) { // CR                        if (clientSocket.getInputStream().read() == 10) { // LF                            outputString.append("\n");                        }                    } else {                        outputString.append((char) dataBuffer);                    }                                        // do we have Content length                    int len = extractContentLength(outputString);                    if (len > 0) {                        int actualLength = len - 1; // we need to substract \r\n                        for (int i = 0; i < actualLength; i++) {                            int body = clientSocket.getInputStream().read();                            outputString.append((char) body);                        }                        isBodyRead = true;                        break;                    }                } // end of reading while                if (isBodyRead) {                    // response headers                    out.println("HTTP/1.1 200 OK");                    out.println("Connection: close");                    out.println(); // must have empty line for HTTP                                        out.flush();                     out.close(); // close clients connection                }            } catch (IOException ioEx) {                System.out.println(ioEx.getMessage());            }            System.out.println(outputString.toString());            break; // stop server - break while true                    } // end of outer while true                serverSocket.close();    } // end of method}

You can test it like this:

curl -X POST -H "Content-Type: application/json" -H "Connection: close" -d '{"name": "gustinmi", "email": "gustinmi at google dot com "}' -v http://localhost:8081/

I had some fun, I toyed around and pieced together this. I hope it helps you.You are going to need Gradle installed or use Maven with a plugin.

build.gradle

plugins {    id 'application'}group 'foo.bar'version '1.0'repositories {    mavenCentral()}application{    mainClass.set("foo.FooServer")}dependencies {}

FooServerThe main entry point, your main class.

package foo;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.ServerSocket;import java.net.Socket;import java.nio.ByteBuffer;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentMap;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class FooServer {    public static void main(String[] args) throws IOException {        ServerSocket serverSocket = new ServerSocket(7654);        serverSocket.setPerformancePreferences(0, 1, 2);        /* the higher the numbers, the better the concurrent performance, ha!           we found that a 3:7 ratio to be optimal           3 partitioned executors to 7 network executors */        ExecutorService executors = Executors.newFixedThreadPool(3);        executors.execute(new PartitionedExecutor(serverSocket));    }    public static class PartitionedExecutor implements Runnable {        ServerSocket serverSocket;        public PartitionedExecutor(ServerSocket serverSocket) {            this.serverSocket = serverSocket;        }        @Override        public void run() {            ExecutorService executors = Executors.newFixedThreadPool(30);            executors.execute(new NetworkRequestExecutor(serverSocket, executors));        }    }    public static class NetworkRequestExecutor implements Runnable{        String IGNORE_CHROME = "/favicon.ico";        String BREAK = "\r\n";        String DOUBLEBREAK = "\r\n\r\n";        Integer REQUEST_METHOD = 0;        Integer REQUEST_PATH = 1;        Integer REQUEST_VERSION = 2;        String RENDERER;        Socket socketClient;        ExecutorService executors;        ServerSocket serverSocket;        public NetworkRequestExecutor(ServerSocket serverSocket, ExecutorService executors){            this.serverSocket = serverSocket;            this.executors = executors;        }        @Override        public void run() {            try {                socketClient = serverSocket.accept();                Thread.sleep(19);//do this for safari, its a hack but safari requires something like this.                InputStream requestInputStream = socketClient.getInputStream();                OutputStream clientOutput = socketClient.getOutputStream();                if (requestInputStream.available() == 0) {                    requestInputStream.close();                    clientOutput.flush();                    clientOutput.close();                    executors.execute(new NetworkRequestExecutor(serverSocket, executors));                    return;                }                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);                int bytesRead;                while ((bytesRead = requestInputStream.read(byteBuffer.array())) != -1) {                    byteArrayOutputStream.write(byteBuffer.array(), 0, bytesRead);                    if (requestInputStream.available() == 0) break;                }                String completeRequestContent = byteArrayOutputStream.toString();                String[] requestBlocks = completeRequestContent.split(DOUBLEBREAK, 2);                String headerComponent = requestBlocks[0];                String[] methodPathComponentsLookup = headerComponent.split(BREAK);                String methodPathComponent = methodPathComponentsLookup[0];                String[] methodPathVersionComponents = methodPathComponent.split("\\s");                String requestVerb = methodPathVersionComponents[REQUEST_METHOD];                String requestPath = methodPathVersionComponents[REQUEST_PATH];                String requestVersion = methodPathVersionComponents[REQUEST_VERSION];                if (requestPath.equals(IGNORE_CHROME)) {                    requestInputStream.close();                    clientOutput.flush();                    clientOutput.close();                    executors.execute(new NetworkRequestExecutor(serverSocket, executors));                    return;                }                ConcurrentMap<String, String> headers = new ConcurrentHashMap<>();                String[] headerComponents = headerComponent.split(BREAK);                for (String headerLine : headerComponents) {                    String[] headerLineComponents = headerLine.split(":");                    if (headerLineComponents.length == 2) {                        String fieldKey = headerLineComponents[0].trim();                        String content = headerLineComponents[1].trim();                        headers.put(fieldKey.toLowerCase(), content);                    }                }                clientOutput.write("HTTP/1.1 200 OK".getBytes());                clientOutput.write(BREAK.getBytes());                Integer bytesLength = "hi".length();                String contentLengthBytes = "Content-Length:" + bytesLength;                clientOutput.write(contentLengthBytes.getBytes());                clientOutput.write(BREAK.getBytes());                clientOutput.write("Server: foo server".getBytes());                clientOutput.write(BREAK.getBytes());                clientOutput.write("Content-Type: text/html".getBytes());                clientOutput.write(DOUBLEBREAK.getBytes());                clientOutput.write("hi".getBytes());                clientOutput.close();                socketClient.close();                executors.execute(new NetworkRequestExecutor(serverSocket, executors));            } catch (IOException ex) {                ex.printStackTrace();            } catch (InterruptedException ioException) {                ioException.printStackTrace();            }        }    }}

Run it:

gradle run

Browse to:

http://localhost:7654/

Your question has a very good pool of answers covering a creation web server just using Java SE. However, some people can be interesting in a similar solution running on the Android platform. It's very naturally limited to Java SE and even a max JVM version can be limited to Java 8. I use Atjeews for creation web server on Android. It's open source and you can check sources atGitHub.The server can be also easily embedded in your Android application, for example:

void uploadWork(boolean start) {    if (start) {        if (serv == null) {            serv = new Serve1();            serv.addServlet("/*", new Uploader(this));        } else if (serv.isRunning())            return;        Properties properties = new Properties();        properties.put(Serve.ARG_PORT, options.getPort());        properties.setProperty(Serve.ARG_NOHUP, "nohup");        serv.arguments = properties;        new Thread(new Runnable() {            @Override            public void run() {                PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);                PowerManager.WakeLock fullLock = pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK,                        getClass().getName());                fullLock.acquire();                try {                    serv.serve();                } finally {                    if (fullLock.isHeld())                        fullLock.release();                }            }        }).start();    } else {        if (serv != null)            serv.notifyStop();    }}

Using servlet concept simplifies creation of a web server, because you can be focused on a business logic required to your app and delegate all HTTP work to a servlet engine.

• java
• http
• httpserver