it-swarm.com.de

einfacher HTTP-Server in Java, der nur Java SE API verwendet

Gibt es eine Möglichkeit, einen sehr einfachen HTTP-Server (der nur GET/POST unterstützt) in Java zu erstellen, indem nur die Java SE-API verwendet wird, ohne Code schreiben zu müssen, um HTTP-Anforderungen manuell zu analysieren und HTTP-Antworten manuell zu formatieren? Die Java SE-API kapselt die HTTP-Clientfunktionalität gut in HttpURLConnection, aber gibt es eine Analogfunktion für die HTTP-Serverfunktionalität?

Um es klar zu sagen, das Problem, das ich bei vielen ServerSocket-Beispielen, die ich online gesehen habe, habe, ist, dass sie ihre eigenen Anforderungsanalyse-/Antwortformatierungen und Fehlerbehandlungen durchführen. und ich versuche es aus diesen Gründen zu vermeiden.

Als Beispiel für die manuelle HTTP-Manipulation, die ich zu vermeiden versuche:

http://Java.Sun.com/developer/technicalArticles/Networking/Webserver/WebServercode.html

291
asker

Seit Java SE 6 gibt es einen integrierten HTTP-Server Sonne Oracle JRE. Die com.Sun.net.httpserver-Paketübersicht umreißt die beteiligten Klassen und enthält Beispiele.

Hier ist ein Kickoff-Beispiel copypasted aus ihren Dokumenten (an alle Leute, die versuchen, es trotzdem zu bearbeiten, da dies ein hässlicher Code ist, bitte nicht, dies ist ein Copy-Paste, nicht meiner, außerdem sollten Sie niemals Zitate bearbeiten es sei denn, sie haben sich in der Originalquelle geändert). Sie können es einfach auf Java 6+ kopieren und kopieren.

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();
        }
    }

}

Es sollte bemerkt werden, dass der response.length()-Teil in ihrem Beispiel schlecht ist. Er hätte response.getBytes().length sein sollen. Selbst dann muss die getBytes()-Methode explizit den Zeichensatz angeben, den Sie dann im Antwortheader angeben. Leider ist dies zwar ein Irrtum für Anfänger, aber es ist nur ein einfaches Kick-Off-Beispiel.

Führen Sie es aus und gehen Sie zu http: // localhost: 8000/test . Daraufhin wird die folgende Antwort angezeigt:

Dies ist die Antwort


Beachten Sie bei der Verwendung von com.Sun.*-Klassen, dass dies im Gegensatz zu dem, was einige Entwickler meinen, absolut nicht verboten ist durch die bekannten FAQ Warum Entwickler keine Programme schreiben sollten, die "Sun" -Pakete nennen . Dieses FAQ betrifft das Sun.*-Paket (wie Sun.misc.BASE64Encoder) für die interne Verwendung durch die Oracle-JRE (wodurch Ihre Anwendung abgebrochen würde, wenn Sie sie auf einer anderen JRE ausführen), nicht das com.Sun.*-Paket. Sun/Oracle entwickelt auch Software wie jede andere Firma wie Apache und so weiter. Die Verwendung von com.Sun.*-Klassen wird nur empfohlen (aber nicht verboten), wenn es sich um eine -Implementierung einer bestimmten Java-API handelt, wie z. B. GlassFish (Java EE impl), Mojarra (JSF impl), Jersey (JAX-RS impl) usw. .

426
BalusC

Auschecken NanoHttpd

"NanoHTTPD ist ein leichter HTTP - Server, der zum Einbetten in andere Anwendungen entwickelt wurde und unter einer modifizierten BSD - Lizenz veröffentlicht wurde.

Es wird bei Github entwickelt und verwendet Apache Maven für Builds & Unit-Tests. "

41
letronje

Die com.Sun.net.httpserver -Lösung ist nicht über JREs portierbar. Es ist besser, die offizielle Webservices API in javax.xml.ws zu verwenden, um einen minimalen HTTP-Server zu booten.

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: das funktioniert eigentlich! Der obige Code sieht aus wie Groovy oder so. Hier ist eine Übersetzung nach Java, die ich getestet habe:

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);
    }
}
25
gruenewa

Schauen Sie sich den "Jetty" Webserver Jetty an. Ein hervorragendes Stück Open-Source-Software, das alle Ihre Anforderungen zu erfüllen scheint.

Wenn Sie darauf bestehen, selbst zu rollen, schauen Sie sich die Klasse "httpMessage" an.

20
James Anderson

Ich mag diese Frage, weil es in diesem Bereich stetige Innovationen gibt und immer ein Light-Server erforderlich ist, insbesondere wenn es sich um eingebettete Server in kleinen Geräten handelt. Ich denke, die Antworten lassen sich in zwei große Gruppen einteilen.

  1. Thin-Server: statischer Inhalt des Servers mit minimaler Verarbeitung, Kontext oder Sitzungsverarbeitung.
  2. Small-server: angeblich hat a viele httpD-artige Serverqualitäten mit einem so geringen Footprint, wie Sie nur können.

