tutego

Zustände von Web-Applikationen können, sofern sie klein sind, im Cookie gespeichert werden. Alles, was jedoch größer als 4 KB ist, wird in der Regel auf der Serverseite abgelegt. Nun haben in den letzten Jahren die Browser-Hersteller lokale Speichermöglichkeiten entwickelt:

• globalStorage: Firefox 2.0+, Internet Explorer 8
• localStorage: development WebKit
• openDatabase: Safari 3.1+
• userdata behavior: Internet Explorer 5.5+

Daneben gibt es Plugins, etwa von Google (Gears) oder Yahoo. Das dumme bei den Plugins ist jedoch, das diese extra installiert werden müssen. Ihr Vorteil allerdings: Eine standardisierte API. Doch damit kann nun Schluss sein. Mit PersistJS gibt es eine standardisierte API, die von den jeweiligen Browser- und Plugin-APIs abstrahiert. Der Zugriff ist simpel

var store = new Persist.Store('Mein Data Store');
var data = "Daten";
store.set('saved_data', data);
store.get('saved_data', function(ok, val) {
  if (ok)
    alert('saved data = ' + val);
});
store.remove('saved_data');

PersistJS nutzt nun intern:

• flash: Flash 8 persistent storage.



• gears: Google Gears-based persistent storage.



• localstorage: HTML5 draft storage.



• whatwg_db: HTML5 draft database storage.



• globalstorage: HTML5 draft storage (old spec).



• ie: Internet Explorer userdata behaviors.



• cookie: Cookie-based persistent storage.

Labels: JavaScript

Adam Myatt. Apress. ISBN 978-1-59059-895-5. Februar 2008, 491 Seiten

Ein aktuelles Buch über NetBeans, welches auf grundlegende aber auch erweiterte Eigenschaften der Entwicklungsumgebung eingeht. Themen sind unter anderem Installation (das 1. Kapitel "Downloading, Installing, and Customizing NetBeans" ist auch online), der Editor, Einstellungen, Projektangaben, Gui-Bilder, Debugging, Profiling, Versionsmanagement, JUnit, Refactoring, Datenbankbrowser, Qualitätsprüfung. Dass das Buch auf der aktuellen Version 6 aufbaut, zeigt sich insbesondere an den letzten Kapiteln, in denen es JRuby und Rails, Web-Services, BPEL, REST, dem Swing-Application Framework und Beans Binding zur Sprache bringt. Dem Autor ist das Kapitel über Swing aber lieber gewesen, denn hier beschreibt er ausführlicher die Technologie, während bei Web-Services nur Einträge in den Dialogen aufgezählt werden, aber nicht erklärt wird, was diese eigentlich sollen. Aber das ist wohl immer der Fall, wenn ein Buch nur zeigen möchte, WIE man mit der IDE etwas macht, aber nicht warum. Für welche Käuferschicht das Buch am Besten geeignet ist, ist schwer zu beantworten. Erfahrene Entwickler, die schon einige IDEs kennengelernt haben (Eclipse, JDeveloper, ...) werden mit NetBeans keine Probleme haben. (Aus der Java-Community gibt es vielfach die Meinung, NetBeans ist viel einfacher zu bedienen als Eclipse.) Daher bekommt man mit etwas Rumklicken und aufmerksamem Lesen die meisten Sachen schnell raus, zumal die Webseite von Sun voll von Tutorials insbesondere für die fortgeschrittenen Themen ist. Wer ein Gespür für Entwicklungswerkzeuge hat, und gerne Online-Tutorials liest, wird mit http://www.netbeans.org/kb/ auch glücklich. Zumal bei Sun Artikel zur Java ME-Entwicklung, C(++) oder UML-Modellierung stehen, die das Buch überhaupt nicht ankratzt. Schade eigentlich, denn vermutlich dürfte UML für die meisten Leser interessanter sein als einen BPEL-Web-Service auf Glassfish zu deployen. Das letzte Kapitel „Developing Rich Client Applications“ hat aber nichts mit der Entwicklungsumgebung selbst zu tun, sondern stellt kurz das NetBeans RCP vor. Hier ist die Zielgruppe eine völlig andere. Denn der Bediener einer IDE ist nicht unbedingt einer, der mit dem RCP Desktop-Anwendungen schreibt. Sehr fragwürdig ist daher auch der Titel „ Rich Client Platform Edition“; hier ist man verleitet anzunehmen, dass es ein Buch über das RCP-Framework ist. Doch nein, es ist nur ein Buch über die Bedienung einer Entwicklungsumgebung.

