Christoph Kiehl » Java http://www.christophkiehl.com Software Development - Java - Open Source Mon, 25 Aug 2008 14:07:58 +0000 http://wordpress.org/?v=2.8.4 en hourly 1 Book Review: Wicket In Action http://www.christophkiehl.com/book-review-wicket-in-action http://www.christophkiehl.com/book-review-wicket-in-action#comments Mon, 25 Aug 2008 13:31:46 +0000 Chris Kiehl http://www.christophkiehl.com/?p=16 Alright here is the short summary: Martijn and Eelco have done an amazing job writing a comprehensive yet easy to read book, that covers pretty much every aspect of Wicket and is more than recommended for everyone who wants to get started with Wicket.

Starting with the introduction they give you a good idea what Wicket is and how it came into life. It outlines a lot of the reasons why Model 2 web frameworks suck and how Wicket does a better job. This already got me hooked because it’s always nice to read about different approaches.

Wicket Architecture

After explaining the wicket architecture they introduce the first sample application which is … no, not another pet store … a cheese store ;) But as you continue reading you will find that their writing is not cheesy at all. They’ve got a fresh style of writing which is not too boring but still delivers all the technical details you need, to thoroughly understand what’s going on.

The first two chapters of part 2 of the book go into detail about Wicket’s core elements: Models and Components. Understanding those and how they interact is the cornerstone of understanding Wicket.
But to really fill your models and components with life, you will need to interact with your user and fill your application with data. Explaining how to process user input using forms including validation and what different layout concepts Wicket has to offer is covered by the next two chapters.

Advanced Topics

So what’s next? I already gained the knowledge to write my basic Wicket application, but there are still some advanced topics to cover:

  • Developing reusable components
  • Images, CSS and scripts: working with resources
  • Rich components and AJAX

If you ever build a bigger web application you’ll realize quickly that there are some topics left to explain. Does Wicket provide means of authentication and authorization? How does i18n work? Oh, and I want my application to integrate with Spring and Hibernate! And how do I test my wicked Wicket application?
Fortunately all those questions and more are answered in the last part of the book called “Preparing for the real world”.

Awesome Book

Martijn and Eelco do a great job getting you up to speed with Wicket. But it’s not only about getting through those sample applications. What I love about the book is that it actually provides hands on instructions for real world applications which is often missing from such books. It’s probably due to the fact that they are both members of the core Wicket team and use Wicket on a daily basis. They are not another example of those authors that just decide that they are going to write a book about a topic, and then do the tutorials and hang around on the mailing lists to gather just enough information to fill a book.

To summarize: Well done! I wish this book was available about a year ago, when one of my colleagues tried to build his first Wicket application!

If you are thinking of buying the book, you should buy it now as they offer a 35% discount until the end of August.

]]> http://www.christophkiehl.com/book-review-wicket-in-action/feed 1 Performance Tuning: Object Creation Overhead http://www.christophkiehl.com/performance-tuning-object-creation-overhead http://www.christophkiehl.com/performance-tuning-object-creation-overhead#comments Sat, 01 Dec 2007 17:53:41 +0000 christoph http://www.christophkiehl.com/performance-tuning-object-creation-overhead While working on a Jackrabbit issue I came across a method that is called about a million times for certain requests. In this method an ArrayList instance and a few Integer instances were created on each call to eventually build up a list of ints. I thought I might give it a try and use an int array instead – lo and behold! That gave me an overall performance gain of about 40%.

I wrote this little test code to show the difference:

import java.util.ArrayList;
import java.util.List;


public class ArrayPerformance {

    private static final int LOOP_COUNT = 10000000;
    private static final int ARRAY_SIZE = 10;

    private static void buildArrayList() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < LOOP_COUNT; i++) {
            List values = new ArrayList(ARRAY_SIZE);
            for (int j = 0; j < ARRAY_SIZE; j++) {
                values.add(Integer.valueOf(j));
            }
        }
        long end = System.currentTimeMillis();
        printTime(start, end, "ArrayList");
    }
   
    private static void buildArray() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < LOOP_COUNT; i++) {
            int[] values = new int[ARRAY_SIZE];
            for (int j = 0; j < ARRAY_SIZE; j++) {
                values[j] = j;
            }
        }
        long end = System.currentTimeMillis();
        printTime(start, end, "array");
    }

    private static void printTime(long start, long end, String label) {
        System.out.printf("%-10s: %5dms\n", new Object[]{label, Long.valueOf(end-start)});
    }
   
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            buildArray();
            buildArrayList();
        }
    }
   
}

