Today i submitted my application Its Your Phone for the Android Developer Challenge. Its Your Phone sends data from a mobile phone to a server. The server saves data in a database. Therefore Its Your Phone consist of two parts: a client for Android which sends data and a server which receives and persists data.

Read more…

Obwohl wir seit Jahren erfolgreich JBoss einsetzen muss ich für einen neuen Kunden WebLogic von BEA testen. Der Kunde nutzt die aktuelle Version 10.0. Vorsicht: WebLogic 10.0 (veröffentlicht am 10.04.07) läuft nicht mit Java 6 (veröffentlicht am 11.12.06). Hm, das alleine ist zumindest merkwürdig. Neue Java Versionen sind in der Regel abwärtskompatibel. So läuft z.B. JBoss-4.0.2, der vor Jahren veröffentlicht wurde, problemlos mit Java 6. Richtig ärgerlich ist aber, dass in der WebLogic Dokumentation nicht darauf hingewiesen wird. Es gibt viele Megabyte Dokumentation zur Version 10.0, z.B. Installation Prerequisites mit System Requirements oder Supported Configurations for BEA WebLogic Platform 10.0 mit Hinweisen zu Betriebssystemen, Web Servern, Datenbanken und sogar Spring Versionen. Es gibt aber keine Hinweise welche JDK Versionen unterstützt werden. Nur indirekt wird darauf hingewiesen. Die WebLogic Server 10.3 Tech Preview unterstützt erstmals Java 6:

This Technology Preview includes select new features, standards updates and performance improvements. Version 10.3 TP remains fully Java EE 5 compatible and adds new support for Java SE 6.

Vielleicht ist es BEA etwas peinlich, dass ihr 10000$-Server sich nicht mir Java 6 verträgt. Ich habe einen ganzen Tag damit verschwendet die 10.0 mit Java 6 zu testen bis ich endlich den Hinweis gefunden habe.

Wer mit Maven arbeitet braucht ein Repository um dort eigene Projekte zu installieren. In dieses Repository müssen Dateien übertragen werden, wenn eine neue Version erstellt wurde. Wenn der Upload in das Repository per SSH bzw. SCP erfolgt, dann fragt Maven während des Builds nach dem Passwort und unterbricht so den Build-Prozesses. Das ist lästig. Daher kann das Passwort in der Maven Konfigurationsdatei <user_home>/.m2/settings.xml eingetragen werden:

…
<servers>
  <server>
    <id>serverid</id>
    <username>name</username>
    <password>passwort</password>
    <filePermissions>664</filePermissions>
    <directoryPermissions>775</directoryPermissions>
  </server>
</servers>
…

Die Id des Servers wird im POM des Projekts referenziert:

…
<distributionManagement>
  <repository>
    <id>serverid</id>
    <name>csecvs Maven Respository</name>
    <url>scp://hostname/path/to/repository</url>
  </repository>
</distributionManagement>
…

Wenn Maven trotzdem nach dem Passwort fragt, dann muss möglicherweise der SSH Server auf dem Rechner umkonfiguriert werden, auf dem das Repository installiert ist. In der Datei /etc/ssh/sshd_config muss die Zeile

PasswordAuthentication yes

eingetragen sein.

HDR Bilder haben einen viel höheren Kontrast als normale Bilder. Der Kontrast liegt bei chemische Photographie bei 10.000:1, bei Digitalphotographie nur bei 1000:1 und bei einem HDR Bild bei ca. 200.000:1. Viele Bereiche von Digitalaufnahmen sind oft über- bzw. unterbelichtet sind. Diese Über- und Unterbelichtung wird bei HDR Aufnahmen reduziert, so dass viel mehr Details sowohl in den dunklen als auch den hellen Bereichen eines Bildes zu erkennen sind. Erreicht wird das mehrere unterschiedlich belichtete Aufnahmen vom selben Motiv. Eine Software setzt das HDR Bild aus diesen Aufnahmen zusammen und wählt für jeden Bereich immer die optimale Belichtung aus.