Labels: Rezension

Ein abgefahrendes Projekt ist eine JPA-Schnittstelle für die Amazon SimpleDB (Amazon S3 (Simple Storage Service)). Mit http://code.google.com/p/simplejpa/ lässt sich auf die Amazon-Datenbank über das standardisierte JPA zugreifen. Die Doku unter http://code.google.com/p/simplejpa/wiki/GettingStarted listet alles nötigen Jar-Dateien auf und zeigt anhand eines kleines Beispiels die Nutzung. Da die Amazon-DB keine "richtige" relationale DB ist, gibt es auch einige Einschränkungen, etwa "Can only query on a single object type, no joins." Auf der anderen Seite:

• Supports ManyToOne references with lazy loading
• Supports OneToMany collections with lazy loading
• Large object (LOB) support via Amazon S3
• Caches objects for quick response after first retrieval
• Retrieves result sets concurrently for fastest retrieval from SimpleDB
• JPA Queries (subset)
• @ManyToOne - object references. Stores id reference to another object in another Domain
• @OneToMany (java.util.List only, must be generified, must be bi-directional with mappedBy parameter) - Collection support. Please be careful with collections, usually better to just query for what you want rather than attaching via collections.
• @Inheritance - Only SINGLE_TABLE supported (only one that makes sense).
• @MappedSuperClass - Useful for a common ID and timestamping class.
• @Lob - stores lobs in S3 so make it as big as you want (up to 5GB).
• @Id - MUST be a string
• JPA Queries - see JPAQuery page
• Integer and Long - no problems, all good.
• Double - pads to 20 digits on each side of the decimal by default so fine for a lot of cases, but if you plan to use Double's, let us know so we can work it out perfectly. SimpleDB makes it hard to work with these numbers because it treats everything as a String.
• BigDecimal - same problems as Double
• String
• no primitives yet! Please use wrappers only for now.
• @Enumerated (ordinal and string)
• @Column (name only)

Labels: Open Source

Auf der Java One 2008 hat William Pugh den Vortrag Defective Java™ Code: Turning WTF code into a learning experience gehalten. In interessanten Beispielen geht er auf Synchronisation, Immutable und equals() ein. Insbesondere letztes ist sehr interessant und an guten Beispielen dokumentiert. (Die Insel geht ebenfalls das Problem der Symmetrie ein.)

Cargo (von Vincent Massol) bietet Java-APIs sowie Ant und Maven Unterstützung, um Web- und Java EE-Container zu starten/stoppen und Module zu deployen. Die Liste der Server ist erst einmal toll: Geronimo, JBoss, Jetty, Resin, WebLogic, Tomcat (kein WebSphere!). So gut die Idee auch ist, leider ist das Projekt soweit gestorben. Wer Lust hat, darf gerne project lead werden. Na ja, die letzte Version ist von 10/03/07 und bisher hat sich noch keiner gefunden.

Labels: Open Source

jps (Java Virtual Machine Process Status Tool) ist ein Utility, welches neu bei Java 5 ist. Es zeigt die aktuellen laufenden Java VM-Instanzen an.

$ jps 
2256 
2960 Jps

$ jps -mlvV 
1692 sun.tools.jps.Jps -mlvV -Dapplication.home=C:\Programme\Java\jdk1.6.0 -Xms8m 
2256  -Xbootclasspath/a:C:\PROGRA~1\Java\JRE16~1.0\lib\deploy.jar;C:\PROGRA~1\Java\JRE16~1.0\lib\plugin.jar -Xmx96m ...

Um ein eigenes jps zu schreiben ist, ist das Java-Archiv tools.jar aus dem lib-Verzeichnis des JDK im Klassenpfad nötig. Dort gibt es das zentrale (interne!) Paket sun.jvmstat.

import java.util.Set;
import sun.jvmstat.monitor.*;

public class T
{
 @SuppressWarnings("unchecked")
 public static void main( String[] args ) throws Exception
 {
  MonitoredHost monitoredhost = MonitoredHost.getMonitoredHost( "//localhost" );
  for ( int id : (Set<Integer>) monitoredhost.activeVms() ) {
   VmIdentifier vmidentifier = new VmIdentifier( "" + id );
   MonitoredVm monitoredvm = monitoredhost.getMonitoredVm( vmidentifier, 0 );
   System.out.printf( "%d %s %s %s%n", id,
   MonitoredVmUtil.mainClass( monitoredvm, true ),
   MonitoredVmUtil.jvmArgs( monitoredvm ),
   MonitoredVmUtil.mainArgs( monitoredvm ) );
  }
 }
}

