TaskExecutor und java.util.concurrent.Executor in Spring 2

Seit Java 5 gibt es mit dem Executor (JSR 166) eine Schnittstelle für "Ausführer" von Runnable-Objekten.
Spring bietet mit dem TaskExecutor die gleiche Schnittstelle.
- So steht die Funktionalität auch für Java 1.4 und Java 1.3 und auch für Java EE Umgebungen zur Verfügung.
org.springframework.core.task.TaskExecutor:
void execute( Runnable task )

Die TaskExecutor im Überblick

SimpleThreadPoolTaskExecutor
- Thread-Pool durch Quartz's SimpleThreadPool.
SimpleAsyncTaskExecutor
- Erzeugt pro Anfrage einen neuer Thread. Es gibt eine optionale maximale Größe.
SyncTaskExecutor
- Führt Runnable im aktuellen Thread aus. Erzeugt also keinen neuen Thread zur Nebenläufigkeit.
ConcurrentTaskExecutor
- Ein Wrapper zum java.util.concurrent.Executor von Java 5.
ThreadPoolTaskExecutor
- Geht direkt auf den java.util.concurrent.ThreadPoolExecutor von Java 5. Ermögicht Anpassung der Properties "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity".
TimerTaskExecutor
- Nutzt einen java.util.Timer zur Ausführung. Der Runnable wird als TimerTask hintereinander durch den Timer-Thread ausgeführt.
WorkManagerTaskExecutor
- Nutzt CommonJ WorkManager als Implementierung. Ermöglicht Ausführung auf Applikationsservern von BEA und IBM.

Beispiel für TaskExecutor

public class DoItExecutor
{
private TaskExecutor executor;

public DoItExecutor( TaskExecutor executor )
{
this.executor = executor;
}

public void doIt()
{
Runnable run = new Runnable() {
public void run() {
System.out.println( Thread.currentThread() );
}
};

executor.execute( run );
executor.execute( run );
}
}

Injizierung vom TaskExecutor

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="5" />
<property name="maxPoolSize" value="10" />
<property name="queueCapacity" value="25" />
</bean>

<bean id="doItExecutor" class="DoItExecutor">
<constructor-arg ref="taskExecutor" />
</bean>


"Fehlende" Typen aus Java 5

Spring bietet unterschiedliche Implementierungen für den TaskExecutor, aber Java 5 bietet außer execute() im Executor noch mehr.
Der java.util.concurrent.ThreadPoolExecutor implementiert mehr als nur Executor, nämlich ExecutorService. Das bietet
- awaitTermination(), invokeAll(), invokeAny(), isShutdown(), isTerminated(), shutdown(), shutdownNow(), submit()
- mit weiteren Typen wie Future, Callable.
Spring bietet dafür bisher keine Abstraktion!

SimpleJdbcTemplate aus Spring 2.0

Das org.springframework.jdbc.core.JdbcTemplate compiliert unter Java 1.4 und nutzt keine Eigenschaften von Java 5 wie Generics, Autoboxing und Varags.
Seit Spring 2.0 gibt es mit org.springframework.jdbc.core.simple.SimpleJdbcTemplate eine neue Klasse mit eine überschaubaren Anzahl Methoden für Java 5.
- Es ist eine Java 5-Fassade vor dem JdbcTemplate.
Der Konstruktor von SimpleJdbcTemplate nimmt wie JdbcTemplate eine DataSource an.

Methoden vom SimpleJdbcTemplate

int queryForInt(String sql, Object... args)
long queryForLong(String sql, Object... args)
Erfragt ein int/long über einen SQL-String und Argumenten.
List<Map<String,Object>> queryForList(String sql, Object... args)
Map<String,Object> queryForMap(String sql, Object... args)
Führt die SQL-Anfrage mit optionalen Argumenten aus.
<T> T queryForObject(String sql, ParameterizedRowMapper<T> rm, Object... args)
Die SQL-Anfrage liefert ein Ergebnis, das der Mapper auf ein Objekt überträgt.
<T> T queryForObject(String sql, Class<T> requiredType, Object... args)
Führt eine SQL-Anfrage aus und überträgt die Eigenschaften auf ein Objekt.
<T> List<T> query(String sql, ParameterizedRowMapper<T> rm, Object... args)
Der ParameterizedRowMapper überträgt Ergebnisse auf Objekte.
int update(String sql, Object... args)
Führt ein SQL-Update mit optionalen Argumenten durch.

SimpleJdbcDaoSupport

