Category Archives: java

die programmiersprache und was noch dazu gehört

Spring Boot running in 2 min

Spring Boot 1.0.1 is released. I wanted to find the fastest way to get a spring boot app running. The usual “Hello world” was created and running in around 2 minutes. For the creation of the initial project files I used lazybones. The project template uses gradle as build tool. So I had to install gradle too. And the easiest way to install lazybones and gradle is gvm.

Install gvm:

curl -s get.gvmtool.net | bash
source "//.gvm/bin/gvm-init.sh"

Install gradle and lazybones:

gvm install gradle
gvm install lazybones

Create a project with the name “mycrm” with the template “spring-boot-actuator”:

lazybones create spring-boot-actuator mycrm

Change into project directory and build the runable jar:

cd mycrm
gradle bootRepackage

Run the application:

java -jar build/libs/spring-boot-sample-actuator-1.0.0.jar &

Get the hello world 🙂

wget -O - localhost:8080 | less

Done.

 

running all tests of vert.x on a gentoo box

so after setting up the dev environment (btw. IDEA setup was much smoother) I wants to run all tests via

$./mk test

After getting errors like:

Exception in Ruby verticle: no such file to load -- rubygems

or
Exception in Ruby verticle: no such file to load -- json

I figured out that I have to install ruby and jruby properly on my Gentoo box. In short, run the following commands:

$sudo emerge -va dev-java/jruby dev-ruby/rubygems dev-lang/ruby
$sudo eselect ruby set ruby19
$sudo jruby -S gem install json

and add the following lines to your ~/.bashrc

...
export JRUBY_HOME=/usr/share/jruby
export RUBY_HOME=/usr/lib64/ruby/1.9.1
...

Don’t forget

$source ~/.bashrc

I used

$equery files jruby

and
$equery files ruby

to find the right directories.

Result:

$~/mk test

...

Information: Starting test: test_echo_binary

:test

BUILD SUCCESSFUL

Total time: 2 mins 19.355 secs

vert.x, the new gradle build and Eclipse 4.2

Developing vert.x with Eclipse 4.2:

  1. Fork the vert.x repo at github (help) and clone it to your local machine (let’s say to /tmp/vert.x )
  2. change directory cd /tmp/vert.x und run ./mk eclipse
  3. Install Gradle 1.0 / Java SDK 7 / Eclipse 4.2 (Eclipse Classic)
  4. Optional Install Grovvy Eclipse Plugin
  5. Start Eclipse and import  every project (I can’t find a solution to import all at once.)
    1. Import…
    2. Existing Projects into Workspace
    3. Select root directory
      1. /tmp/vert.x
    4. Finish
    5. Import…
    6. Existing Projects into Workspace
      1. /tmp/vert.x/vertx-boot
    7. Finish
  6. Seclect Project vert.x
    1. Right click
    2. Team -> Share Project
    3. Git
    4. Next, Finish
  7. Project -> Clean -> Clean all Projects
  8. Happy Hacking

I read about gradle support in SpringSource STS but I did not tried it.

java.io.NotSerializableException – but where is the field?

To enable more informations about “java.io.NotSerializableException” just add the “-Dsun.io.serialization.extendedDebugInfo=true” VM argument to your run configuration.

Example: java -Dsun.io.serialization.extendedDebugInfo=true -jar your.jar

Without extendedDebugInfo:

Exception in thread "main" java.io.NotSerializableException: net.nautsch.addressbook.Country
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1164)
        at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1518)
        at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1483)
        at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1400)
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158)
        at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1518)
        at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1483)
        at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1400)
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158)
        at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:330)
        at net.nautsch.addressbook.App.main(App.java:33)

and with:

Exception in thread "main" java.io.NotSerializableException: net.nautsch.addressbook.Country
        - field (class "net.nautsch.addressbook.Address", name: "country", type: "class net.nautsch.addressbook.Country")
        - object (class "net.nautsch.addressbook.Address", net.nautsch.addressbook.Address@13caecd)
        - field (class "net.nautsch.addressbook.Person", name: "address", type: "class net.nautsch.addressbook.Address")
        - root object (class "net.nautsch.addressbook.Person", net.nautsch.addressbook.Person@158b649)
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1161)
        at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1518)
        at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1483)
        at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1400)
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158)
        at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1518)
        at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1483)
        at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1400)
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1158)
        at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:330)
        at net.nautsch.addressbook.App.main(App.java:33)

Gesetz von Demeter, Unit Tests und der zweite Programmierer

In meinem letzten Post habe ich beschrieben, das Delegation für den Benutzer einer Klasse angenehm ist und das wir dies auch im realen Leben schätzen. Heute möchte ich kurz beschreiben wie sich das Einhalten des Gesetzes von Demeter auf das Schreiben von Unit-Tests und das Benutzen meiner Implementierungen auswirkt. Dazu habe ich das Modell um Implementierungen erweitert:

lod overview 1

Continue reading

Gesetz von Demeter im Alltag

In den letzten zwei Monaten hatte ich im Umfeld der Software-Entwicklung sehr viel dieser “AHA”-Effekte. Da das Gehirn neue Erkenntnisse mit dem Ausschütten von Glückshormonen belohnt, war es eine sehr gute Zeit für mich. 🙂

Als heute  morgen alle noch bei Kaffee in unserem Pausenraum sassen, habe ich ein speziellen Teil unseres Domain Modells an die dort hängende Tafel gemalt. Ich wollte allen mitteilen, auf welch schönes Design wir gestern für einen Teil unseres Domain Modells gekommen waren. Insbesondere wollte ich auch aufzeigen, wie elegant eine Lösung werden kann, wenn man sich an das Gesetzt von Demeter hält. Dabei haben Jan und ich nicht mal an das Gesetz gedacht, als wir die Schnittstellen definiert haben. Es ist sozusagen “einfach entstanden”.

Hier ein leicht abgeändertes Beispiel:

lod 1

Continue reading

Spring Greenpages mit Teneo

Beim SpringSource® dm Server™ ist ein Beispiel dabei, welches Greenpages heisst. Vor ein paar Wochen durfte ich auf Arbeit mal ausprobieren, ob Teneo mit dem dm-Server läuft. Also habe ich mir das Beispiel von SpringSource geschnappt und die Sache angeschaut.

Es hat funktioniert!

Leider habe ich erst heute Zeit gefunden, den Source auf bitbucket zu stellen. Es hat noch hässliche Sachen drin.  Mir ist es in der Klasse TeneoDirectory zum Beispiel nicht gelungen, die Transaktionen deklartiv einzubauen. Ich hole jetzt von der EntityManagerFactory einen EntityManager und von dort die Transaktion. Anders habe ich es einfach nicht hinbekommen… und irgendwann war die Zeit zu Ende.

Wenn jemand eine andere Lösung hat, bitte unbedingt melden.

Netbeans, Ivy und Spring 3.0.0M4

Ich programmiere gerade eine kleine Web-Applikation und möchte dazu die neuen REST-Features vom Spring-Framework benutzen. Bis gestern habe ich mir dazu in Netbeans ein Webprojekt gebaut und dann ganz artig alle notwendigen Bibos von Hand dem Projekt hinzugefügt. Gestern wurde nun der Milestone 4 von Spring 3.0.0 veröffentlicht und ich wollte mir nicht noch einmal die Arbeit machen.
Continue reading

Dokumentation von Java Source Code

Heute hatte ich eine Diskussion über die Art und Weise wie man in Java dokumentiert.  Was sind gute Kommentare? Was muss dokumentiert werden? Was kann man weglassen?

Ich finde zu diesem Thema die Meinungen von Robert C. Martin gut, die er in seinem Buch Clean Code: A Handbook of Agile Software Craftmanship. Prentice Hall PTR. 2008 unter dem Kapitel 4 “Comments” vertritt.

Ein paar Auszüge:

Seite 63:

It is just plain silly to have a rule that says that every function must have a javadoc, or every variable must have a comment. Comments like this just clutter up the code, propagate lies, and lend to general confusion and disorganisation.

Seite 64f.:

And then there’s this paragon of redundancy:

/**
 * Returns the day of the month.
 *
 * @return the day of the month.
 */
 public int getDayOfMonth() {
    return dayOfMonth;
 }

Seite 71:

As useful as javadocs are for public API’s, they are anathema to code that is not intended for public consumption.

Auch wenn ich hier Auszüge aus dem Kapitel “Bad Comments” bringe, so halte ich Kommentare und Dokumentation zum Job eines Softwareentwicklers. Öffentliche Methoden müssen eine nützliche Dokumentation haben (Bitte aber nicht wie in getDayOfMonth 😉 ). Auch macht man sich oder seinen “Nachfolgern” oft das Leben wesentlich leichter seine Intention zu erklären, warum etwas genau so und nicht anders gemacht hat. Alles im Buch beschriebene möchte ich nicht hier wiedergeben. Einfach lesen.

Da aber Softwareentwicklung in den meisten Fällen im Team erfolgt, sollte man sich aber auf Regeln einigen und diese dann auch einhalten.

Militaristen bei Spring Source?

“Battling complexity?”, “Choose your weapon:” “Weapons for the War on …” – Diese Aussprüche habe ich gerade auf der Seite von Spring Source gefunden. Ich dachte bisher es ginge um Java (Spring Framework, und seit Kurzem auch Groovy und Grails). Jetzt habe ich aber das Gefühl in den Krieg ziehen zu müssen. Was soll der Quatsch? Die haben offensichtlich den falschen Mann fürs Marketing eingekauft. Zumindest für meinen Geschmack…