The resulting output was this:

array     :   475ms

ArrayList :  1200ms

array     :   353ms

ArrayList :  1158ms

array     :   337ms

ArrayList :   921ms

array     :   341ms

ArrayList :   921ms

array     :   341ms

ArrayList :   918ms

Which shows that after some warming up the variant using an ArrayList with Integers to build up a list of ints is roughly about 3 times slower than using a plain int array.

What do I learn from this?

If you know about code sections in your code base which are called millions of times make sure you try to find a solution without creating short living object instances, because even if the current JVM is quite fast creating and collection object instances, it still eats some CPU.
This might lead to solutions that are not object oriented anymore, but this is a small drawback if it gives a performance critical part of your application a speedup.

Another thing is that using natives like ints or longs is always preferable over Integer or Long objects for performance critical code. Lucene for example uses natives a lot to get the best performing code.

]]> http://www.christophkiehl.com/performance-tuning-object-creation-overhead/feed 0 Suns Troubleshooting Guide for Java http://www.christophkiehl.com/suns-troubleshooting-guide-for-java http://www.christophkiehl.com/suns-troubleshooting-guide-for-java#comments Mon, 17 Sep 2007 10:31:22 +0000 christoph http://www.christophkiehl.com/?p=13 Suns Troubleshooting Guide for Java provides a nice overview of available tools to analyze and monitor Java processes. I would guess that a lot of Java developers doesn’t know them.

I recently had to identify a performance problem on one of our production servers. The application appeared to hang every few seconds and then continue normal operation. Using jstat I quickly discovered that there were a lot of objects created just to be garbage collected right after. This was the output of jstat:

S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT    LGCC                 GCC

0,00   0,00 100,00 100,00  89,75  10546  726,162  1192 12922,944 13649,106 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,44  10546  726,162  1192 12922,944 13649,106 Allocation Failure   unknown GCCause

0,00   0,00  21,93 100,00  89,47  10546  726,162  1192 12934,808 13660,970 unknown GCCause      No GC

0,00   0,00  32,41 100,00  89,48  10546  726,162  1192 12934,808 13660,970 unknown GCCause      No GC

0,00   0,00  42,44 100,00  89,48  10546  726,162  1192 12934,808 13660,970 unknown GCCause      No GC

S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT    LGCC                 GCC

0,00   0,00  56,79 100,00  89,48  10546  726,162  1192 12934,808 13660,970 unknown GCCause      No GC

0,00   0,00  68,61 100,00  89,48  10546  726,162  1192 12934,808 13660,970 unknown GCCause      No GC

0,00   0,00  78,02 100,00  89,48  10546  726,162  1192 12934,808 13660,970 unknown GCCause      No GC

0,00   0,00  88,74 100,00  89,48  10546  726,162  1192 12934,808 13660,970 unknown GCCause      No GC

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT    LGCC                 GCC

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT    LGCC                 GCC

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT    LGCC                 GCC

0,00   0,00 100,00 100,00  89,48  10546  726,162  1193 12934,808 13660,970 Allocation Failure   unknown GCCause

0,00   0,00  24,36 100,00  89,51  10546  726,162  1193 12946,347 13672,509 unknown GCCause      No GC

The “E” column denotes percent of Eden space used. In the time where this value is 100% the application doesn’t respond until the garbage collection took place.

Using jstack I was able to find out what the server was doing while inflating the heap.

All this was done on a server running in production without using any additional profilers!

Another nice feature is the -XX:+HeapDumpOnOutOfMemoryError option mentioned in section 3.3.3.4 of the guide. I always set this option for production servers. This way you always have a memory dump available to analyze, even if the support team only restarted the application without taking a heap dump.

Or take jmap for example. You can not only get some heap statistics but also generate a heap dump while the application is running.

So make sure you know about the tools available as they might become useful if your application ever gets into trouble ;)

]]> http://www.christophkiehl.com/suns-troubleshooting-guide-for-java/feed 4 Automatically create releases and maintenance branches with Maven http://www.christophkiehl.com/automatically-create-releases-and-maintenance-branches-with-maven http://www.christophkiehl.com/automatically-create-releases-and-maintenance-branches-with-maven#comments Mon, 16 Jul 2007 22:43:05 +0000 christoph http://www.christophkiehl.com/?p=12 First of all you need version at least 2.0-beta-6 of the Maven Release Plugin if you want the branching feature. I just deleted the <home>/.m2/repository/org/apache/maven/plugins/maven-release-plugin folder to get Maven to download the latest version. If you never used the release plugin before it will download the latest version anyway.