Die DAO-Klassen von Spring erlauben Zugriff auf die Template-Objekte.

Während JdbcDaoSupport ein JdbcTemplate liefert, gibt SimpleJdbcDaoSupport ein SimpleJdbcTemplate.

SimpleJdbcDaoSupport ist eine Unterklasse von JdbcDaoSupport:

org.springframework.jdbc.core.support.JdbcDaoSupport
extended by org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport

AJAX in 50 simple lines: Requesting HTML and Producing JSP

First we need a simple JSP as a service.
http://localhost:8080/jsp/request.jsp?name=Chris

<%
 String name = request.getParameter("name");
 if ( name != null )
   out.print( name.length() );
%>

The JSP simply returns the length of the string. The format is simple text, no XML.
Then we need a HTML page. It shows two text fields. One with an attached onkeyup() listener and one which displays the result, the length of the string in the first text field. The AJAX-request is inside a function called call() by the listener.

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Der Längenmann</title>
<script type="text/javascript">
var xmlHttp = false;
/*@cc_on @*/
/*@if (@_jscript_version >= 5)
try {
  xmlHttp = new ActiveXObject("Msxml2.XMLHTTP");
} catch (e) {
  try {
    xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
  } catch (e2) {
    xmlHttp = false;
  }
}
@end @*/
if (!xmlHttp && typeof XMLHttpRequest != 'undefined') {
  xmlHttp = new XMLHttpRequest();
}
function call()
{
  var value = document.getElementById("name").value;
  if ((value == null) || (value == "")) return;
  var url = "/jsp/request.jsp?name=" + escape(value);
  xmlHttp.open("GET", url, true);
  xmlHttp.onreadystatechange = update;
  xmlHttp.send(null);
}
function update()
{
  if ( xmlHttp.readyState == 4)
  {
    var response = xmlHttp.responseText;
    document.getElementById("length").value = response;
  }
}
</script>
</head>
<body>
Nutzung online: <b>http://localhost:8080/jsp/request.jsp?name=Chris</b>.
<form>
Name: <input type="text" name="name" id="name" onKeyUp="call();" />
<br>
Length: <input type="text" name="length" id="length" />
</form>
</body>
</html>

The best solution is to use an AJAX framework like prototype, but this is only a very simple example "how this stuff works" (is there a copyright on the sentence?)

Restart a died Thread

If a Thread dies the system can inform you via a Thread.UncaughtExceptionHandler. You can use it to restart a Thread:

import java.awt.Frame;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.Thread.UncaughtExceptionHandler;
import javax.swing.JDialog;
import javax.swing.JTextArea;

public class Main
{
  public static void main( String[] args )
  {
    ThreadHandler.startThread();
  }
}

class ThreadHandler
{
  static void startThread()
  {
    Thread t = new Thread( new MyCommand() );
    UncaughtExceptionHandler ueh = new MyUncaughtExceptionHandler();
    t.setUncaughtExceptionHandler( ueh );
    t.start();
  }

  static class MyCommand implements Runnable
  {
    public void run()
    {
      int i = 0;

      System.out.println( 12 / i ); // Provoke a RuntimeException
    }
  }
}

class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler
{
  public void uncaughtException( Thread thread, Throwable throwable )
  {
    StringWriter stringWriter = new StringWriter();
    PrintWriter w = new PrintWriter( stringWriter );
    throwable.printStackTrace( w );

    JDialog d = new JDialog( new Frame(), true );
    d.add( new JTextArea( stringWriter.toString() ) );
    d.setTitle( thread.getName() + " --- " + throwable.getMessage() );
    d.pack();
    d.setVisible( true );

    ThreadHandler.startThread(); // Restart Thread
  }
}

Buchkritik "Java 6 Plattform Revealed"

Ein frühes Buch (Juni 2006) zu Java 6, aber es zeigt alle wesentlichen Eigenschaften der neuen Version. Sehr gut gefallen hat mit die Beschreibung von CookieHandler, CookieManager & Co. KG, etwas, was ich noch nie ordentlich erklärt gefunden habe. Der einzige Fehler, der mir aufgefallen ist, befindet sich auf Seite 111, wo eine Variable statt rs (für ResultSet) fälschlicherweise st heißt. Eine präzisere Beschreibung für Web Services und JAXB liefert das Buch leider nicht -- nur ein paar Standard-Beispiele und eine schlaffe Aufzählung der Annotationen -- aber dafür gibt es ja andere Bücher aus der Ecke der Java EE Literatur. Auch StAX ist nicht sonderlich präzise und späteren Neuerungen, wie Java DB oder GroupLayout finden keine Erwähnung. Das gleiche gilt für neue Funktionen copySign(), getExponent(), nextAfter(), nextUp(), scalb() aus Math/StrictMath. Eigentlich wäre jetzt Zeit für ein Buch-Update.

