Ein Leitfaden für NanoHTTPD

1. Einleitung

NanoHTTPD ist ein Open-Source-Webserver, der in Java geschrieben ist.

In diesem Tutorial erstellen wir einige REST-APIs, um deren Funktionen zu untersuchen.

2. Projekteinrichtung

Fügen wir unserer pom.xml die NanoHTTPD-Kernabhängigkeit hinzu :

 org.nanohttpd nanohttpd 2.3.1 

Um einen einfachen Server zu erstellen, müssen wir NanoHTTPD erweitern und seine Serve- Methode überschreiben :

public class App extends NanoHTTPD { public App() throws IOException { super(8080); start(NanoHTTPD.SOCKET_READ_TIMEOUT, false); } public static void main(String[] args ) throws IOException { new App(); } @Override public Response serve(IHTTPSession session) { return newFixedLengthResponse("Hello world"); } }

Wir haben unseren laufenden Port als 8080 und den Server als Daemon definiert (kein Lesezeitlimit).

Sobald wir die Anwendung starten, gibt die URL // localhost: 8080 / die Nachricht Hello world zurück . Wir verwenden die NanoHTTPD # newFixedLengthResponse- Methode als bequeme Methode zum Erstellen eines NanoHTTPD.Response- Objekts.

Probieren wir unser Projekt mit cURL aus:

> curl '//localhost:8080/' Hello world

3. REST-API

In Bezug auf HTTP-Methoden ermöglicht NanoHTTPD GET, POST, PUT, DELETE, HEAD, TRACE und mehrere andere.

Einfach ausgedrückt, können wir unterstützte HTTP-Verben über die Methode enum finden. Mal sehen, wie das abläuft.

3.1. HTTP GET

Schauen wir uns zunächst GET an. Angenommen, wir möchten Inhalte nur zurückgeben, wenn die Anwendung eine GET-Anforderung empfängt.

Im Gegensatz zu Java-Servlet-Containern steht keine doGet- Methode zur Verfügung. Stattdessen überprüfen wir den Wert einfach über getMethod :

@Override public Response serve(IHTTPSession session) { if (session.getMethod() == Method.GET) { String itemIdRequestParameter = session.getParameters().get("itemId").get(0); return newFixedLengthResponse("Requested itemId = " + itemIdRequestParameter); } return newFixedLengthResponse(Response.Status.NOT_FOUND, MIME_PLAINTEXT, "The requested resource does not exist"); }

Das war ziemlich einfach, oder? Lassen Sie uns einen kurzen Test durchführen, indem wir unseren neuen Endpunkt kräuseln und feststellen, dass der Anforderungsparameter itemId korrekt gelesen wird:

> curl '//localhost:8080/?itemId=23Bk8' Requested itemId = 23Bk8

3.2. HTTP POST

Wir haben zuvor auf ein GET reagiert und einen Parameter aus der URL gelesen.

Um die beiden beliebtesten HTTP-Methoden zu behandeln, müssen wir einen POST durchführen (und damit den Anforderungshauptteil lesen):