Die Ausgabe ist

2984  -Dosgi.requiredJavaVersion=1.5 -Xms40m -Xmx512m -XX:MaxPermSize=256M null 
360 T -Dfile.encoding=Cp1252 null 
2256  -Xbootclasspath/a:C:\PROGRA~1\Java\JRE16~1.0\lib\deploy.jar;C:\PROGRA~1\Java\JRE16~1.0\lib\plugin.jar -Xmx96m ...

Nützlich kann das ganze sein, um etwa herauszufinden, ob schon ein Exemplar des aktuellen Programms läuft. Denn das zweite Programm findet über mainClass() zweimal die gleiche Klasse.

Der Spring-Server hat heute schon den ganzen Vormittag Probleme...

Labels: Spring

Das Google Web Toolkit (GWT)  ist ein Web-Framework, mit einem interessanten Ansatz. Statt HTML-Seiten in den Vordergrund zu setzen, schreibt man Gui-Anwendungen in Java mit einer in AWT/Swing bekannten Art (Komponenten/Container und Listener) und lässt diese Anwendung von einem Compiler in JavaScript übersetzten. Die ganze Gui wird somit Teil des Web-Browers. Für den Teil, der nicht im Browser läuft, also die gesamte Geschäftslogik und Datenbank, gibt es eine RCP-Schnittstelle.

Schaue drei Beispiele für die Möglichkeiten von GWT an.

• http://gwt.google.com/samples/KitchenSink/KitchenSink.html
• http://www.gwt-ext.com/demo/ (Der Quellcode der Beispiele ist verlinkt. Hier sollte man auch einen Blick drauf werfen.)
• http://extjs.com/explorer/

Um etwas mehr vom Hintergrund zu verstehen, kann man http://www.maximilien.org/presentations/2006/AJAX_and_GWT_Public_07052006.pdf lesen.

Wer praktisch spielen möchte, kann GWT+Eclipse+Plugin nach dem folgenden Blog-Eintrag installieren. Mehr über die Gui-Komponenten erfährt man in einem Kapitel des Hanser-Verlags (Übersetzung von GWT in Action): Widgets (deutsch).

Labels: Die wöchentliche Dosis Java, GWT

1. Beziehe Tomcat 6.0 und entpacke es.
2. Beziehe GWT 1.5: http://code.google.com/webtoolkit/download.html. Gerade aktuelle Version: http://google-web-toolkit.googlecode.com/files/gwt-windows-1.5.3.zip
3. Lade Eclipse IDE for Java EE Developers (http://phoenix.eclipse.org/packages/)
4. Beziehe Cypal Studio for GWT (http://code.google.com/p/cypal-studio/downloads/list).
   Das Neue bei Eclipse 3.4: Man packt das GWT-Plugin aus und setzt es in einen
   neuen Unterordner Cypal/plugins von Eclipses dropins-Ordner
   (und nicht wie früher plugins). Zum Beispiel stehen dann die drei
   Jars direkt unter C:\Programme\Eclipse\eclipse\dropins\Cypal\plugins.
5. Starte Eclipse
6. Zwei Einstellungen unter Window > Preferences sind vorzunehmen: 1) Installieren in Eclipse Tomcat 6.0. Gehe unter Server > Runtime Environment, Add, ... 2) GWT-Pfad einstellen: Bei Cypal Studio das GWT Home anpassen.
7. Lege in Eclipse ein File > New > Other > Web > Dynamic Web Project an. Unter Configuration gehe auf Modify. Setze ein Häkchen bei Cypal's GWT Facet. Setze Java auf 5.0. Das JavaScript Toolkit ist nicht nötig.
8. Beim neuen Web-Projekt gehe auf Properties, dann Java Build Path im Reiter Libraries. Lösche die Apache Tomcat Libraries.
9. Lege mit File > New > Other > Cypal Studio ein neues Module an. Gib Paketnamen und Name an. Das Plugin erzeugt daraufhin ein Unterpaket client, mit der Klasse, die EntryPoint erweitert.
10. In die Vorlage setzte in onModuleLoad():
RootPanel.get().add( new Button( "Sag 'Hallo'", new ClickListener() {
public void onClick( Widget w ) {
Window.alert( "Hallo" );
}
} ) );
    Lasse Strg+Shift+O alle import-Anweisungen einsetzen. (Paket com.google.gwt.core.client und com.google.gwt.core.client.io).