John Zukowski. APress. ISBN 1590596609. 220 Seiten

Smartest/shortest way to write a string to a file?

Without exception handling:

new FileWriter("c:/test.txt").append("Bo").close();

ROME: Lesen/Schreiben von Atom/RSS-Feeds

Rome ist eine Bibliothek zum Lesen/Schreiben/Konvertieren von Atom/RSS-Feeds in den Versionen

• RSS 0.90
• RSS 0.91 Netscape
• RSS 0.91 Userland
• RSS 0.92/RSS 0.93/RSS 0.94
• RSS 1.0/RSS 2.0
• Atom 0.3/Atom 1.0

Ein Beispiel ist schnell programmiert und die API (Doku hier) ist relativ einfach.

package com.sun.syndication.samples; 

import java.io.FileWriter;
import java.net.URL;
import java.util.List; 

import com.sun.syndication.feed.synd.SyndContent;
import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader; 

public class FeedReader
{
@SuppressWarnings("unchecked")
public static void main( String[] args )
{
try
{
URL feedUrl = new URL( "http://javainsel.blogspot.com/atom.xml" );
SyndFeedInput input = new SyndFeedInput();
SyndFeed feed = input.build( new XmlReader( feedUrl ) ); 

StringBuilder sb = new StringBuilder( 1024 );
for ( SyndEntry syndFeed : (List<SyndEntry> )feed.getEntries() )
{
sb.append( "<b>" + syndFeed.getTitle() + "</b>" );
sb.append( "<blockquote>" + ((SyndContent)syndFeed.getContents().get(0)).getValue() + "</blockquote>" );
} 

// JFrame f = new JFrame( "Einfache Feed Anzeige" );
// f.setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE );
// JEditorPane editor = new JEditorPane( "text/html", sb.toString() );
// editor.setEditable( false );
// f.add( new JScrollPane(editor) );
// f.setSize( 600, 400 );
// f.setVisible( true ); 

FileWriter w = new FileWriter( "c:/out.html" );
w.write( sb.toString() );
w.close();
}
catch ( Exception e )
{
e.printStackTrace();
}
}
}

Wenn die JEditorPane besser wäre, könnte man auch (schnell) was sehen. Daher schreibt das Programm eine selbst generierte HTML-Seite ins Dateisystem.

Buchkritik zu "Pro Apache Geronimo" von Kishore Kumar

Pro Apache Geronimo. Open Source Lightwave J2EE Container
Kishore Kumar. apress. ISBN 1590596420. April 2006. 252 Seiten
 Ich habe zwar Apache Geronimo nicht im Einsatz (und kann mir auch nicht vorstellen, den Server in der nahen Zukunft zu nutzen, da die Verbreitung zu gering ist), aber dennoch wollte ich etwas über die Architektur kennen lernen. Kumar vermittelt zunächst die Basis vom Geronimo Application-Server 1.x und stellt den Kern, einen IOC-Container, der GBeans verwaltet, vor. Er geht kurz über die üblichen Bean-Typen und zeigt, wie sie deployed werden und welche spezifischen Deployment-Deskriptoren es gibt. Gut gefallen hat mir ein Kapitel zur Web-Service Fassade für eine Session-Bean, und wie J2EE Connectoren programmiert und eingebunden werden. Dass das Buch jedoch etwas zu Java EE 5 enthält -- so steht es auf dem Buchrücken "Includes some Java EE 5" -- ist eine glatte Lüge. Januar 2007

Character „Chunking“ bei SAX

Bei langen Zeichenketten ist es nicht zwingend, dass sie in einem Rutsch der characters() Methode übergeben werden.

<TSeq_sequence>
 TAACCCTAACCCTAACCCTAACCCTAAC
</TSeq_sequence>

Denkbar ist hier ein (skizzierter) Aufruf von

characters("T");
characters("AACCCTAAC");
characters("CCTAACCCTAACCCTAAC");

Die Anwendung muss mit Character „Chunking“ rechnen und damit umgehen. Man kann es nicht abstellen! Viele Parser teilen die CDATA-Sektion auf, so dass nach jedem Carriage Returns einmal characters() aufgerufen wird.