@Override public Response serve(IHTTPSession session) { if (session.getMethod() == Method.POST) { try { session.parseBody(new HashMap()); String requestBody = session.getQueryParameterString(); return newFixedLengthResponse("Request body = " + requestBody); } catch (IOException | ResponseException e) { // handle } } return newFixedLengthResponse(Response.Status.NOT_FOUND, MIME_PLAINTEXT, "The requested resource does not exist"); }
Beachten Sie, dass wir zuvor, als wir nach dem Anforderungshauptteil gefragt haben, zuerst die parseBody- Methode aufgerufen haben . Das liegt daran, dass wir den Anforderungshauptteil zum späteren Abrufen laden wollten.

Wir werden einen Body in unseren cURL- Befehl aufnehmen:

> curl -X POST -d 'deliveryAddress=Washington nr 4&quantity=5''//localhost:8080/' Request body = deliveryAddress=Washington nr 4&quantity=5

Die verbleibenden HTTP-Methoden sind sehr ähnlich, daher überspringen wir diese.

4. Ursprungsübergreifende gemeinsame Nutzung von Ressourcen

Mit CORS ermöglichen wir die domänenübergreifende Kommunikation. Der häufigste Anwendungsfall sind AJAX-Aufrufe aus einer anderen Domäne. Der erste Ansatz, den wir verwenden können, besteht darin, CORS für alle unsere APIs zu aktivieren. Mit dem Argument - -cors erlauben wir den Zugriff auf alle Domänen. Wir können auch definieren, welche Domänen wir mit –cors = ”// dashboard.myApp.com //admin.myapp.com” zulassen . Der zweite Ansatz besteht darin, CORS für einzelne APIs zu aktivieren. Mal sehen, wie man addHeader verwendet , um dies zu erreichen:
@Override public Response serve(IHTTPSession session) { Response response = newFixedLengthResponse("Hello world"); response.addHeader("Access-Control-Allow-Origin", "*"); return response; }

Wenn wir jetzt cURLEN , erhalten wir unseren CORS-Header zurück:

> curl -v '//localhost:8080' HTTP/1.1 200 OK Content-Type: text/html Date: Thu, 13 Jun 2019 03:58:14 GMT Access-Control-Allow-Origin: * Connection: keep-alive Content-Length: 11 Hello world

5. Datei hochladen

NanoHTTPD hat eine separate Abhängigkeit für das Hochladen von Dateien. Fügen wir sie also unserem Projekt hinzu:

 org.nanohttpd nanohttpd-apache-fileupload 2.3.1   javax.servlet javax.servlet-api 4.0.1 provided 

Bitte beachten Sie, dass die Servlet-API- Abhängigkeit ebenfalls benötigt wird (andernfalls wird ein Kompilierungsfehler angezeigt).

Was NanoHTTPD verfügbar macht, ist eine Klasse namens NanoFileUpload :

@Override public Response serve(IHTTPSession session) { try { List files = new NanoFileUpload(new DiskFileItemFactory()).parseRequest(session); int uploadedCount = 0; for (FileItem file : files) { try { String fileName = file.getName(); byte[] fileContent = file.get(); Files.write(Paths.get(fileName), fileContent); uploadedCount++; } catch (Exception exception) { // handle } } return newFixedLengthResponse(Response.Status.OK, MIME_PLAINTEXT, "Uploaded files " + uploadedCount + " out of " + files.size()); } catch (IOException | FileUploadException e) { throw new IllegalArgumentException("Could not handle files from API request", e); } return newFixedLengthResponse( Response.Status.BAD_REQUEST, MIME_PLAINTEXT, "Error when uploading"); }

Hey, lass es uns ausprobieren:

> curl -F '[email protected]/pathToFile.txt' '//localhost:8080' Uploaded files: 1

6. Mehrere Routen

Ein Nanolet ist wie ein Servlet, hat aber ein sehr niedriges Profil. Wir können sie verwenden, um viele Routen zu definieren, die von einem einzelnen Server bedient werden (im Gegensatz zu früheren Beispielen mit einer Route).

Fügen wir zunächst die erforderliche Abhängigkeit für Nanolets hinzu :

 org.nanohttpd nanohttpd-nanolets 2.3.1 

Und jetzt erweitern wir unsere Hauptklasse mithilfe von RouterNanoHTTPD, definieren unseren laufenden Port und lassen den Server als Daemon ausführen.

The addMappings method is where we'll define our handlers:

public class MultipleRoutesExample extends RouterNanoHTTPD { public MultipleRoutesExample() throws IOException { super(8080); addMappings(); start(NanoHTTPD.SOCKET_READ_TIMEOUT, false); } @Override public void addMappings() { // todo fill in the routes } }

The next step is to define our addMappings method. Let's define a few handlers.

The first one is an IndexHandler class to “/” path. This class comes with the NanoHTTPD library and returns by default a Hello World message. We can override the getText method when we want a different response:

addRoute("/", IndexHandler.class); // inside addMappings method

And to test our new route we can do:

> curl '//localhost:8080' 

Hello world!

Secondly, let's create a new UserHandler class which extends the existing DefaultHandler. The route for it will be /users. Here we played around with the text, MIME type, and the status code returned:

public static class UserHandler extends DefaultHandler { @Override public String getText() { return "UserA, UserB, UserC"; } @Override public String getMimeType() { return MIME_PLAINTEXT; } @Override public Response.IStatus getStatus() { return Response.Status.OK; } }

To call this route we'll issue a cURL command again:

> curl -X POST '//localhost:8080/users' UserA, UserB, UserC

Finally, we can explore the GeneralHandler with a new StoreHandler class. We modified the returned message to include the storeId section of the URL.

public static class StoreHandler extends GeneralHandler { @Override public Response get( UriResource uriResource, Map urlParams, IHTTPSession session) { return newFixedLengthResponse("Retrieving store for id = " + urlParams.get("storeId")); } }

Let's check our new API:

> curl '//localhost:8080/stores/123' Retrieving store for id = 123

7. HTTPS

In order to use the HTTPS, we'll need a certificate. Please refer to our article on SSL for more in-depth information.

We could use a service like Let's Encrypt or we can simply generate a self-signed certificate as follows:

> keytool -genkey -keyalg RSA -alias selfsigned -keystore keystore.jks -storepass password -validity 360 -keysize 2048 -ext SAN=DNS:localhost,IP:127.0.0.1 -validity 9999

Next, we'd copy this keystore.jks to a location on our classpath, like say the src/main/resources folder of a Maven project.

After that, we can reference it in a call to NanoHTTPD#makeSSLSocketFactory:

public class HttpsExample extends NanoHTTPD { public HttpsExample() throws IOException { super(8080); makeSecure(NanoHTTPD.makeSSLSocketFactory( "/keystore.jks", "password".toCharArray()), null); start(NanoHTTPD.SOCKET_READ_TIMEOUT, false); } // main and serve methods }

And now we can try it out. Please notice the use of the —insecure parameter, because cURL won't be able to verify our self-signed certificate by default:

> curl --insecure '//localhost:8443' HTTPS call is a success

8. WebSockets

NanoHTTPD supports WebSockets.

Let's create the simplest implementation of a WebSocket. For this, we'll need to extend the NanoWSD class. We'll also need to add the NanoHTTPD dependency for WebSocket:

 org.nanohttpd nanohttpd-websocket 2.3.1 

For our implementation, we'll just reply with a simple text payload:

public class WsdExample extends NanoWSD { public WsdExample() throws IOException { super(8080); start(NanoHTTPD.SOCKET_READ_TIMEOUT, false); } public static void main(String[] args) throws IOException { new WsdExample(); } @Override protected WebSocket openWebSocket(IHTTPSession ihttpSession) { return new WsdSocket(ihttpSession); } private static class WsdSocket extends WebSocket { public WsdSocket(IHTTPSession handshakeRequest) { super(handshakeRequest); } //override onOpen, onClose, onPong and onException methods @Override protected void onMessage(WebSocketFrame webSocketFrame) { try { send(webSocketFrame.getTextPayload() + " to you"); } catch (IOException e) { // handle } } } }

Instead of cURL this time, we'll use wscat:

> wscat -c localhost:8080 hello hello to you bye bye to you

9. Conclusion

Zusammenfassend haben wir ein Projekt erstellt, das die NanoHTTPD-Bibliothek verwendet. Als Nächstes haben wir RESTful-APIs definiert und weitere HTTP-bezogene Funktionen untersucht. Am Ende haben wir auch ein WebSocket implementiert.

Die Implementierung all dieser Snippets ist über GitHub verfügbar.