Da blättere ich gerade durch das „Just Java“ Buch und glaube, schon einen Fehler gefunden zu haben, da sagt mir der Compiler, dass alles in Ordnung ist:

public class T
{
public static int foo()[]
{
 return new int[] { 1, 2, 3 };
}

public static void main( String[] args )
{
 System.out.println( foo().length );
}
}

Diese sonderbare Rückgabe habe ich noch nie gesehen und ist mir in der Grammatik der Sprache Java auch noch nie aufgefallen.

Was früher noch Teil der J2EE war, ist heute Teil der Java Standard Edition.

• http://java.sun.com/j2ee/sdk_1.3/techdocs/api/ zeigt noch DOM und SAX, sowie das „JDBC 2.0 Optional Package“ was dann Teil der J2SE 1.4 wurde.
• http://java.sun.com/j2ee/1.4/docs/api/index.html zeigt javax.management „Java Management Extensions“ (JMX), und javax.xml.parsers, javax.xml.transform was fester Bestandteil von Java SE 5 wurde.
• http://java.sun.com/javaee/5/docs/api/ zeigt die JPA (Java Persistence API), was vermutlich Teil von Java 6 wird.

Viele Teile der Java Enterprise Edition werden so geläufig, dass sie in die Java Standard Edition wandern.

• Dennoch wurde es unter der Enterprise-Edition mehr: 78 Pakete in Java EE 5, 54 Pakete in J2EE 1.4, 32 in J2EE 1.3

Mit JBoss und den proprietären Annotationen ist es einfach eine JMX zu schreiben. JBoss bringt ein Beispiel gleich mit:

package trail.jmx;

public interface Rechner {

// Attribute
public void setGrowthrate (double g);
public double getGrowthrate ();

// The management method
public double calculate (int start, int end, double saving);

// Life cycle method
public void create () throws Exception;
public void destroy () throws Exception;
}

package trail.jmx;

import java.lang.management.ManagementFactory;

import javax.annotation.PostConstruct;

import org.jboss.annotation.ejb.Management;
import org.jboss.annotation.ejb.Service;

@Service (objectName=“trail:service=calculator“)
@Management(Rechner.class)
public class RechnerMBean implements Rechner {

double growthrate;

public void setGrowthrate (double growthrate) {
this.growthrate = growthrate;
}

public double getGrowthrate () {
return growthrate;
}
public double calculate (int start, int end, double saving) {
double tmp = Math.pow(1. + growthrate / 12., 12. * (end – start) + 1);
return saving * 12. * (tmp – 1) / growthrate;
}

// Lifecycle methods
public void create() throws Exception {
growthrate = 0.08;
System.out.println(„Calculator – Creating“);
}

public void destroy() {
System.out.println(„Calculator – Destroying“);
}

}

In der JMX-Console taucht die Klasse dann auf.

Wenn man das ganze nun mit der JConsole hinbekommen möchte, hat man ein Problem, denn JBoss meldet die Beans nicht am Standard-Container für JMX Beans an, sondern an einem eigenen. Daher benötigt JBoss einen Hinweis, in den Sun-Container zu schreiben. Dazu ist ein Schalter beim Starten (run.bat oder in Eclipse bei der Startkonfiguration) mit anzugeben:

-Djboss.platform.mbeanserver -Djavax.management.builder.initial=org.jboss.system.server.jmx.MBeanServerBuilderImpl

Unter Java 5 muss natürlich noch -Dcom.sun.management.jmxremote dazu.

Jetzt ist der „Rechner“ auch in der JConsole.

• Greift Hibernate nicht allein auf die Datenquelle zu, sind die Daten im Cache unter Umständen nicht mehr aktuell.
• Wenn Daten einmal in den Cache gesetzt werden, danach aber nie wieder benötigt werden, war die Arbeit umsonst.
• Bei sehr vielen Daten quillt der Cache über und muss Dinge entfernen – nach Murphys Law sind die dabei, die wir als nächstes wieder lesen.
• Es sollen/müssen alle Anfragen an die Datenbank gehen, weil etwa jede Anfrage Logging-Informationen mitgespeichert. (Durch ein SELECT ist ein Trigger verbunden.)
• Wenn es nur eine Sitzung gibt, ist ein Second Level Cache unnötig. Er dient nur dazu, Daten zwischen mehreren Sitzungen „lebendig“ zu halten.

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!

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?)

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
  }
}

Without exception handling:

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

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.

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

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

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.