Während ich HTTP-Bibliotheken wie: Jetty , Apache HTTP-Komponenten , Netty und andere betrachten könnte, ähneln sie eher einer rohen HTTP-Verarbeitungseinrichtung. Die Kennzeichnung ist sehr subjektiv und hängt von der Art der Dinge ab, die Sie für kleine Websites bereitgestellt haben. Ich mache diese Unterscheidung im Geiste der Frage, insbesondere die Bemerkung über ...

  • "... ohne Code schreiben zu müssen, um HTTP-Anforderungen manuell zu analysieren und HTTP-Antworten manuell zu formatieren ..."

Mit diesen Rohwerkzeugen können Sie das tun (wie in anderen Antworten beschrieben). Sie eignen sich nicht wirklich für einen Ready-Set-Go-Stil, bei dem leichte, eingebettete oder Mini-Server hergestellt werden. Ein Mini-Server ist etwas, das Ihnen eine ähnliche Funktionalität wie einen voll funktionsfähigen Webserver (wie zum Beispiel Tomcat ) ohne Schnickschnack, geringes Volumen und gute Leistung in 99% der Fälle bieten kann. Ein Thin-Server scheint der ursprünglichen Formulierung nur ein wenig mehr als nur roh zu sein, vielleicht mit einer begrenzten Teilmenge-Funktionalität, genug, um Sie in 90% der Fälle gut aussehen zu lassen. Meine Vorstellung von raw würde mich 75% der Zeit ohne zusätzliches Design und Codierung gut aussehen lassen. Ich denke, wenn/wenn Sie das Niveau der WAR-Dateien erreichen, haben wir das "kleine" für Bonsi-Server gelassen, das wie alles aussieht, was ein großer Server kleiner macht.

Thin-Server-Optionen

Mini-Server-Optionen:

  • Spark Java ... Mit vielen Hilfskonstrukten wie Filtern, Vorlagen usw. sind gute Dinge möglich.
  • MadVoc ... will Bonsai sein und könnte auch so sein ;-)

Zu den anderen Aspekten, die zu berücksichtigen sind, würde ich Authentifizierung, Validierung, Internationalisierung sowie die Verwendung von FreeMaker oder eines anderen Vorlagen-Tools zum Rendern der Seitenausgabe einschließen. Andernfalls führt die Verwaltung von HTML-Bearbeitungen und -Parametrierungen dazu, dass die Arbeit mit HTTP wie ein Noughts-N-Crosses aussieht. Natürlich hängt alles davon ab, wie flexibel Sie sein müssen. Wenn es sich um eine menügesteuerte Faxmaschine handelt, kann dies sehr einfach sein. Je mehr Interaktionen erforderlich sind, desto "dicker" muss Ihr Rahmen sein. Gute Frage, viel Glück!

17
will

Ich habe einmal nach etwas Ähnlichem gesucht - einem leichtgewichtigen, aber voll funktionsfähigen HTTP-Server, den ich problemlos einbetten und anpassen kann. Ich habe zwei Arten von möglichen Lösungen gefunden:

  • Vollständige Server, die nicht ganz so leicht oder einfach sind (für eine extreme Definition von Leichtgewicht).
  • Wirklich schlanke Server, die keine echten HTTP-Server sind, aber ServerSocket-Beispiele verherrlicht, die nicht einmal aus der Ferne RFC-konform sind und normalerweise erforderliche grundlegende Funktionen nicht unterstützen.

Also ... Ich habe mich zum Schreiben von JLHTTP - Der Java Lightweight HTTP Server entschieden.

Sie können es in jedes Projekt als einzelne (wenn auch lange) Quelldatei oder als ~ 50K-Dose (~ 35K) ohne Abhängigkeiten einbetten. Es ist bestrebt, RFC-konform zu sein und umfasst eine umfangreiche Dokumentation und viele nützliche Funktionen, während das Aufblasen auf ein Minimum reduziert wird.

Zu den Features gehören: virtuelle Hosts, File Serving von der Festplatte, Mime-Typ-Mappings über die Standard-Mime.types-Datei, Verzeichnisindexgenerierung, Willkommen-Dateien, Unterstützung für alle HTTP-Methoden, Unterstützung für bedingte ETags und If- * - Header, Chunked-Transfer-Codierung, gzip/deflate Komprimierung, einfaches HTTPS (wie von der JVM bereitgestellt), Teilinhalt (Download-Fortsetzung), Verarbeitung von Multipart-/Formulardaten für Dateiuploads, mehrere Kontext-Handler über API oder Annotationen, Parameteranalyse (Abfragezeichenfolge oder x-www-form-urlencoded) Körper) usw.

Ich hoffe, andere finden es nützlich :-)

15
amichair