11. Auf dem Projekt gehe unter Run As > Run Configuration, GWT Hosted Mode Application, New_configuration. Ist das Modul ausgewählt. startet Run die Google GWT-Umgebung.
12. Für einen neuen Service öffne File > New > Other Cypal Studio > Remote Service. Der Service soll FileService heißen. Die Service-URL soll file heißen. Bestätige den Dialog. Der Generator legt eine Klasse und eine Schnittstelle für die Client- und eine weitere Klasse für die Server-Seite an. Wähle zunächst den Client aus com.tutego.client.FileService. Setze in den Rumpf der Klasse die Methode String[] getFiles(String path);. Ein Compilerfehler taucht dann bei der Realisierung com.tutego.server.FileServiceImpl auf. Setze dort hinein: public String[] getFiles( String path ) { return new File(path).list(); }
13. Erweitere in der Hauptklasse die Methode onModuleLoad() durch:
    final ListBox listBox = new ListBox();
FileService.Util.getInstance().getFiles( "c:/", new AsyncCallback<String[]>() {
public void onFailure( Throwable throwable ) { }
public void onSuccess( String[] strings ) {
for ( String string : strings )
listBox.addItem( string );
};
} );
RootPanel.get().add( listBox );

14. Zum Weiterlesen http://blogs.pathf.com/agileajax/2007/07/36-gwt-tutorial.html

Labels: GWT, Open Source

JIDE ist ein Unternehmen, welches schon seit vielen Java qualitativ hochwertige Swing-Komponenten baut. Einige der Komponenten sind frei (JIDE Common Layer (Open Source Project)), weitere wie das Docking-Framework, Action Framework, (Pivot) Grids, Code Editor und weitere gehören zum kommerziellen Teil. Die Komponenten aus dem JIDE Common Layer stehen unter dual-license: GPL und free commercial license.

Textbox, die sich automatisch erweitert

Tabelle und Liste mit Checkboxen, Split-Pane mit mehreren Bereichen

Neue Border und Border-Layout mit anderer Anordnung Norden und Süden

Button-Gruppe und Datums, Popupmenü verbreiterbarer Größe und Zeit/Datum-Auswahl

Neue Standard-Dialoge

Verzeichnisauswahl

Overlay legt Komponenten über andere Komponenten

Scrollpane mit Platz für weitere Komponenten, Slider mit zwei Enden

Container mit Suche und Selektion

Statt Scrollbar automatisches Scrollen durch Pfeile

Diverse Label

Reiterkomponente

Labels: Open Source

Eclipse kommt in die Release Candidates, und der erste kann geladen werden. Aufgefallen ist mir das erst, nach dem ich gesehen habe, dass es auch ein Update vom WTP mit den Web-Tools 3.0RC1 gibt. Das Ganymede Java EE Package enthält als All-in-one-Package (JEE ist ca. 160 MB) alles nötige.

Labels: Eclipse, Entwicklungsumgebung

David Heffelfinger. Packt Publishing. ISBN 1847192602. Oktober 2007. 408 Seiten

Trägt ein Buchtitel eine Technologie und gleichzeitig ein Produkt im Namen, ist das eine schwere Mischung. Entweder wird auf die Administration des Servers eingegangen, oder wir finden ein Lehrbuch, das nur Beispiele lauffähig auf einem speziellem Produkt vorweisen kann. Heffelfingers Werk gehört in keine Kategorie. Der Bezug zu Glassfish ist minimal, und wer mehr sucht als eine kleine Installationsanweisung – die es auch im Netz bei Sun gibt –, wird enttäuscht. Da die sauberen Java EE Beispiele den Entwickler nicht an einen speziellen Container binden, sind seine Quellcodes auch auf JBoss oder Geronimo ablauffähig. Wer nun Java EE lernen möchte, ist sicherlich darin interessiert, seine Beispiele zumindest auf einem Server laufen zu sehen. Aus Sicht der Zielgruppe eines Buches wohl eher unnötig einschränkend.

Didaktisch und fachlich gibt es das ein oder andere zu bemängeln. Einige Quellcode-Snippets bekommen ihr @Override vor den überschriebenen Servlet-Methoden, andere nicht. Und warum wird der String-Konstruktor laienhaft verwendet?

application.setAttribute("applicationAttribute", new String( "This string is accessible accross sessions."));

Oder parameterName aus String deklariert, aber später dennoch einmal explizit gecastet?

String parameterName = (String) initParameterNames.nextElement();
out.print(config.getInitParameter((String) parameterName));

