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.
Viele Teile der Java Enterprise Edition werden so geläufig, dass sie in die Java Standard Edition wandern.
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.
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
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.
See flash under http://madbean.com/anim/jarwars/.
Guckst du hier: http://www.youtube.com/v/av5y5X5Eyrg
Das hier unter http://www.absoluteswissen.de/web-xml_i.htm ist doch mal eine schöne interaktive Visualisierung von web.xml.
Oracle und JBoss habe beide Spezial-Annotationen, um etwa idetime/timeout zu sezten. Im Fall von Oracle etwa
@StatefulDeployment(idletime=10,timeout=15)
Bei JBoss gibt es @org.jboss.annotation.ejb.PoolClass, aber auch@CacheConfig und @Cache aus dem Caching-Paket.
Für die für die Anwendung der Annotationen gibt es kaum Hinweise im Netz.
Unter http://blogs.sun.com/dagastine/entry/java_6_leads_out_of schreibt David Dagastine über die ersten Performance-Messungen der JVM Version 6. Die Zahlen (und Grafiken) sehen schon gut aus; die Version 6 schneidet bei (fast) allen Szenarien von Sun am Besten ab — so wurden die Szenarien wahrscheinlich auch ausgesucht 🙂 BEA JRockit 5.0_06 R26.4 hat mich ein wenig überrascht, da die JVM in einigen Messungen leicht über Suns JVM lag, in den meisten Fällen aber weit am Ende lag.
Interessant erscheint mit der Hinweis, dass das Parameter-Tuning vermutlich in Zukunft einfacher wird, weil die JVM automatisch ihre Modi wählt. Die guten Laufzeitergebnisse kamen auch zustande, ohne einen speziellen Schalter gesetzt zu haben.
EJB 2 und EJB 3 im Container
Jeder EJB 3 Container muss auch EJB 2.x Beans verwalten können. Beim Design der neuen Spezifikation war es wichtig, dass
– eine EJB 2.x Bean in eine EJB 3.0 Bean injiziert werden kann,
– eine EJB 3.0 Bean sich von außen als EJB 2.x Bean ansprechen lässt.
Klassisches Home/Component-Interface
Nehmen wir für eine Session-Bean eine EJBHome-Schnittstelle MyHome an, dessen create()-Methode ein MyRemote liefert.
public interface MyHome extends EJBHome {
public MyRemote create()
throws CreateException, RemoteException;
}
public interface MyRemote extends EJBObject {
public void foo() throws RemoteException;
}
@EJB injiziert eine EJB 2 Bean
Mit der Annotation @EJB injiziert der Container nicht nur EJB 3 Verweise, sondern auch EJB 2 Beans. Da EJB 2 Beans kein Business-Interface haben, injiziert der Container Exemplare, die das Home-Interface implementieren. Der Container soll die Objektvariable myHome belegen:
@EJB private MyHome myHome;
Der Zugriff auf die EJB 2-Bean läuft wie üblich über create():
MyRemote bean = myHome.create();
bean.foo();
@RemoteHome/@LocalHome
Mit den neuen Annotationen aus EJN 3.0 kann eine Enterprise-Bean mit einer EJB 2 Sicht veröffentlicht werden. Dazu ist ein Remote- und Component-Interface nötig.
– Etwa wie im Beispiel MyHome und MyRemote.
Im nächsten Schritt wird die Bean mit @RemoteHome/@LocalHome annotiert, etwa so:
@RemoteHome( MyHome.class )
Nur das Home-Interface, aber nicht das Componten-Interface, kommt in die Annotation.
Die EJB implementiert das Componten-Interface nicht, muss auch keine Annotationen vor diese Methoden setzen. Die create-Methoden werden mit @Init annotiert. Der Name ist egal.
Beispiel einer EJB 2 mit der EJB 3 API
@Stateful
@RemoteHome( MyHome.class )
public class MyEJB2Bean
{
@Init
public void create() { }
public void foo() { }
}
Google hat einen Dienst vorgestellt, bei dem nach US-Patenten gesucht werden kann. Java taucht in den Patentschriften (http://www.google.com/patents?q=java) über 800 mal auf. Viele Patente stammen von Sun Microsystems, aber MS, IBM und Mobilfunkhersteller sind auch dabei.
Beim Durchsehen der Webseiten meine Seminarkonkurrenz ist mir ein Link auf ein Buch aufgefallen, was mich zu http://entwickler-press.de brachte. Interessiert über ein neues Spring 2.0 Buch musste ich erfahren, dass es schon wieder ein neues Framework gibt: String. Interessant. Von der Webseite zitiert:
„Das Buch beschreibt das Spring-Framework im Enterprise-Einsatz. Es zeigt die Erweiterungen und neuen Möglichkeiten der aktuellen Version 2.0 und stellt weitere Frameworks vor, die sich im Projektalltag gut mit String kombinieren lassen. Die Autoren legen Ihren Schwerpunkt auf die Datenbankanbindung und Testing.“