Now let’s say you’ve got version 1.0.0-SNAPSHOT of your artifact and you want to cut a release: the normal procedure would be to run

mvn release:prepare release:perform

To get this running you need two prerequisites in you pom.xml:

  1. a scm section
  2. a distributionManagement section

Those might look like this:

<scm>
  <connection>scm:svn:http://<yourhost>/release-test/trunk/</connection>
  <developerConnection>scm:svn:http://<yourhost>/release-test/trunk/</developerConnection>
</scm>

<distributionManagement>
  <repository>
    <id>repo</id>
    <name>Local Repo</name>
    <url>file:///c:/tmp/repo</url>
  </repository>
</distributionManagement>

From now on I assume that your project name is release-test. You also need to make sure that there is a folder http://<yourhost>/release-test/tags in your repo. Maven needs this folder to tag the released version unless you told Maven otherwise.

Assure that everything is checked in and you’ve got no changes in your checked out copy. If you now call

mvn release:prepare release:perform

and accept 1.0.1-SNAPSHOT as the next development version Maven will nicely build your application, tag the sources in svn and modify your pom.xml to reflect the next development version. This is already quite cool and saves a lot of time. But …

… I like to create maintenance branches after such a release. So I would choose 1.1.0-SNAPSHOT as the next development version and create a branch containing a 1.0.1-SNAPSHOT version derived from the 1.0.0 Release. Creating branches and modifying pom.xmls is quite tedious (unless you wrote yourself a script to do the stupid work). This is where the release plugins new branch feature comes into play.

Before I create my 1.0.0 release I create a 1.0.x branch with Maven. Just make sure you’ve got a http://<yourhost>/release-test/branches folder in your repository. Now call

mvn release:branch -DbranchName=1.0.x

Maven will ask you for the new working copy version. Enter 1.1.0-SNAPSHOT as this will be our new bleeding edge development version. Maven now creates a branch at http://<yourhost>/release-test/branches/1.0.x which contains a pom.xml with version 1.0.0-SNAPSHOT and modifies the version in your trunks pom.xml to be 1.1.0-SNAPSHOT.

To finally cut your 1.0.0 release you have to checked out your branch http://<yourhost>/release-test/branches/1.0.x and do the usual

mvn release:prepare release:perform

which will suggest the correct version numbers. Subsequent maintenance release are created of this branch in the same fashion.

This got a bit longer than I thought ;) If you’ve got any questions – ask. I’ll be more than happy to go into further detail if needed

]]> http://www.christophkiehl.com/automatically-create-releases-and-maintenance-branches-with-maven/feed 2 Easy way to display your apps version number using Maven http://www.christophkiehl.com/easy-way-to-display-your-apps-version-using-maven-and-manifest http://www.christophkiehl.com/easy-way-to-display-your-apps-version-using-maven-and-manifest#comments Wed, 30 May 2007 21:47:17 +0000 christoph http://www.christophkiehl.com/?p=4 Recently I wanted to print our apps version number to the log file. Since I’m using Maven and the Maven Release Plugin to create releases of our app I was looking for an easy way to incorporate the version in the pom.xml into the release and display it.

Fortunately Maven already provides a hook to have the version number written to a jars MANIFEST.MF. I simply added the following snippet to my pom.xml:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <configuration>
        <archive>
          <manifest>
            <mainClass>test.App</mainClass>
            <addDefaultImplementationEntries>
              true
            </addDefaultImplementationEntries>
          </manifest>
        </archive>
      </configuration>
    </plugin>
  </plugins>
</build>

The important part is addDefaultImplementationEntries. This instructs Maven to add the following headers to the MANIFEST.MF of your jar:

Implementation-Title: display-version Implementation-Version: 1.0-SNAPSHOT Implementation-Vendor-Id: test

Now you can use this line of code to access the version number:

App.class.getPackage().getImplementationVersion()

where “App” is just any class in your jar.

In defiance of all those Maven haters out there thing are sometimes just that easy with Maven ;)

]]> http://www.christophkiehl.com/easy-way-to-display-your-apps-version-using-maven-and-manifest/feed 1