Das erste Android Programm

Im Moment gibt es ein großes Rumgezampel wegen der NDA von Apple bei der Entwicklung von iPhone-Applikationen und das, was es als Applikationen in den Apple App Store darf und was nicht

Google macht das mit Android besser, da hier alles frei sind wird und auch jede Applikation in den Store kommt. Und ein erstes Programm ist schnell aufgebaut:

  1. Gehe auf http://code.google.com/android/download_list.html.
  2. Lade unter Windows zum Beispiel android-sdk-windows-1.0_r1.zip. Entpacke das Zip, etwa nach C:\Program Files\Java\android-sdk-windows-1.0_r1.
  3. Installiere über den Eclipse Update-Manager das Plugin unter der URL http://dl-ssl.google.com/android/eclipse/. Das dauert! Starte Eclipse neu.
  4. Unter Window > Preferences > Android trage das Verzeichnis C:\Program Files\Java\android-sdk-windows-1.0_r1 ein.
  5. Gehe auf http://code.google.com/android/intro/hello-android.html und führe die Schritte für ein neues Android-Projekt durch.
  6. In die generierte onCreate()-Methode setzte rein:
  7. super.onCreate(savedInstanceState);
    TextView tv = new TextView(this);
    tv.setText("Hello, Android");
    setContentView(tv);
  8. Starte die Applikation wie unter http://code.google.com/android/intro/hello-android.html#run beschrieben im Emulator. Das dauert leider sehr lange!

Thema der Woche: Continuous Integration mit Hudson

Lies zunächst http://martinfowler.com/articles/continuousIntegration.html von Martin Fowler über die Motivation von CI in der Softwareentwicklung.

In den letzten Monaten hat sich das Hudson zu einem Publikumslieblig entwickelt. Studiere die folgende Präsentation:

(Hudson stammt vom Kohsuke Kawaguchi, der eine ganze Reihe sehr interessanter Projekte bei Sun macht, etwas JAXB oder auch https://com4j.dev.java.net/. Wer ein Podcast von ihm und Husdon hören möchte: http://blogs.sun.com/glassfishpodcast/entry/episode_007_interview_with_kohsuke)

Blättere ein wenig auf den Seiten unter http://hudson.gotdns.com/wiki/display/HUDSON/Meet+Hudson. Falls ein Projekt mit CSV- oder SVN-Zugriff verfügbar ist teste Hudson.

Java Tipp: Initialisierung einer Map

Der übliche Weg führt über ein put(), wobei man das unterschiedlich schreiben kann:

Map<String, String> map = new HashMap<String, String>();
map.put( "name", "chris" );
map.put( "email", "a@b.c" );

Oder auch mit einem Exemplarinitialisierer (das ist aber schmutzig in meinen Augen!):

Map<String, String> map = new HashMap<String, String>() {{
  put( "name", "chris" );
  put( "email", "a@b.c" );
}};

Alternative: http://commons.apache.org/collections/api-release/org/apache/commons/collections/MapUtils.html#putAll(java.util.Map,%20java.lang.Object[]). Die API nennt ein Beispiel:

Map colorMap = MapUtils.putAll(new HashMap(), new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}
});

Die Apache Common Collections sind aber erst einmal nicht generisch!

Für http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/Maps.html ist so was wohl geplant, aber bisher noch nicht implementiert.

Java Wikipedia API

Wer von Java aus auf die Inhalte von Wikipedia zugreifen, und die Inhalte auch noch Rendern möchte, findet mit der quelloffenen Java Wikipedia API (http://www.matheclipse.org/en/Java_Wikipedia_API) eine passende Unterstützung.

Zum Laden einer Wikipedia-Seite und Renderer in eine Datei ist lediglich nötig:

User user = new User( "", "", "http://de.wikipedia.org/w/api.php" );
List<Page> queryContent = user.queryContent( Arrays.asList( "Java (Programmiersprache)" ) );
String content = queryContent.get( 0 ).getCurrentContent();

WikiModel wikiModel = new WikiModel( "http://de.wikipedia.org/wiki/${image}",
                                     "http://de.wikipedia.org/wiki/${title}" );

String rendererdHtmlContent = wikiModel.render( content );

FileWriter fw = new FileWriter("c:/test.html");
fw.write( rendererdHtmlContent );
fw.close();

Einige Dinge löst der Renderer aber nicht auf. So verbleiben im Text Wiki-Templates wie

  • {{Infobox Programmiersprache}}
  • {{IPA}}
  • {{Wikiversity}}
  • {{Wikibooks}}

oder bei anderen Texten

  • {{Begriffsklärungshinweis}}
  • {{Commonscat}}
  • {{internetquelle}}
  • {Literatur}}