Ich habe die Aufnahme oben mit dem Programm qtpfsgui unter Linux erstellt.

qtpfsgui ist Open Source und läuft unter Linux, Mac OS X und Windows. Die Bedienung ist einfach, sonst hätte ich damit kein HDR erstellen können: Zuerst wählt man Bilder aus, aus denen das HDR erstellt werden soll. In meinem Fall 3 Aufnahmen aus meiner Canon PowerShot 520 mit der Blende F5.6 und den Belichtungen 1/5s, 1/3s und 1s. Zu sehen sind Bürogebäude der Oberbaum City in Berlin Friedrichshain.
Im nächsten Schritt kann man die Bilder relativ zueinander verschieben, damit sie genau übereinander liegen. Trotz Stativ kann es zu mehreren Pixeln Abweichung kommen. Danach wird das HDR erstellt. qtpfsgui speichert HDRs in den Formaten OpenEXR, RadianceRGBE, HDR TIFF und PFS Stream.
Zum Export eines JPEGs muss man aus dem HDR durch Tone Mapping wieder in ein “normales” Bild umwandeln. Dafür bietet qtpfsgui viele Algorithmen die zu ganz unterschiedlichen Effekten führen, einige davon sind hier beschrieben. Die Anleitung für qtpfsgui findet sich hier. Viel mehr Bilder, die mit qtpfsgui erstellt wurden finden sich in einer qtpfsgui Flickr Gruppe.

Neu in Compiz Fusion: Mit dem shift switcher kann man alle offenen Fenster auf dem Desktop “durchbättern”.

Compiz Fusion ist ein Window Manager für den Linux Desktop mit 3D Funktionen, unter anderem:

• Desktop Cube: Die virtuellen Desktops werden beim Umschalten auf einem Würfel dargestellt.
• Wobbly: Beim Verschieben bewegen sich die Fenster als wären sie elastisch.
• Expo: Alle virtuellen Desktops werden nebeneinander dargestellt. Fenster lassen sich in der Ansicht verschieben.
  
• Scale: Alle Fenster werden skaliert nebeneinander dargestellt. Ein Klick auf ein Fenster beendet die Ansicht und zeigt das gewählte Fenster im Vordergrund.
  

Alle Funktionen von finden sich hier. Compiz Fusion ist Teil von Ubuntu 7.10 und vielen anderen Linux Distributionen. Voraussetzung ist eine Grafikkarte mit 3D Unterstützung unter Linux.

Eindrucksvoller als Screenshots ist ein Video:

Logging ist wichtig. Trotzdem spricht vieles gegen zu viel Logging in Anwendungen:

• Logging ist für die Funktion einer Anwendung unnötig.
• Logging macht den Quellcode unübersichtlich.
• Logging beeinträchtigt die Performance.

Alle diese Nachteile lassen sich vermeiden und trotzdem kann der Aufruf jeder Methode incl. Parameter und Rückgabewerte und die Laufzeit geloggt werden. Möglich machen dies Spring und Aspektorientierte Programmierung (AOP).

Eine Klasse übernimt das Logging der Methodenaufrufe, die andere das Laufzeitlogging:

Methodenlogger:
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
public class MethodenLogger {
private static final Log LOG = LogFactory.getLog( MethodenLogger.class );
public void logMethodEntry( final JoinPoint joinPoint ) {
if( LOG.isDebugEnabled() ) {
final String targetClassName = joinPoint.getTarget().getClass().getName();
final Log targetLog = LogFactory.getLog( targetClassName );
if( targetLog.isDebugEnabled() ) {
final Object[] args = joinPoint.getArgs();
final String name = joinPoint.getSignature().toLongString();
final StringBuffer sb = new StringBuffer( name + ” called with: [" );
for( int i = 0; i < args.length; i++ ){
final Object o = args[ i ];
sb.append( o );
sb.append( ( i == args.length - 1 ) ? ”]” : ”, ” );
}
LOG.debug( sb );
}
}
}
public void logMethodExit( final JoinPoint joinPoint, final Object result ) {
if( LOG.isDebugEnabled() ) {
final String targetClassName = joinPoint.getTarget().getClass().getName();
final Log targetLog = LogFactory.getLog( targetClassName );
if( targetLog.isDebugEnabled() ) {
final String name = joinPoint.getSignature().toLongString();
LOG.debug( name + ” returning: [" + result + "]“ );
}
}
}
}

Laufzeitlogger:
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.core.Ordered;
import org.springframework.util.StopWatch;
public class LaufzeitLogger {
private static final Log LOG = LogFactory.getLog( LaufzeitLogger.class );
// this method is the around advice
public Object loggeLaufzeit( final ProceedingJoinPoint call ) throws Throwable {
Object returnValue;
if( LOG.isDebugEnabled() ) {
final String targetClassName = call.getTarget().getClass().getName();
final String targetMethodName = call.getSignature().getName();
final Log targetLog = LogFactory.getLog( targetClassName );
if( targetLog.isDebugEnabled() ) {
final StopWatch clock = new StopWatch( getClass().getName() );
try {
clock.start( call.toShortString() );
returnValue = call.proceed();
}
finally {
clock.stop();
final StringBuffer sb = new StringBuffer( ”Laufzeit ” );
sb.append( targetMethodName ).append( ”: ” );
sb.append( Hilfsmethoden.erzeugeLesbareDauer( clock.getTotalTimeMillis() ) );
targetLog.debug( sb.toString() );
}
}
else {
returnValue = call.proceed();
}
}
else {
returnValue = call.proceed();
}
return returnValue;
}
}

Wie aber werden die Methoden loggeLaufzeit, logMethodEntry und logMethodExit aufgerufen? Die Spring Beans werden so konfiguriert, dass beim Aufruf jeder beliebigen Methoden in den Beans die Logger benutzt werden können. Die Konfiguration erfolgt deklarativ in der Spring XML Definition der Beans:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns:aop=”http://www…org/schema/aop”
xmlns:tx=”http://www…org/schema/tx”
xsi:schemaLocation=”
http://www…org/schema/beans http://www…org/schema/beans/spring-beans-2.0.xsd
http://www…org/schema/tx http://www…org/schema/tx/spring-tx-2.0.xsd
http://www…org/schema/aop http://www…org/schema/aop/spring-aop-2.0.xsd”>

</aop:config>
</beans>

In den Parametern expression der aop:pointcut Elemente wird definiert welche Methoden geloggt werden. Geloggt wird nur, wenn auch die log4j Einstellungen entsprechend gesetzt sind. Das Loglevel des LaufzeitLogger bzw. MethodenLogger und der Klasse, die die Methode enthält muss auf DEBUG gestellt sein.

Der deklarative Ansatz hat den Vorteil, das durch das Entfernen der Konfiguration oben, das Logging aus der Anwendung “verschwindet”. Es gibt dann kein Beeinträchtigung der Laufzeit mehr durch das Logging. Durch die Auslagerung in Aspekte, bleibt die Anwendung frei von Logging-Statements. Der Code ist übersichtlich und enthält nur den funktionalen Teil.

Hier ein Auszug aus dem Logfile:

DEBUG [aop.MethodenLogger]
public Code hibernate.CodeDao.sucheCode(java.lang.String,java.lang.String) called with: [JOB_STATUS, NEU]
DEBUG [aop.MethodenLogger]
public Code hibernate.CodeDao.sucheCode(java.lang.String,java.lang.String) returning: [hibernate.entities.Code@110278e]
DEBUG [hibernate.CodeDao] Laufzeit sucheCode: 45ms

Dokumentation:

• Aspect Oriented Programming with Spring
• POJO Aspects in Spring 2.0: A Simple Example

Es gibt ein Python Modul für den Zugriff auf den MS Sqlserver: pymssql. Hier ein Skript, das die Id und ein Datum aus einer Tabelle selektiert und ausgibt:

con = pymssql.connect(host=”hostname,user=’name’,password=’kennwort’,database=’dbname’)
cur = con.cursor()
query=”select id,datum from tabelle where datum>=\’” + von + “\’ and ts_insert<=\’” + bis + “\’”
cur.execute(query)
for row in cur.fetchall():
  id = row[0]
  datum = row[1]
  print Id + ” vom ” + str(datum.day) + “.” + str(datum.month) + “.” + str(datum.year) + ” um ” + str(datum.hour) + “:” + str(datum.minute) + “:” + str(datum.second)
con.commit()
con.close()

Ich benutze das Modul zur einfachen Auswertung von Cronjobs, die jede Nacht laufen und Fehler in einer Datenbanktabelle protokollieren.

Axis 1 benutzt log4j. Um Soap Nachrichten zu Loggen müssen 2 Logger auf das Level DEBUG gestellt werden, je nachdem ob mit Axis ein Client oder ein Service implementiert ist:

• Axis als Client:
  <logger name="org.apache.axis.transport.http.HTTPSender">
<level value=”DEBUG”/>
</logger>
• Axis als Service:
  <logger name="org.apache.axis.providers.java.RPCProvider">
<level value=”DEBUG”/>
</logger>

Geloggt wird danach der XML Code der SOAP Nachrichten.

Ubuntu ist da - Dell hats bemerkt und bietet jetzt auch in Deutschland Pcs und Notebooks mit vorinstalliertem Linux an. Auf der Einstiegsseite wird der Kunde aber gewarnt:

Sie sind nicht sicher, ob Open Source das Richtige für Sie ist?

und ggf. zu den Windows Rechnern geleitet.
Auch Lenovo hat sich entschlossen Notebooks mit Linux auszuliefern. Ich selber habe ein ThinkPad T60 und Ubuntu und kann es allen empfehlen. Bei xtops.DE gibt es ThinkPads mit vorinstalliertem Linux und persönlicher Beratung.

XMLBeans ist eine Open Source API zum Auslesen und Erzeugen von XML Dateien, die in einem XML Schema beschrieben sind. XMLBeans generiert Java Klassen aus dem Schema mit denen man Dateien bearbeiten kann.

Zum Generieren enthält XMLBeans das Kommandozeilenwerkzeug scomp. Der Aufruf

scomp -out abruf.xsd.jar -src ./src ./abruf.xsd

generiert aus dem Schema abruf.xsd Klassen und packt sie in ein Jar. Der Quellcode der Klassen kann durch den Parameter -src in ein Verzeichnis gespeichert werden.
Das Lesen von Daten aus einer Datei ist einfach. Für jedes Element aus dem Schema gibt es Getter und Setter:

VertragDocument vertragXml = VertragDocument.Factory.parse( xmlDatei );
String vertragNummer = vertragXml.getVertrag().getAbruf().getKopfdaten().getVertragsnummer();

liest das Element Vertragsnummer aus einer Datei.
Gespeichert werden Dateien durch Aufruf von:

StammdatenDocument doc = …
…
XmlOptions opts = new XmlOptions();
opts.setSavePrettyPrint();
opts.setSavePrettyPrintIndent(4);
opts.setCharacterEncoding(”UTF-8″);
opts.setDocumentType(doc.schemaType());
PrintStream destStream = new PrintStream(new FileOutputStream(dateiName), false, “UTF-8″);
doc.save(destStream,opts);
destStream.close();

Durch XMLBeans ist das Bearbeiten einer XML-Datei so einfach wie das Erzeugen eines einfachen Java-Bean. Wenn sich das Schema einmal ändert, muss nur neu generieren. In der IDE bemerkt man sofort die Stellen im Code, die man anpassen muss.