Spark ist der einfachste, hier ist eine Kurzanleitung: http://sparkjava.com/

9
Laercio Metzner
8
Nikos

Es ist möglich, einen HTTP-Server zu erstellen, der grundlegende Unterstützung für J2EE-Servlets mit nur dem JDK und dem Servlet-API in nur wenigen Codezeilen bietet. 

Ich habe festgestellt, dass dies für Unit-Test-Servlets sehr nützlich ist, da es wesentlich schneller als andere leichte Container startet (wir verwenden einen Steg für die Produktion). 

Die meisten sehr einfachen HTTP-Server bieten keinen Support für Servlets, aber wir brauchen sie, also dachte ich, ich würde sie teilen.

Das folgende Beispiel bietet grundlegende Servlet-Unterstützung oder löst und UnsupportedOperationException für noch nicht implementierte Elemente aus. Es verwendet den com.Sun.net.httpserver.HttpServer für die grundlegende HTTP-Unterstützung.

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());
    }
}
7
f.carlsen

Ich kann dringend nach Simple suchen, insbesondere wenn Sie keine Servlet-Funktionen benötigen, sondern einfach auf die Request/Reponse-Objekte zugreifen. Wenn Sie REST benötigen, können Sie Jersey darüber legen, wenn Sie HTML oder ähnliches ausgeben müssen, gibt es Freemarker. Ich finde es wirklich toll, was man mit dieser Kombination machen kann, und es gibt relativ wenig API, die man lernen kann.

6
Waldheinz

Dieser Code ist besser als bei uns, Sie müssen nur 2 Bibliotheken hinzufügen: javax.servlet.jar und org.mortbay.jetty.jar

Klassensteg:

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-Klasse: 

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();
    }
}
5
leandro

Sie können sich auch einige NIO-Anwendungsframeworks ansehen, wie zum Beispiel: 

  1. Netty: http://jboss.org/netty
  2. Apache Mina: http://mina.Apache.org/ oder dessen Unterprojekt AsyncWeb: http://mina.Apache.org/asyncweb/
5
ThiamTeck

Check out takes. Siehe https://github.com/yegor256/takes für eine schnelle Info

3
George

kasse Einfach . Es ist ein ziemlich einfacher, einbettbarer Server mit integrierter Unterstützung für eine Vielzahl von Operationen. Ich liebe besonders das Einfädelmodell.

Tolle!

3
Olu Smith

Wie wäre es mit Apache Commons HttpCore project? 

Von der Website: ... HttpCore Goals

  • Implementierung der grundlegendsten HTTP-Transportaspekte
  • Balance zwischen guter Leistung und Klarheit und Ausdruckskraft von API
  • Kleiner (vorhersagbarer) Speicherbedarf
  • In sich geschlossene Bibliothek (keine externen Abhängigkeiten außerhalb von JRE)
2
I. Joseph

Sie können einen recht einfachen eingebetteten Jetty Java-Server schreiben.

Embedded Jetty bedeutet, dass der Server (Jetty) zusammen mit der Anwendung geliefert wurde, anstatt die Anwendung auf einem externen Jetty-Server bereitzustellen.

Wenn also Ihre Webapp bei nicht eingebetteter Methode in eine WAR-Datei integriert ist, die auf einem externen Server ( Tomcat / Jetty/etc) bereitgestellt wird, schreiben Sie in Embedded Jetty die Webapp und instanziieren den Jetty-Server in derselben Codebasis.

Ein Beispiel für einen eingebetteten Jetty-Java-Server können Sie git clone und verwenden: https://github.com/stas-slu/embedded-jetty-Java-server-example

1
Stas

Alle obigen Antworten beziehen sich auf den Single Handed Request Handler.

rahmen:

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

Ermöglicht die Bereitstellung mehrerer Anfragen über mehrere Threads mit dem Executor-Dienst.

Der Endcode wird also wie folgt aussehen:

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();
        }
    }
}
1
Balu mallisetty

Probieren Sie diese https://github.com/devashish234073/Java-Socket-Http-Server/blob/master/README.md

Diese API hat einen http-Server mit Sockets erstellt. Einzelheiten:
1. Es erhält eine Anfrage vom Browser als Text
2. Parst es, um URL-Informationen, Methoden, Attribute usw. abzurufen.
3.Erzeugt eine dynamische Antwort unter Verwendung der definierten URL-Zuordnung
4.Sendet die Antwort an den Browser.

So konvertiert der Konstruktor in der Klasse "Response.Java" eine rohe Antwort in eine http-Antwort:


öffentliche Antwort (String bzw.) { 
Datum Datum = neues Datum ();
String start = "HTTP/1.1 200 OK\r\n";
String header = "Date:" + date.toString () + "\ r\n";
header + = "Inhaltstyp: text/html\r\n";
header + = "content-length:" + resp. länge () + "\ r\n";
header + = "\ r\n";
this.resp = start + header + bzw.
}