Auch Bilder werden standardmäßig nicht richtig umgesetzt. So wird bei http://de.wikipedia.org/wiki/Linux aus

[[Bild:Linus Torvalds.jpeg|thumb|right|Linus Torvalds 2004]]

kein Bild, sondern ein Link

<a href="http://de.wikipedia.org/wiki/Bild:Linus_Torvalds.jpeg%7Cthumb%7Cright" id="w">Linus Torvalds 2004</a>

Dumm nur, dass %7Cthumb%7Cright falsch ist, sonst wäre wenigstens der Link korrekt. (%7C ist |)

HOWTO Build a REST-Application with Jersey and Jetty

Resource first:

package com.tutego.traida.server;

import javax.ws.rs.*;

@Path( "/" )
public class GreetingResource
{
@GET @ProduceMime("text/plain")

public String get()
{
return "Yea!";
}
}

Bring it to Jetty

package com.tutego.traida.server;

import org.mortbay.jetty.Server;
import org.mortbay.jetty.servlet.Context;
import org.mortbay.jetty.servlet.ServletHolder;
import com.sun.jersey.spi.container.servlet.ServletContainer;

public class Application 
{
public static void main( String[] args ) throws Exception
{
ServletHolder sh = new ServletHolder( ServletContainer.class );

sh.setInitParameter( "com.sun.jersey.config.property.resourceConfigClass",
"com.sun.jersey.api.core.PackagesResourceConfig" );
sh.setInitParameter( "com.sun.jersey.config.property.packages", "com.tutego.traida.server" );

Server server = new Server( 9999 );
Context context = new Context( server, "/", Context.SESSIONS );

context.addServlet( sh, "/*" );
server.start();

}
}

To use REST-parameters

@Path( "/edit-customer/{customerid}" )
public class EditCustomerResource
{
@GET @ProduceMime("text/plain")
public String editUser( @PathParam("customerid") String customerId )
{
....
}
}

HOWTO Add a JDBC DataSource/JNDI to GlassFish

Use asadmin with option create-jdbc-connection-pool first:

asadmin create-jdbc-connection-pool --datasourceclassname org.apache.derby.jdbc.EmbeddedDataSource --property databaseName=\$\{com.sun.aas.instanceRoot\}/databases/tutegodb:connectionAttributes=\;create\=true tutegoPool

Use asadmin again to install the actual JNDI name:

asadmin create-jdbc-resource --connectionpoolid=tutegoPool jdbc/tutego

To remove the pool and all attached JNDI names:

asadmin delete-jdbc-connection-pool --cascade tutegoPool

DZone-Interview mit Sacha Labourey über JBoss AS 5

Gibt es unter http://java.dzone.com/videos/tech-chat-sacha-labourey-jboss.

Natürlich galt es im Interview zu klären, warum man auf JBoss 5 so lange warten muss. Fertig ist er aber immer noch nicht!

We are very close to GA.

Warum noch immer nicht soweit? Weil der JBoss einen ganz neuen Microcontainer bekommt und weil unter anderem die Messaging-Lösung (JBoss Messaging) neu entwickelt wurde und JBoss 5 einen neuen Transaktions-Monitor bekommt. Einen Lacher erntet er bei mir aber mit:

Intuitively people usually think that it is an issue with the J2EE spec and how much time it took us to implement this pretty significant update of the J2EE spec.

JBoss war immerhin einer der ersten Container, die EJB 3 unterstützten. Aber Web-Services machen den JBoss 4 immer etwas Probleme, was auch an der Integration von Axis lag.

