Anzeige
Jetty Webserver in einem Javaprogramm

Jetty Webserver in einem Javaprogramm

Ich gehe hier der Frage nach wie übertrage ich Daten von
Android nach einem PC/Server
Teil eins: Der Webserver in der Java anwendung

http://www.eclipse.org/jetty/
https://webtide.com/downloads/

http://www.eclipse.org/jetty/documentation/current/advanced-embedding.html

Download:
https://repo1.maven.org/maven2/org/...v20160915/jetty-all-9.3.12.v20160915-uber.jar

Embedded Webserver Jetty für Java

Alles fing mit der Frage an: "Wie übertrage ich Daten von Android zum Server"

Mit der Suche im Web bin ich auf diverse Begriffe gestossen wie "REST", "SOAP"

alle diese Techniken benötigen allerdings auf der Serverseite viel Aufwand
und folgen der Idee "Server startet Anwendung". Und alle diese Techniken basieren auf
Html / Web Übertragungs techniken.

Ich wollte aber was "kleines" was in Java eingebunden werden kann, also ein Server in der Java Anwendung.

Auf der Server / PC Seite bin ich bei meiner Suche auf embedded Jetty gestossen, einem Webserver der in einem Javaprogramm
eingebunden werden kann.

Siehe auch http://www.eclipse.org/jetty/documentation/current/advanced-embedding.html

"embedded" ist in dem zusammenhang wichtig, da es den Jetty auch als vollwertigen Http Server gibt der dem klassischen .
Aufbau folgt "Webserver startet Anwendung".

Schauen wir erst mal auf die Übertragungsmöglichkeiten beim Webserver.
Daten zum Server : dort gibt es POST, GET, und Fileupload.
GET ist die Technik wo die Informationen an die URL "dranhängen"
POST ist die bessere Wahl, da die Daten im Header mit übergeben werden und diese Version wird hier im Tutorial eingesetzt.

Bei POST arbeitet man mit Key und Value, man überträgt ein Variablennamen
und den Inhalt dazu.
Daten zum Client Transport ist einfach Text in Form von XML / Html oder auch Filedownload.

Kommen wir zum Jettyserver. Der Server arbeitet Ereignisgesteuert wobei das Ereignis
das aufrufen einer URL ist. Sobald der Server aufgerufen wird ruft der seinerseits ein
Handler oder ein Servlet auf. Da es hier um möglichst einfach geht behandle ich hier
die Handler Technik.

Der Jettyserver ruft genau einen Handler auf. Das ist langweilig :) Aber die Einschränkung bekommen wir auch noch
geregelt.

Starten wir einfach mit einem AbstractHandler einer der Grundklasse für Handler.

Unter dem Strich geht es darum eine Classe zu schreiben die den AbstractHandler erweitert
um vom Client übertragenden Postdaten zu verarbeiten.

Fangen wir mit der simplen Variante an:

Code:
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.HandlerList;
import org.eclipse.jetty.server.handler.ResourceHandler;

public class TutorialServer {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("start");
    
        // erzeugen des Jetty Servers auf port 8080
        Server server = new Server(8080);
        // setup Handler - hier wird noch erweitert
    
        //der Jettyserver bekommt unseren erweiterten Handler
        server.setHandler(new MyTestHandler());
    
    
        // und start Server
        try {
            server.start();
            server.join();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}
Das war schon der Server.
Kommen wir zu unserem Handler - dazu muss die Classe den AbstractHandler erweitern.
Unser Handler sendet ein Eingabeformular und druckt die vom Formular gesendeten Postvariablen Name/Inhalt aus.

Code:
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.handler.AbstractHandler;


public class MyTestHandler extends AbstractHandler {

