Weiterlesen »]]> Wer kennt sie nicht? In fast jedem System mit Datenaustausch sind sie zu finden. Und falls nicht, benötigt sie mindestens eine das System nutzende Fachabteilung um sie in Excel einzulesen. Die Rede ist von csv Dateien, beschrieben in rfc4180, die einfachste Form des strukturierten Datenaustauschs. Wer beim Verarbeiten der Dateien zur Abwechslung mal nicht mit StringTokenizer, StringBuilder und Listen von Strings hantieren möchte, sollte einen Blick auf opencsv werfen. Insbesondere das Binding der csv Daten an JavaBeans ist erleichtert das Einlesen der Daten enorm, hier das Beispiel dazu aus der Dokumentation:

ColumnPositionMappingStrategy strat = new ColumnPositionMappingStrategy();
strat.setType(YourOrderBean.class);
// the fields to bind do in your JavaBean
String[] columns = new String[] {"name", "orderNumber", "id"};
strat.setColumnMapping(columns);

CsvToBean csv = new CsvToBean();
List list = csv.parse(strat, yourReader);

Alles in allem ein hilfreiches kleines Framework, das die Arbeit mit csv Dateien erleichtert.

Weiterlesen »]]> Bei sehr großen Formularen kann es vorkommen, dass jbossweb an das Limit der Request Parameter stößt, dies resultiert dann in folgender Fehlermeldung:

java.lang.IllegalStateException: More than the maximum number of request
parameters (GET plus POST) for a single request ([512]) were detected. Any
parameters beyond this limit have been ignored. To change this limit,
set the maxParameterCount attribute on the Connector.
	org.apache.tomcat.util.http.Parameters.addParameter(Parameters.java:199)
	org.apache.tomcat.util.http.Parameters.processParameters(Parameters.java:383)
	org.apache.tomcat.util.http.Parameters.processParameters(Parameters.java:229)
	org.apache.catalina.connector.Request.parseParameters(Request.java:2874)
	org.apache.catalina.connector.Request.getParameter(Request.java:1291)
	...

Laut Tomcat Dokumentation sollte der Parameter maxParameterCount auf 10000 stehen, dies ist aber bei jbossweb nicht der Fall. Um den Parameter zu setzen ist es notwendig eine system property mit den Namen org.apache.tomcat.util.http.Parameters.MAX_COUNT zu setzen. Dies kann entweder über die JBoss 7 Kommando Konsole erfolgen (jboss-cli) oder direkt über die Konfigurationsdatei standalone.xml.

Der Aufruf mit jboss-cli sieht folgendermaßen aus:

/system-property=org.apache.tomcat.util.http.Parameters.MAX_COUNT:add(value=10000)

Dieser Aufruf erzeugt einen Eintrag in standalone.xml, welcher auch direkt eingefügt werden könnte:

<system-properties>
   <property name="org.apache.tomcat.util.http.Parameters.MAX_COUNT" value="10000"/>
</system-properties>

Nach einem Neustart des Servers sollten das Problem beseitigt sein.

Weiterlesen »]]> Kürzlich stand ich im Bahnhofskiosk und überflog kurz das Javamagazin 05/2012 zum Thema Websockets. Grund genug, selbst zu recherchieren und auszuprobieren was Java, speziell Application Server hinsichtlich Websockets zu bieten haben.

Was ist ein Websocket?

Das WebSocket Protokoll, beschrieben in RFC 6455, ermöglicht eine bidirektionale Kommunikation zwischen einem Server und einer Webanwendung. Die Verbindung zum Server wird dabei über http initialisiert und dann offen gehalten. Übertragen werden können dann Binärdaten oder Zeichenketten.

Java und Websockets

Recherchiert man im Netz, so finden sich durchwegs viele Frameworks, bzw. Server die Websockets unterstützen. Einen Standard zur Integration in einen Application Server gibt es jedoch noch nicht, was nicht verwundert, da das Protokoll noch nicht abschließend spezifiziert ist. Eine Standardisierung ist in Java EE Version 7 zu erwarten.

Für Jetty und Glassfish existieren gut dokumentierte und nachvollziehbare Beispiele und Dokumentationen, JBoss AS 7 hingegen unterstützt Websockets derzeit noch unzureichend. Eine Implementierung ist jedoch in Arbeit https://github.com/mikebrock/jboss-websockets. Alternativ ist es wohl mit Hilfe eines eingebetteten Jetty Servers möglich Websocket Kommunikation auch mit dem JBoss zu betreiben, sofern man noch davon sprechen kann. Mehr dazu siehe hier:  http://golovnin.blogspot.it/2012/04/jboss-7-and-websockets.html

Glassfish Echo Server

Entschieden habe ich mich für eine einfachste Implementierung mit dem Glassfish Application Server. Die Idee: Einen einfachen Echo Service mit minimalen Codeumfang als Maven Projekt zu implementieren und die Stolpersteine dabei kennenzulernen.

Es existieren einige Beispiele im Netz, jedoch stellte sich bald heraus, dass zahlreiche von ihnen nicht lauffähig waren, Ursache dafür war eigentlich immer eine veraltete Protokollversion. Eine mit dem Glassfish 3.1.2 funktionierende Applikation ist hier zu finden: http://download.java.net/maven/glassfish/com/sun/grizzly/samples/grizzly-websockets-chat/1.9.19/

Mein Beispiel sollte jedoch etwas weniger umfänglich sein.

Glassfish benutzt ein standard HttpServlet als Einstiegspunkt für die Websocket Kommunikation, welches einen WebSocket Adapter registriert. Im pom.xml des Projekt sind also folgende Abhängigkeiten notwendig:

<dependency>
   <groupId>javax</groupId>
   <artifactId>javaee-api</artifactId>
   <version>6.0</version>
   <scope>provided</scope>
</dependency>
<dependency>
   <groupId>com.sun.grizzly</groupId>
   <artifactId>grizzly-websockets</artifactId>
   <version>1.9.46</version>
   <scope>provided</scope>
</dependency>

Die Implementierung des Servlets selbst ist recht einfach:

public class WebsocketServlet extends HttpServlet {

    /** The Application to register or unregister. */
    private final EchoApplication app = new EchoApplication();

    @Override
    public void init(ServletConfig config) throws ServletException {
        WebSocketEngine.getEngine().register(app);
    }

    @Override
    public void destroy() {
        WebSocketEngine.getEngine().unregister(app);
    }
}

In Zeile 4 wird eine Instanz der eigentlichen Websocket Applikation erzeugt, welche wiederum WebSocketApplication erweitert. EchoApplication erweitert überschreibt dabei die Methode zur Erzeugung des Websockets und zur Verarbeitung eingehender Textnachrichten. Zur Verarbeitung von binären Nachrichten oder fragmentierten Nachrichten existieren eigene Methode. Dementsprechend einfach ist ist auch die Echo Applikation gehalten:

public class EchoApplication extends WebSocketApplication {

    /** The logger. */
    private static final Logger logger =
        Logger.getLogger(EchoApplication.class.getName());

    @Override
    public boolean isApplicationRequest(Request request) {
        final String uri = request.requestURI().toString();
        return uri.endsWith("/echo");
    }

    @Override
    public WebSocket createWebSocket(ProtocolHandler protocolHandler,
                                     WebSocketListener... listeners) {
        return new DefaultWebSocket(protocolHandler, listeners);
    }

    @Override
    public void onMessage(WebSocket socket, String text) {
        logger.info("Received message: " + text);
        try {
            socket.send(text);
            logger.info("Sent message: " + text);
        } catch (WebSocketException e) {
            logger.info("Error, closing socket: " + e.getMessage());
            socket.close();
        }
    }
}

Um auf Seiten des Clients eine Websocket Verbindung zu öffnen wird mit Javascript eine WebSocket Instanz mit der URL des Services erzeugt. Es gibt dabei vier Callback Funktionen und eine Funktion zum Senden von Nachrichten.

webSocket = new WebSocket("ws://localhost:8080/echo-websocket/echo");

webSocket.onopen = function(event) {
    var $textarea = $('#echoLogId');
    $textarea.val($textarea.val() + "Connected.\n");
};

webSocket.onmessage = function(event) {
    var $textarea = $('#echoLogId');
    $textarea.val($textarea.val() + "Received: " + event.data + "\n");
    $textarea.animate({scrollTop:$textarea.height()}, 1000);
};

webSocket.onclose = function(event) {
    webSocket.send("Disconnected");
};

webSocket.onerror = function(event) {
    var $textarea = $('#echoLogId');
    $textarea.val($textarea.val() + "Communication error!\n");
}

jQuery ist übrigens nicht Voraussetzung für eine Websocket Kommunikation. Das Verschicken von Nachrichten erfolgt dann folgendermaßen:

jQuery.sendEchoMessage = function() {
    var message = $('#echoMessageId').val();
    webSocket.send(message);
    var $textarea = $('#echoLogId');
    $textarea.val($textarea.val() + "Sending: " + message + "\n");
};

Nach dem Deployment kann die Applikation unter http://localhost:8080/websockets-gl/ aufgerufen werden.

Interessant ist wie der Client mit dem Server die Websocket Verbindung aushandelt, indem dieser nach einem Upgrade auf eine bestimmte Protokollversion fragt.

Host=localhost:8080
...
Connection=keep-alive, Upgrade
Sec-WebSocket-Version=13
Origin=http://localhost:8080
Sec-WebSocket-Key=WqbvVAKudnxMdk7KQWJslg==
...
Upgrade=websocket

Der Server akzeptiert das Upgrade und antwortet seinerseits mit einer 101

Status=Switching Protocols - 101
Upgrade=websocket
Connection=Upgrade
Sec-WebSocket-Accept=rpoZxgcB9KqCOXdGWc/46nmkZLk=

Fazit

Websocket ist ein interessanter Ansatz was die bidirektionale Kommunikation zwischen Client und Server angeht, vor allem kann dadurch ein ständiges Pollen des Clients entfallen. Derzeit ist die Standardisierung des Protokolls leider noch nicht abgeschlossen, insbesondere für die serverseitige Implementierung in Java gibt es noch keine Standards. Abhilfe wird hier vermutlich Java EE 7 schaffen. Auf Client Seite werden Websocket Verbindungen derzeit von Chrome, Firefox, Safari und Opera je nach Version unterschiedlich unterstützt. Der Internet Explorer kann noch nicht mit Websockets umgehen, es gibt aber Workarounds die auf Flash basieren. Erst ab Version 10 soll der IE dann Websocket Verbindungen beherrschen.
Sobald die verbreiteten Browser Websocket unterstützen, Java EE das Protokoll in einer finalen Version in den Standard integriert, werden wir sich öfters Websockets in Webapplikationen finden.

Das gesamte Projekt ist hier zu finden: https://github.com/bpark/websockets-gl

Weiterlesen »]]> Nachdem Rechteumstellung bei hosteurope und ein neues WordPress Update mein altes Weblog mit in den Abgrund gerissen haben, starte ich das Ganze mal neu. Dies nehme ich auch als Gelegenheit wahr öfters Artikel zu Themen rund um Java Entwicklung zu verfassen, zumal hier lange Zeit Ruhe eingekehrt war.

Allen Lesern wünsche ich daher viel Spaß mit den neuen Artikeln.