Ich sehe eher weniger gute Zukunfsaussichten für JBoss. Mit der wachsenden Popularität von GlassFish und Geronimo wird JBoss 5 zu kämpfen haben. GlassFish und Geronimo/IBM WASCE sowie WebLogic Server v10.0, SAP NetWeaver 7.1, Apusic Application Server, TmaxSoft JEUS 6, NEC WebOTX 8.1 sind (zum Teil schon sehr lange) Java EE 5 zertifiziert (http://java.sun.com/javaee/overview/compatibility.jsp) und JBoss 5 hat das auch noch vor sich.

Weiterhin glaube ich in der Java-Community einen Trend in Richtung der Sun-Implementierungen erkennen zu können, was zum Beispiel die RI für JavaServer Faces, aber auch etwa JAX-WS für Web-Services angeht. Interessant ist auch, dass GlassFish die JSP-Servlet-Übersetzung optimiert über JSR 199 regelt, eine Entwicklung, die eben nicht von Tomcat ausgeht. So nutzt auch Jetty das. (Schon 2006 war zu lesen: "patch to allow Jetty to use JSP2.1 from Glassfish instead of Jasper from Tomcat"). Von GlassFish geht im Moment ein sehr starker Zug aus und es bleibt sehr spannend.

MouseScrollableUI für JXLayer

Browser haben mich zum ersten Mal auf ein Gui-Feature aufmerksam gemacht, das folgender Screenshot am Besten erklärt:

demo screenshot

In der Tabelle erkennt man ein Symbol, mit dem sich leicht durch große Views scrollen lässt. Aktiviert wird diese Möglichkeit über die mittlere Maustaste.

Nun ist so etwas auch einfach für Swing über einen Dekorator möglich:

JScrollPane sp = JScrollPane( table );
JXLayer<JScrollPane> lsp = new JXLayer<JScrollPane>( sp, new MouseScrollableUI() );
container.add( lsp );

Thema der Woche: Refactoring

Refactoring von Code ist eine wichtige Aufgabe von Entwicklern neben der Neuentwicklung von Programmcode. Die Pflege und Aufarbeitung darf natürlich nicht zum Selbstzweck werden, aber langlebige Software muss zwingend für immer die Kriterien Wartbarkeit und Erweiterbarkeit bewahren und gut dokumentiert und verständlich sein.

Den größten Einfluss auf das Thema Refactoring hat das Refactoring-Buch von Martin Fowler, der auf seiner Webseite das Prinzip Refactoring, Refactoring-Tools und News auflistet.

Martin Fowler hat mir erlaubt, seinen Refactoring-Katalog auf Deutsch zu übersetzen: http://www.tutego.com/java/refactoring/catalog/. Gehe kurz über alle Refactorings.

Moderne IDEs erlauben von Haus aus das Refactoring von Code. Im Fall von Eclipse finde zu jedem unterstützten Refactoring ein Beispiel und lasse es von Eclipse umbauen:

GWT 1.5 RC2

Bezug unter http://code.google.com/webtoolkit/download.html . Changelog unter http://code.google.com/webtoolkit/releases/release-notes-1.5.1.html#Release_Notes_Current . Grundsätzlich für GWT 1.5:

  • Java 1.5 Support
  • Compiler Enhancements to Improve Application Speed
  • UI Library Additions: Widget Animations, Visual Themes
  • DOM API for simplified DOM Programming
  • Internationalization Improvements: Bi-di, Pluralization
  • Accessibility Support
  • Enhancements to the JRE Emulation Library

Erster Java Closures Prototype im openjdk

Von http://gafter.blogspot.com/2008/08/java-closures-prototype-feature.html:

The complete source code, released under GPLv2, is in the project’s openjdk repository. A binary build, suitable for use with an existing JDK6, is at http://www.javac.info/closures.tar.gz. Other related documents are on the website http://www.javac.info/

Neu sind Method references aus dem  FCM proposal:

{ String => int } parseInt = Integer#parseInt(String);
int x = parseInt.invoke("42");

Damit wird es immer wahrscheinlicher, dass es Closures in Java 7 gibt, obwohl Zeitpunkt und Inhalte immer noch nicht feststehen.

VisualVM 1.0 + JDK Integration

VisualVM ist nun in der Version 1.0 final. Ein erstaunliche Neuerung ist, dass Sun VisualVM in das Update 7 von JDK 6 integriert hat; sonst wurden noch nie in Updates neue Tools integriert.

Die wichtigsten Features von der Webseite:

Display local and remote Java applications. VisualVM automatically detects and lists locally and remotely running Java applications (jstatd must be running on the remote host). You can also define applications manually by JMX connection. This way you can easily see what Java applications are running on your system or check if a remote J2EE server process is alive.


Display application configuration and runtime environment. For each application VisualVM shows basic runtime information: PID, main class, arguments passed to java process, JVM version, JDK home, JVM flags and arguments and system properties.


Monitor application memory consumption and runtime behavior. VisualVM monitors application heap and permanent generation memory, number of loaded classes and running threads. You can easily detect suspicious memory consumption and take an action – invoke garbage collection in the application or take a heap dump and browse the contents of application heap.


Monitor application threads. All threads running in a Java process are displayed in a timeline. You can track thread activity and uncover inefficient patterns like blocked Event Dispatch Thread or unused worker threads.


Profile application performance or analyze memory allocation. VisualVM has a built-in application profiler which can visualize where most of the time is being spent or which objects consume most of the memory by just one mouse click without any additional configuration.


Take and display thread dumps. Taking and displaying a thread dump is as easy as clicking a mouse button. You don’t need to deal with the command line at all to determine what’s currently happening in the application. Moreover, simultaneous thread dumps of multiple applications can be taken at once to start uncovering distributed deadlocks.


Take and browse heap dumps. When you need to browse contents of application memory or uncover a memory leak in your application, you’ll find the built-in HeapWalker tool really handy. It can read files written in hprof format and is also able to browse heap dumps created by the JVM on an OutOfMemoryException.


Analyze core dumps. When a Java process crashes, a core dump can be generated by the JVM containing important information about application state at the time of the crash. VisualVM is able to display application configuration and runtime environment and to extract thread and heap dumps from the core dump.


Analyze applications offline. VisualVM is able to save application configuration and runtime environment together with all taken thread dumps, heap dumps and profiler snaphots into a single application snapshot which can be later processed offline. This is especially useful for bug reports where users can provide a single file containing all the necessary information to identify runtime environment and application state.

Die Webseite sieht auch viel schicker aus (was für die anderen java.net-Projekte aber nicht gilt).

Werbung: Wir haben neue/aktualisierte Seminare.

Doclet APIviz für nette UML-Diagramme

APIviz ist ein LGPL-Doclet, welches nicht nur die klassische JavaDoc-API erstellt, sondern gleich dabei noch UML-Diagramme. Die Diagramme werden generiert von http://www.graphviz.org/.

Hier ein Beispiel, wie das nach dem Erzeugen aussieht:

net.gleamynode.netty.buffer
Class HeapChannelBuffer

java.lang.Object
extended by net.gleamynode.netty.buffer.AbstractChannelBuffer
extended by net.gleamynode.netty.buffer.HeapChannelBuffer

All Implemented Interfaces:
Comparable<ChannelBuffer>, ChannelBuffer
Direct Known Subclasses:
BigEndianHeapChannelBuffer, LittleEndianHeapChannelBuffer

public abstract class HeapChannelBuffer
extends AbstractChannelBuffer

http://netty.googlecode.com/svn/site/api/3.0/net/gleamynode/netty/buffer/HeapChannelBuffer.png

Version:
$Rev$, $Date$
Author:
The Netty Project (netty@googlegroups.com), Trustin Lee (trustin@gmail.com)

Thema der Woche: Rich Internet Applications mit OpenLaszlo und ZK

Statt wie bei vielen Java Web-Frameworks HTML-Seiten in das Zentrum zu stellen, gehen moderne RIA (Rich Internet Applications)-Frameworks einen anderen Weg. Im Mittelpunkt stehen dort XML-Dateien, die die View beschreiben, angereichert mit JavaScript für die Interaktion und das Ansprechen von Services in der Middle-Tier. Drei der bekannten Frameworks sind:

Verschaffe einen Eindruck über die Frameworks mit dem Demos http://www.zkoss.org/demo/, http://www.openlaszlo.org/showcase, http://www.webspiders.com/flex/.

http://www.openlaszlo.org/lps4/laszlo-explorer/index.jsp?lzr=dhtml bietet unter "Laszlo in 10 Minutes " einen Editor auf der einen Seite und eine Ansicht auf der anderen, so dass man über dem Editor, eigene Programme in der Mini-IDE schreiben kann. Entwickle auf diese Weise einen Umrechner von Euro in Dollar.

Installiere den OpenLaszlo Server (http://www.openlaszlo.org/lps4/docs/installation/). Setze den Euro/Dollar-Umrechner in das Verzeichnis. Schreibe eine einfache JSP (oder echten Web-Service über Java 6 wer will; angelehnt an http://rscreeney.wordpress.com/2006/09/19/laszlo-simple-web-service/), die als Service den aktuellen Umrechnugskurs liefert, worauf das eigene OpenLaslo-Programm zurückgreift. (Wer möchte, kann die Lösung gerne hier als Kommentar reinsetzen.)

Sehr interessanter Java/C-Benchmark

Stefan hat unter http://www.stefankrause.net/wp/?p=9 die Ausführungszeit von Programme mit unterschiedliche JVMs und C-Compilern getestet. Zwar misst er keine OOP-Eigenschaften, wie die Heap-Allokation, GC oder Kosten für dynamisch gebundene Methodenaufrufe, aber eben die Effizient für Low-Level-Operationen. Gut zu sehen, dass Java auch da schon extrem gut mithalten kann. Ich hätte die Performance bei arithmetischen Operationen gar nicht so gut eingeschätzt. Im Endeffekt gibt es folgendes Ergebnis:

  • Der GCC-Compiler und die C-Programme sind in der Regel am Schnellsten. Mal ist Suns JVM sogar schneller.
  • Der native-Compiler JET von Excelsior bringt ausgezeichnete Ergebnisse (Platz 2).
  • Der oft gepriesene C-Compiler LLVM ist nicht so gut wie gedacht.
  • Die Performance von Suns JVM schwankt stark. Mal ist sie ausgezeichnet im Gewinnerfeld, mal weit abgeschlagen in der absoluten Verliererzone.

Praxisrelevant sind diese Benchmarks nur zum Teil. Jetzt ist es interessant zu wissen, wie OOP-Eigenschaften vom C++-Compiler oder von JET umgesetzt werden.

Zwei Open-Source Bibs für Java ME Entwicklung

Wer für die Java ME entwickelt, der muss vieles selbst machen, da die CLDC/MIDP-Bibs doch relativ schwach sind. Zwei Open-Source Bibs, die dort Arbeit abnehmen können, sind:

  • kommons – JavaME reusable objects; hat nix mit KDE zu tun 🙂
    The goal of the project kommons is to provide a set of reusable objects useful to make networking, object persistence (Caching), logging, working with Strings (Iso, UTF8) and many more…
  • 59pixels Open Source J2ME Libraries
    Some of the libraries which 59Pixels have built up over the last year. Most of them are the first generation versions and are not as polished or as efficient as they could be but we have been able to distribute our products on over 150 handsets so I’m sure they will be useful to you.

Apache POI 3.1 final

Von http://poi.apache.org, der Open-Source Bib. zum Verarbeiten von MS Excel-, PowerPoint-, Visio- und Word-Dateien, gibt es eine neue Version. Änderungen sind unter anderem:

Highlights in POI-HSSF - Java API To Access Microsoft Excel Format Files:

  • Major improvements in formula evaluation
  • Support for conditional formatting
  • Support for Excel hyperlinks
  • Handling of embedded OLE2 documents
  • Support for getting excel cell comments when extracting text
  • Support for specifying a policy to HSSF on missing / blank cells when fetching

Highlights in POI-HSLF - Java API To Access Microsoft PowerPoint Format Files:

  • Support for getting embedded sounds
  • Support for getting embedded OLE objects
  • Support for Tables
  • Improved text extraction
  • Export PowerPoint slides into image
  • Java2D Graphics driver

Highlights in POI-HWPF - Java API To Access Microsoft Word Format Files

  • Handling of embedded OLE2 documents
  • Support for extracting Escher images from HWPF files
  • Improved Range.replaceText()

Ich bin gespannt, ob sich mit der MS-Initiative, Dokus anzubieten, die Bib. noch weiter und vollständiger entwickeln wird:

Thema der Woche: Collection-API-Erweiterungen

Die Java-Collection API bietet grundlegende Sammlungen, aber es gibt immer noch Bedarf an mehr. Drei Bibliotheken stechen hier besonders raus:

Lese etwas über die Projekte. Beantworte folgende Fragen:

  • Welche neuen Datenstrukturen enthalten Google Collections?
  • Welche Autoren arbeiten an Google Collections?
  • Welchen Sinn ergeben folgende Szenarien: new ReferenceMap(WEAK, STRONG), new ReferenceMap(WEAK, WEAK), new ReferenceMap(STRONG, STRONG)?
  • Was kann man mit der Apache-Klasse ExtendedProperties machen?
  • Wofür sind die Typen in org.apache.commons.collections.functors nötig und wie verwendet man sie ? Haben Transformer damit etwas zu tun?
  • Warum spricht Javolution an vielen Stellen von "hard real-time compliant"?
  • Bewerte den Benchmark http://javolution.org/doc/benchmark.html.