    @Override
    public void handle(String string, Request baserequest, HttpServletRequest hsr, HttpServletResponse response) throws IOException, ServletException {
        // response encoding and types
        response.setContentType("text/html; charset=utf-8");

        // response status code - sende alles ok an Client
        response.setStatus(HttpServletResponse.SC_OK);

        System.out.println("method :" + hsr.getMethod());  //welche methode - POST oder GET
        System.out.println("pathinfo " + hsr.getPathInfo()); //verzeichnis Pfad abzüglich Context
        System.out.println("context " + hsr.getContextPath()); // in welchen Context bewegen wir uns
    
        // POST Variablen namen ausgeben
    
        Enumeration<String> list = hsr.getParameterNames();
        while (list.hasMoreElements()) {
            String postname = list.nextElement(); //variablenname
            String postvalue = hsr.getParameter(postname); //inhalt der Variable
            System.out.println("var " + postname + " value " + postvalue); //ausgabe auf Console
        }

        // Write response: hier ein kleines Eingabeformular für den Client für den Anfang
        response.getWriter().println("<h1>Hello World</h1><form action=\"/test/return.html\" method=\"post\" > ");
        response.getWriter().println("<input type=\"text\" name=\"return\" /> ");
        response.getWriter().println("</form>");

        // Sage dem Server das die Anfrage abgearbeitet wurde - sprich wenn weitere Handler noch in der Liste sind
        // die werden nicht mehr gebraucht
        baserequest.setHandled(true);

    }

}
Bei dem Aufbau des Eingabeformulars ist das \ Zeichen ein Maskierungszeichen für die " Zeichen.
aus \" wird nach dem Compilerdurchlauf ".

Kommen wir zu der Technik das mehrere Handler abgearbeitet werden können.

Um das zu erreichen setzt man eine HandlerList ein. Das ist ein Handler der alle Handler aufruft die in seiner
interne Liste sind.

Code:
HandlerList handlerlist = new HandlerList();
handlerlist.addHandler(cont);
mit addHandler wird ein Handler zur Liste hinzugefügt.


Als nächstes benötigen wir ein Filter. Das wird mittels eines ContextHandler gemacht.

Ein Context ist ein Teil der URL die vom Client aufgerufen wird.
Wir haben folgenden URL Aufbau:
//my.webserver.de/context_teil/datei.html

Ein ContexHandler arbeitet als Filter, da er nur Anfragen vom Client an den nächsten Handler weiterleitet
die dem Context entsprechen.

Wenn wir die main classe erweitern:

Code:
   // erzeugen des Jetty Servers auf port 8080
   Server server = new Server(8080);
   // main wird erweitert
 
   // erzeugen der Handlerliste
   HandlerList handlerlist = new HandlerList();

   // erzeuge Filter mit dem context /test
   ContextHandler cont = new ContextHandler("/test");
   // filter ruft erneut unser eigenen Handler auf
   cont.setHandler(new MyTestHandler());
   // filer auf die Liste  
   handlerlist.addHandler(cont);
   // server erhält die liste    
   server.setHandler(handlerlist);
   // starte Server siehe oben
Kommen wir zum folgenden Aufbau: (> steht für ruft auf)

JettyServer > HandlerList (ruft alle Handler in der Liste auf) > ContexHandler (Filter) > eigene Classe (AbstractHandler)


Hier im Tutorial gehe ich davon aus das unser Server die IP 192.168.1.50 hat, bei eigenen Versuchen bitte entsprechend anpassen.

Wenn wir nun das Programm starten und mit dem Browser "//192.168.1.50:8080/test aufrufen" kommt ein nettes Hallo und ein
Einabeformular. Das ruft beim absenden erneut die Seite auf und unser Server sollte die Post Variablename "return" ausgeben
und das was wir im Browser eingegeben haben.
Allerdings bekommen wir vom Server nur dann eine Antwort wenn wir den context (verzeichnis) /test nutzen.

lernen wir den ResourceHandler kennen.
dem Handler können wir ein Verzeichnis auf dem Server mitgeben und dort sollte eine Webseite sein.
Die Webseite muss allerdings Statisch sein, also Html Dateien pur - auch mit Unterverzeichnissen, Links gehen natürlich :)
So einfach kann ein Webserver sein.

Code:
// weiterer Handler für die Main Classe

        ResourceHandler resource_handler = new ResourceHandler();
        resource_handler.setDirectoriesListed(true);
        resource_handler.setWelcomeFiles(new String[]{"index.html"});
        //das locale verzeichnis auf dem Rechner setzen - muss euren gegebenheiten angepasst werden !
        resource_handler.setResourceBase("/home/susi/homepage/www.net-wolf.de"); //das locale verzeichnis auf dem Rechner

        ContextHandler chtm = new ContextHandler("/html");
        chtm.setHandler(resource_handler);
        // der neue Handler auf die Liste
        handlerlist.addHandler(chtm);
jetzt haben wir 2 Urls die wir aufrufen können.
//192.168.1.50:8080/test ist weiter unser Eingabeformular
//192.168.1.50:8080/html ist die statische Webseite
Autor
melmager
First release
Last update
Bewertung
0,00 Stern(e) 0 Bewertungen

More resources from melmager

Anzeige