Oder ein StringBuffer statt der guten allen String-Konkatenation eingesetzt?

@Override public String toString() {
StringBuffer fullNameBuffer = new StringBuffer();
fullNameBuffer.append(firstName);
fullNameBuffer.append(" ");
fullNameBuffer.append(lastName);
return fullNameBuffer.toString();
}

Hier ist ein return firstName + " " + lastName; doch wirklich angenehmer zu lesen und auch die Performance gar nicht schlechter.

Ebenso heiße ich es nicht für sinnvoll, auf das MVC-Konzept auch bei JSP/Servlets zu verzichten. Didaktisch dürften JSPs eher vor Servlets Sinn ergeben. JSPs gehen mir auch zu früh runter auf implizite Objekte und eine Skriptlet-Ebene ohne früh schon EL und die Standard-TagLib zu erklären. Die web.xml-Datei bekommt auch immer unterschiedliche Schema-Dateien und Versionen untergeschoben: Einmal 2.4, dann wieder das aktuelle 2.5. Beim Fehlerhandling findet sich:

StringWriter stringWriter = new StringWriter();
PrintWriter printWriter = new PrintWriter(stringWriter);
exception.printStackTrace(printWriter);
out.write(stringWriter.toString());

Warum der Autor nicht einfach exception.printStackTrace(new PrintWriter(out)); schreibt, ist mir ein Rätsel. (out ist ein JspWriter extends Writer und printStackTrace() möchte einen PrintStream oder PrintWriter.) Dann ist die Definition einer Bean falsch: „All of its variables must be private.” Die von Properties verwendeten Attribute sind in der Regel private, aber sie müssen es nicht sein. Auch sind natürlich public static final-Konstanten erlaubt. (Wunderbar, dass ausgerechnet im zugehörigen Beispiel die Variablen nicht private sind, sondern paketsichtbar.)

Die Datenbank ist mit zehn Tabellen vielleicht für Einstiegerbeispiele doch etwas zu kompliziert. Als Leser ist man erschrocken, plötzlich ein Servlet zu sehen, welches an die Datenbank geht und SQL-Anweisungen ausführt. Warum sieht man so einen Wahnsinn noch im Jahre 2008? Die Datenbank-Connection wird zudem nicht korrekt im finally-Block geschlossen. Es reicht, auf Seite 120 gebe ich auf und wage den Wiedereinstieg auf Seite 347. (Übersprungen werden Standard TagLibs, JSF, JMS, Security, EJB, Web-Services.) Zum Abschluss ein kleiner Höhepunkt: Heffelfinger geht praktisch auf Facelets ein und zeigt auch ein Beispiel für das Templating, ein Weiteres für Ajax4jsf und JBoss Seam findet sich ebenso. Ein erneuter Lichtblick: Der Autor verwendet vorbildlich die vorgesehene Dateieindung .jspf für inkludierte JSP-Fragmente. Dann noch etwas IDE-Integration (NetBeans und Eclipse) und der Spuk ist vorbei.

Labels: Rezension

Arulkumaran Kumaraswamipillai, Sivayini Arulkumaran. Lulu.com. ISBN 1411668243. April 2007. 355 Seiten

Es handelt sich um ein interessantes Buch, welches ich in dieser Form noch nicht gelesen habe. Meist dreht es sich ja um Anwendungsdesign oder harte Technologien, aber ein Buch, welches für Java-Entwickler mögliche Bewerbungsfragen sammelt, ist mir neu. Daher sollte das Werk auch von zwei Seiten beleuchtet werden: Vom Interviewer und vom Interviewten. Beide Gruppen erhalten mögliche Standardfragen zu diversen Themen aus Java SE, Java EE (+Hibernate +Spring) sowie Anwendungsdesign. Das Niveau wechselt zwischen „Was ist der Unterschied zwischen String und StringBuffer?“ und „Erkläre Inner Join und Outer Join.“ Beide Parteien erhalten ausreichende Antworten, wobei das Buch nur kurze Erklärungen liefert und auf breite Ausschweifungen verzichtet; sonst könnte leicht ein 2000 Seiten starker Wälzer daraus werden. Die Fragen sind gut gemischt und decken optimal das Standardwissen jedes Entwicklers ab. Trotz des Lobes kann die Erwähnung einiger Fehler nicht unterbleiben. Ein Beispiel zum Thema Varags: „The type must be Object and it must be the last argument or the only argument to the method.” Natürlich kann jeder Typ bei Varags verwendet werden, int… genauso wie String…. Hinzu kommen noch ein paar Kleinigkeiten, wie \n statt %n in printf(), klein geschriebene Enum-Konstanten, String-Konkatenationen im SQL-Statement für variable Teile statt Prepared-Statement und nicht erreichbarer Programmcode beim Schließen von JDBC-Connections, wenn es vorher eine Exception gab. Dennoch alles in allem ein gutes Buch zur Vorbereitung und auch zum Auffrischen des Java-Wissens für Entwickler, die schon ein paar Jahre Java programmieren.