statisch vs. new performance

Heute hatten wir eine Diskussion darüber, ob auf einen Wert via einem statischen Klassenmember oder über einen Getter zugegriffen werden soll oder ob es sogar egal ist wenn man jedes Mal eine neue Instanz erzeugt. Jetzt hat es mich gejuckt, mal einfach ein kleines Beispiel zu machen. Mir ist klar, dass entscheidend ist, wie teuer das erzeugen des Objektes ist. Aber hier sind einfach mal die Zahlen vom Beispiel um ein Gefühl zu bekommen:

count: 10
static  msec: 0
get     msec: 0
new     msec: 0
count: 100
static  msec: 0
get     msec: 0
new     msec: 0
count: 1000
static  msec: 0
get     msec: 0
new     msec: 2
count: 10000
static  msec: 4
get     msec: 1
new     msec: 16
count: 100000
static  msec: 1
get     msec: 1
new     msec: 32
count: 1000000
static  msec: 0
get     msec: 0
new     msec: 224
count: 10000000
static  msec: 0
get     msec: 0
new     msec: 1848
count: 100000000
static  msec: 0
get     msec: 0
new     msec: 19029

Und hier noch das Beispiel:

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class Main {

    private static final Person PERSON = new Person();
    private static long timestamp;

    public static void main(String[] args) {
        int count = 10;
        for(int i = 1; i < 9; i++){
            System.out.println("count: " + count);
            iterate(count);
            count *= 10;
        }
    }

    private static void iterate(int count){
        timestamp = System.currentTimeMillis();
        iterateStatic(count);
        out("static ");
        timestamp = System.currentTimeMillis();
        iterateGetter(count);
        out("get    ");
        timestamp = System.currentTimeMillis();
        iterateNew(count);
        out("new    ");
    }

    private static Person getPerson(){
        return PERSON;
    }
    
    private static void iterateStatic(int count){
        for(int i = 0; i < count; i++){
            Person person = PERSON;
            person.blub();
        }
    }
    private static void iterateNew(int count){
        for(int i = 0; i < count; i++){
            Person person = new Person();
            person.blub();
        }
    }
    private static void iterateGetter(int count){
        for(int i = 0; i < count; i++){
            Person person = getPerson();
            person.blub();
        }
    }
    private static void out(String s){
        System.out.println(s + " msec: " + (System.currentTimeMillis()-timestamp));
    }
}

class Person {

    private Map<?, ?> aMap = new HashMap<String, Object>();
    private Set<?> aSet = new HashSet<String>();

    public Person() {
    }

    void blub(){
    }
}

Class von “Type Parameter” – Java Generics (gepimpt)

Meine Lösung von gestern funktioniert nicht, wenn die Klassenhierarchy tiefer als Eins ist. Die Methode getGenericSuperclass() liefert eben nur die Superklasse der aktuellen Klasse. Es ist also noch notwendig die Hierarchie nach Dada zu suchen um die Typinformation zu bekommen:

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Parameterized {
    public static void main(String[] args) {
        new SubDada();
        new SubSubDada();
    }
}

abstract class Dada<T> {
    private Class<T> typeOfT;
    public Dada() {
        this.typeOfT = getTypeOfT();
        System.out.println("typeOfT: " + this.typeOfT);
    }
    @SuppressWarnings("unchecked")
    private Class<T> getTypeOfT() {
        ParameterizedType pType = getDadaAsParameterizedType(getClass());
        return (Class<T>) pType.getActualTypeArguments()[0];
    }
    private ParameterizedType getDadaAsParameterizedType(Class<?> clazz) {
        Object gstype = clazz.getGenericSuperclass();
        if (gstype instanceof ParameterizedType) {
            ParameterizedType ptype = (ParameterizedType) gstype;
            Type rawtype = ptype.getRawType();
            if (Dada.class.equals(rawtype)) {
                return ptype;
            }
        }
        return getDadaAsParameterizedType(clazz.getSuperclass());
    }
}

class SubDada extends Dada<String> {
    public SubDada() {
    }
}

class SubSubDada extends SubDada {
    public SubSubDada() {
    }
}

Class von “Type Parameter” – Java Generics

Wie finde ich zur Laufzeit heraus von welchem Typ ein “Type Parameter” ist?

Hier die Lösung:

1
2
3
4
5
6
7
8
9
10
11
12
public class Dada<T> {
 
    private Class<T> typeOfT;
 
    @SuppressWarnings("unchecked")
    public Dada() {
        this.typeOfT = (Class<T>)
                ((ParameterizedType)getClass()
                .getGenericSuperclass())
                .getActualTypeArguments()[0];
    }
...

Die FAQ zu Java Generics bei Angelika Langer finde ich wirklich gelungen.

Hibernate EventListeners in Spring konfigurieren

Wer in Spring Hibernate Event Listener eintragen will macht dies folgendermassen (vergleiche auch Spring Dokumentation Kapitel 12.2.2):

&lt;beans&gt;
  <strong>&lt;bean id="loadListener" class="org.nautsch.MyLoadEventListener" /&gt;</strong>