Eine Lösung ist, die Zeichen zwischenzuspeichern, etwa in einem StringBuilder/StringBuffer.

public void characters(char[] ch, int start, int length)
throws SAXException {
currentText.append( ch, start, length );
}

Wenn endElement() aufgerufen wird, kann man den Puffer auswerten.

Eine interessante Idee ist, einen Delegate zu bauen, der sich für den SAX-Parser wie ein ContentHandler verhält, aber characters() abfängt und die Zeichen intern speichert. Alle anderen Methoden wie endDocument(), … gehen zum Original.
Zuvor jedoch werden die Methoden „flushen“, also ein Aufruf von characters() auf dem Original durchführen und alle Zeichen übergeben.

Anschauen kann man eine solche unter http://koders.com/java/fid607C6038FB8FD26D12EED5B32042D3EF48038AA7.aspx. Die Implementierung steht unter der Apache-Lizenz.

/*
* Copyright 2004 Outerthought bvba and Schaubroeck nv
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.outerj.daisy.htmlcleaner; 
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.Locator;
import org.xml.sax.Attributes; 
class MergeCharacterEventsHandler implements ContentHandler {
private ContentHandler consumer;
private char[] ch;
private int start = 0;
private int length = 0; 
public MergeCharacterEventsHandler(ContentHandler consumer) {
this.consumer = consumer;
} 
public void characters(char ch[], int start, int length) throws SAXException {
char[] newCh = new char[this.length + length];
if (this.ch != null)
System.arraycopy(this.ch, this.start, newCh, 0, this.length);
System.arraycopy(ch, start, newCh, this.length, length);
this.start = 0;
this.length = newCh.length;
this.ch = newCh;
} 
private void flushCharacters() throws SAXException {
if (ch != null) {
consumer.characters(ch, start, length);
ch = null;
start = 0;
length = 0;
}
} 
public void endDocument() throws SAXException {
flushCharacters();
consumer.endDocument();
} 
public void startDocument() throws SAXException {
flushCharacters();
consumer.startDocument();
} 
public void ignorableWhitespace(char ch[], int start, int length) throws SAXException {
flushCharacters();
consumer.ignorableWhitespace(ch, start, length);
} 
public void endPrefixMapping(String prefix) throws SAXException {
flushCharacters();
consumer.endPrefixMapping(prefix);
} 
public void skippedEntity(String name) throws SAXException {
flushCharacters();
consumer.skippedEntity(name);
} 
public void setDocumentLocator(Locator locator) {
consumer.setDocumentLocator(locator);
} 
public void processingInstruction(String target, String data) throws SAXException {
flushCharacters();
consumer.processingInstruction(target, data);
} 
public void startPrefixMapping(String prefix, String uri) throws SAXException {
flushCharacters();
consumer.startPrefixMapping(prefix, uri);
} 
public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
flushCharacters();
consumer.endElement(namespaceURI, localName, qName);
} 
public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
flushCharacters();
consumer.startElement(namespaceURI, localName, qName, atts);
}
}

Prefuse: Immer wieder schöne Graphen

Das "prefuse visualization toolkit" ist eine feine API zur Informationsvisualisierung. In der visualization gallery gibt es etwa folgendes zu sehen und auszuprobieren:

 

Small-World Networks by Stephen Frowe Ingram

 

 

Vizster by Jeffrey Heer and danah boyd

 

 

Flow Map Layout by Doantam Phan

 

 
NameVoyager by Martin Wattenberg, rebuilt by Jeffrey Heer

 

 
¢ongress by Jeffrey Heer

 

 
zipdecode by Ben Fry, rebuilt by Jeffrey Heer

 

 
TreeMap Demo by Jeffrey Heer

 

 
RadialGraphView Demo by Jeffrey Heer

 

TreeView Demo by Jeffrey Heer

 

 
GraphView Demo by Jeffrey Heer

 

 
FisheyeMenu Demo by Jeffrey Heer

 

 
DataMountain Demo by Jeffrey Heer

Nice Office Access: Leichter OpenOffice programmieren

Unter http://ubion.ion.ag/solutions/004niceofficeaccess gibt's eine einfachere API unter der LGPL, um OpenOffice-Aufgaben zu erledigen. Java UNO kann zwar alles, ist aber nicht gerade einfach zu nutzen. Mit Nice Office Access (NOA) soll das ganze einfacher gehen. Es bietet einen leichtgewichtigen Wrapper für viele UNO Schnittstellen.

Da ich das noch nicht genutzt habe, sind Kommentare willkommen.