Labels: Rezension

YUI4JSF (http://yui4jsf.sourceforge.net/) bietet auf der Basis der The Yahoo! User Interface Library (YUI) neue JSF-Komponenten:

• Accordion Menu
• CommandButton
• Ajax CommandButton
• CommandLink
• Menu Button
• Auto Complete
• Slider
• Calendar
• Datatable
• Column
• Editor
• Menu
• MenuBar
• SubMenu
• Menuitem
• Menu Button Item
• TreeView
• TabView
• Tab
• SortList
• SlideShow
• Panel
• Dialog
• Simple Dialog
• Choose Color
• Input Color
• Tooltip
• Logger

Die Webseite schreibt über das YUI4JSF-Projekt:

Components that wrap around builtin YUI Widgets. YUI has many widgets like calendar, slider, autocomplete, treeview, inputColor and etc. YUI4JSF takes these widgets and provides pure JSF Components which take care of the javascript and server side interaction.

Components powered by YUI Utilities. YUI Utilities like DragDrop Utils are used to create custom components like SortList or Accordion Panel.

AJAX Forms (Beta). YUI4JSF Ajax components like ajaxCommandButton ajaxifies your existing forms in few seconds.

Layout Engine (Experimental). YUI4JSF provides a templating engine that helps creating a flexible layout mechanism in your JSF pages.

Das Demo (http://www.nightdev.devisland.net/yui4jsf-examples) zeigt die Komponenten live. Wenn ich allerdings das Look-and-Feel der YUI-Beispiele mit denen von YUI4JSF vergleiche, kommt YUI4JSF irgendwie schlechter weg.

License: Apache License V2.0

Labels: Open Source, Web Frameworks

Vom VisualVM (https://visualvm.dev.java.net/) gibt es eine erste 1.0 Version.

May 6th, 2008: VisualVM 1.0 RC released. This is mainly a stabilization release: many bugs have been fixed and performance and memory management have been significantly improved. The only new feature is the Start Page which contains useful links to VisualVM documentation and JDK monitoring and troubleshooting guides. Sources for this release are available in release10 branch.

Es sieht so aus, als ob VisualVM in Java 7 als weiteres Tool neben der JConsole einzieht. (Oder vielleicht auch VisualVM sich die JConsole einverleibt und dann VisualVM das "Hauptprogramm" wird. VisualVM erlaubt -- genauso wie auch die JConsole -- Plugins, und eines ist eben für MBeans.)

Labels: Java SE, Open Source

Die quelloffene JSF-Komponenten-Sammlung  https://woodstock.dev.java.net/ ist in einer neuen Version 4.2 veröffentlicht. Demos der Komponenten gibt es unter http://webdev2.sun.com/example/faces/index.jsp. Interessant finde ich die Rate-Komponente und das Common Tasks Page.

Labels: Open Source

Anil Hemrajani. Sams. ISBN 0-672-32896-8. Mai 2006. 360 Seiten

Lehrbücher, die anhand eines Beispiels versuchen, die agile testgetriebene Softwareentwicklung mit Ant, Hibernate, HSQLDB und Spring (Web mit Spring MVC) zu zeigen, gibt es meines Wissens keins – bis auf dieses. Vielleicht ist das auch kein Wunder, denn schon die Themen Spring/Hibernate füllen dicke Bücher. Hemrajanis Buch will aber gar nicht in die Tiefe gehen, sondern zeigt, wie mit Open-Source Tools ein Online Timesheet System aufgebaut wird. Der Autor streift dabei weitere Technologien, wie die Eclipse IDE, Logging, Profiling, und stellt Links zu vielen Tools übersichtlich am Ende jedes Kapitels vor. Die Zielgruppe für das Buch dürften Personen sein, die bisher mit dem Standard Java gearbeitet haben, und nun lernen wollen, mit welchen Enterprise Technologien sich Web-Anwendungen bauen lassen. Wer eine detaillierte Beschreibung in JUnit, Hibernate und Spring sucht, ist mit dem Buch sicherlich nicht gut beraten. Schade ist auch, dass Hibernate über die HBM.XML-Dateien konfiguriert wird und nicht die Sprachmöglichkeiten über Java 5 (Annotationen) und der JPA-Entity-Manager zum Einsatz kommen. Dass nicht Spring 2 den Kern bildet, ist zu verschmerzen, und das statt Spring MVC nicht Spring WebFlow zum Einsatz kommt ist wohl eher eine Frage des didaktischen Wegs und dem Zeitpunkts des Drucks zu verschulden.

Labels: Rezension, Spring

Bei jedem Software-Projekt sollte die Qualität über einen langen Zeitraum konstant hoch sein. Insbesondere bei wechselnden Team-Mitgliedern kommen aber schnell Inkonsistenzen in die Sourcen und die Qualität leidet. Code-Analyse Tools versuchen aufgrund bekannter Fehler-Pattern genau diese Schwachstellen zu finden. In Java gibt es eine ganze Reihe von Tools. So führt http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis#Java auf:

• Bandera — analyzer for Java
• Checkstyle — analyze Java and apply coding standard
• Classycle — analyze Java class cycles and class and package dependencies (Layers)
• FindBugs — an open-source static bytecode analyzer for Java (based on Jakarta BCEL).
• Jlint — for Java
• PMD (software) — a static ruleset based Java source code analyzer that identifies potential problems.
• Soot — A Java program analysis and compiler optimization framework

Für einige Produkte gibt es Eclipse-Plugins. Teste FindBugs in Eclipse/NetBeans. Studiere die Bugs/Schwachstellen, die FindBugs automatisch finden kann.

Labels: Die wöchentliche Dosis Java

Beim http://openjdk.java.net/ Projekt ist ein Unterprojekt http://openjdk.java.net/projects/closures/ eingerichtet worden:

This goal of this Project is to produce a feature-complete prototype of the Java bytecode compiler (javac) for the draft BGGA Closures specification. This Project is sponsored by the OpenJDK Compiler Group.

Wenn es also Closures in Java schaffen -- einige Stimmen sagen, dass es dafür noch zu früh ist -- dann wohl diese Syntax. Da das Projekt sehr neu ist, befinden sich in der Mailing-Liste noch nicht viele Nachrichten.

Derweil hat sich die Closures-Spezifikation (Homepage http://www.javac.info/) von der Version 0.5 nicht weiter bewegt und auch die Open Issues sind nicht geklärt.

Interessant ist auch die http://www.javac.info/google-position.html (Neal Gafter ist Angestellter bei Google)

As of April 7, 2008, the following is Google's position on proposals to add support for closures to Java: Google believes Java platform will likely benefit from continued research into closures. To arrive at the best solution, Google is open to multiple parallel investigations but is not currently prepared to commit to any particular proposal. We do not expect these investigations to yield results in time for Java 7, and are of the opinion that it is premature to launch a JSR that forces us down any specific path.

Labels: Java 7

Bis Spring 2.0 gab es im Wesentlichen nur eine Möglichkeit, Spring-Beans zu deklarieren und Bean-Referenzen zu injizieren. Ab Spring 2.0 und besonders in Spring 2.5 gibt es einen Richtungswechsel. Statt Bean-Definitionen und Injizierungsanweisungen ausschließlich über XML-Dokumente zu beschreiben, kommen Annotationen hinzu. Spring nutzt zum Einen Standard-Annotationen aus Java 6 (Common Annoations) aber auch eigene.

Nehmen wir zwei Beans an:

    <bean id="today" class="java.util.Date" /> 
    <bean id="calendarPrinter" 
      class="com.tutego.spring.annotation.CalendarPrinter" /> 

Die Bean CalendarPrinter soll ein Datum injiziert bekommen.

    public class CalendarPrinter { 
      public void setDate( Date date ) … 

Über XML lässt sich das einfach beschreiben, doch seit Spring 2.5 veranlasst eine Annotation Spring dazu, die Verweise automatisch zu injizieren:
@Autowired

@Autowired ist eine Annotation für Methoden und Attribute, damit Spring selbständig den Verweis setzt:

    public class CalendarPrinter { 
      @Autowired 
      public void setDate(@Qualifier("today") Date d) … 
    } 

Die Annotation @Qualifier ist nur dann nötig, wenn es mehrere Beans dieses Typs gibt. (Nicht bei uns.)

Damit Spring überhaupt die Verknüpfung vornimmt, ist in der XML-Datei ein Hinweis zu setzen.

Die erste Möglichkeit ist:

    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

Eine im Allgemeinen bessere Alternative (die AutowiredAnnotationBeanPostProcessor und CommonAnnotationBeanPostProcessor zusammenfasst) ist

    <context:annotation-config/>

Die Annotation @Autowired ist genauso gültig bei Attributen:

    public class CalendarPrinter 
    { 
      @Autowired Date date;

      public void doIt() 
      { 
        System.out.println( date ); 
      } 
    }

<beans xmlns="http://www.springframework.org/schema/beans" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xmlns:context="http://www.springframework.org/schema/context" 
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-2.5.xsd"> 
<context:annotation-config/> 
<bean id="today" class="java.util.Date" /> 
<bean id="calendarPrinter" class="com.tutego.spring.annotation.CalendarPrinter" /> 
</beans>

Java 6 (für Java 5 ist ein Extra-Jar nötig) führt aus JSR-250 die Lebenszyklus-Annotationen @PostConstruct und @PreDestroy sowie @Resource ein.

    public class CalendarPrinter { 
      @PostConstruct public void initialize() { 
        System.out.println( "init" ); 
      } 
      /* @PreDestroy public void remove() { 
        System.out.println( "destroy" ); 
      } */ 
    }

Beans deklarieren

Die Verknüpfung ist durch Autowire automatisiert und minimiert die XML-Konfigurationsdatei.
Zum Deklarieren von neuen Beans bringt Spring ebenfalls Annotationen mit.
Statt in der XML-Datei zu schreiben

    <bean id="calendarPrinter" class="com.tutego.spring.annotation.CalendarPrinter" /> 

können wir annotieren:

    @Component class CalendarPrinter

Damit Spring nach annotierten Beans sucht, ist nötig:

    <context:component-scan base-package="com.tutego.spring" />

Die Annotation @Component ist an allen Typen erlaubt und natürlich zur Laufzeit sichtbar:

    @Target(value=TYPE) 
    @Retention(value=RUNTIME) 
    @Documented 
    public @interface Component 
    { 
      String value(); 
    } 

API zur Eigenschaft: „The value may indicate a suggestion for a logical component name, to be turned into a Spring bean in case of an autodetected component.“

Geben wir dem CalendarPrinter den Bean-Namen „ cal-printer“:

    @Component("cal-printer") 
    public class CalendarPrinter

Aus dem ApplicationContext genommen folgt:

    ApplicationContext context = 
      new ClassPathXmlApplicationContext( … ); 
    Object bean = context.getBean( "cal-printer" ); 
    System.out.println( bean.getClass() ); 
    // class com.tutego.spring.annotation.CalendarPrinter

@Component ist eine sehr allgemeine Annotation.

Besser ist es, semantische Annotationen zu nutzen, die @Component erweitern. Spring liefert drei mit:

1. @Target(value=TYPE) … @Component
   public @interface Repository
   


2. @Target(value=TYPE) … @Component
   public @interface Service


3. @Target(value=TYPE) … @Component
   public @interface Controller

Labels: Spring

Heise schreibt am 7. Mai, dass Borland CodeGear für lächerliche 23 Millionen Dollar an Embarcadero verkauft. Damit geht eine lange Ära von Borland Entwicklungswerkzeugen zuende. Was nun aus dem JBuilder wird, ist damit offen. Embarcadero ist zumindest bei Entwicklern kein Unbekannter, denn das Unternehmen entwickelte das UML-Tool Describe, was in die Sun-IDE eingeflossen ist.

An der Datum/Zeit-API wird schon ewig rumgemeckert, und jetzt soll es wirklich gut werden. Lies zunächst die API-Dokumentation der zentralen Standard-Klassen:

• Date
• DateFormat
• SimpleDateFormat
• Calendar
• GregorianCalendar

Was sind die Argumente der Kritiker?

• http://justinsomnia.org/2007/05/dates-and-java-suck/
• http://robsanheim.com/2006/03/13/top-five-worst-apis-in-java/
• http://vafer.org/blog/20041128172956 (Java Dates and other crap)

Eine hervorragende Open-Source-Biblitohek ist http://joda-time.sourceforge.net/. Was macht Joda-Time anders/besser?

Die https://jsr-310.dev.java.net/ möchte endlich eine tolle Datums/Zeit-API in das Standard-Java Version 7 bringen. Was unterscheidet Joda-Time von JSR 310?

Labels: Die wöchentliche Dosis Java