  &lt;bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"&gt;
    &lt;property name="driverClassName" value="org.hsqldb.jdbcDriver"/&gt;
    &lt;property name="url" value="jdbc:hsqldb:hsql://localhost:9001"/&gt;
    &lt;property name="username" value="sa"/&gt;
    &lt;property name="password" value=""/&gt;
  &lt;/bean&gt;

  &lt;bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"&gt;
    &lt;property name="dataSource" ref="myDataSource"/&gt;
    &lt;property name="mappingResources"&gt;
      &lt;list&gt;
        &lt;value&gt;product.hbm.xml&lt;/value&gt;
      &lt;/list&gt;
    &lt;/property&gt;
    &lt;property name="hibernateProperties"&gt;
      &lt;value&gt;
        hibernate.dialect=org.hibernate.dialect.HSQLDialect
      &lt;/value&gt;
    &lt;/property&gt;
    &lt;property name="eventListeners"&gt;
        &lt;map&gt;
            <strong>&lt;entry key="load"&gt;&lt;ref local="loadListener" /&gt;&lt;/entry&gt;</strong>
        &lt;/map&gt;
    &lt;/property&gt;
  &lt;/bean&gt;

&lt;/beans&gt;

Wer wissen möchte welche Schlüssel es für die EventListener gibt sollte sich mal den Source der Klasse org.hibernate.event.EventListeners anschauen. Dort gibt es einen statischen Block der alle Keys mit den dazugehörigen Typen definiert:

       static {
                eventInterfaceFromType = new HashMap();
 
                eventInterfaceFromType.put("auto-flush", AutoFlushEventListener.class);
                eventInterfaceFromType.put("merge", MergeEventListener.class);
                eventInterfaceFromType.put("create", PersistEventListener.class);
                eventInterfaceFromType.put("create-onflush", PersistEventListener.class);
                eventInterfaceFromType.put("delete", DeleteEventListener.class);
                eventInterfaceFromType.put("dirty-check", DirtyCheckEventListener.class);
                eventInterfaceFromType.put("evict", EvictEventListener.class);
                eventInterfaceFromType.put("flush", FlushEventListener.class);
                eventInterfaceFromType.put("flush-entity", FlushEntityEventListener.class);
                eventInterfaceFromType.put("load", LoadEventListener.class);
                eventInterfaceFromType.put("load-collection", InitializeCollectionEventListener.class);
                eventInterfaceFromType.put("lock", LockEventListener.class);
                eventInterfaceFromType.put("refresh", RefreshEventListener.class);
                eventInterfaceFromType.put("replicate", ReplicateEventListener.class);
                eventInterfaceFromType.put("save-update", SaveOrUpdateEventListener.class);
                eventInterfaceFromType.put("save", SaveOrUpdateEventListener.class);
                eventInterfaceFromType.put("update", SaveOrUpdateEventListener.class);
                eventInterfaceFromType.put("pre-load", PreLoadEventListener.class);
                eventInterfaceFromType.put("pre-update", PreUpdateEventListener.class);
                eventInterfaceFromType.put("pre-delete", PreDeleteEventListener.class);
                eventInterfaceFromType.put("pre-insert", PreInsertEventListener.class);
                eventInterfaceFromType.put("pre-collection-recreate", PreCollectionRecreateEventListener.class);
                eventInterfaceFromType.put("pre-collection-remove", PreCollectionRemoveEventListener.class);
                eventInterfaceFromType.put("pre-collection-update", PreCollectionUpdateEventListener.class);
                eventInterfaceFromType.put("post-load", PostLoadEventListener.class);
                eventInterfaceFromType.put("post-update", PostUpdateEventListener.class);
                eventInterfaceFromType.put("post-delete", PostDeleteEventListener.class);
                eventInterfaceFromType.put("post-insert", PostInsertEventListener.class);
                eventInterfaceFromType.put("post-commit-update", PostUpdateEventListener.class);
                eventInterfaceFromType.put("post-commit-delete", PostDeleteEventListener.class);
                eventInterfaceFromType.put("post-commit-insert", PostInsertEventListener.class);
                eventInterfaceFromType.put("post-collection-recreate", PostCollectionRecreateEventListener.class);
                eventInterfaceFromType.put("post-collection-remove", PostCollectionRemoveEventListener.class);
                eventInterfaceFromType.put("post-collection-update", PostCollectionUpdateEventListener.class);
                eventInterfaceFromType = Collections.unmodifiableMap( eventInterfaceFromType );
        }