Sorry for another non-ruby post, but I’m currently very busy at work playing with JBoss 4, EJB 3, EasyMock, and a bunch of other pretty cool technologies.

I’m a big fan of EasyMock but frequently I ran into problems when code performed lookups to get resources like:

Context ctx = new InitialContext();
UserTransaction trans = (UserTransaction) ctx.lookup("UserTransaction");
trans.begin();

At first it looked like I had to change the code to somehow inject my mock objects. But fortunately there is an easier, more elegant solution.

Java uses an instance of InitialContextFactory to create the InitialContext object. So the solution was to write a mock object for InitialContextFactory and tell Java to use it instead. This mock object must be a ‘real’ class (not one created with EasyMock) that can be found by reflection.

import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.spi.InitialContextFactory;
/**
 * Provides a JNDI initial context factory for the MockContext.
 */
public class MockInitialContextFactory
  implements InitialContextFactory {
    private static Context mockCtx = null;
    public static void setMockContext(Context ctx) {
        mockCtx = ctx;
    }
    public Context getInitialContext(java.util.Hashtable< ?, ?> environment)
      throws NamingException {
        if (mockCtx == null) {
            throw new IllegalStateException("mock context was not set.");
        }
        return mockCtx;
    }
}

To use it for my piece of example code, I have tell Java which InitialContextFactory to use (via java.naming.factory.initial), create a mock Context, create a mock Transaction, tell the mock Context to return the Transaction. And finally tell the mock factory to return the mock Context. This sound much more complex than it actually is, here’s the same in code:

System.setProperty("java.naming.factory.initial", "MockInitialContextFactory");
Context mockCtx = createMock(Context.class);
UserTransaction mockTrans = createMock(UserTransaction.class);
expect(mockCtx.lookup("UserTransaction")).andReturn(mockTrans);
replay(mockCtx);
MockInitialContextFactory.setMockContext(mockCtx);

jboss.org/wiki:
hsqldb is not a production quality database.

I haven’t found a good tutorial, even the JBoss Developer’s Notebook wasn’t exhaustive, so here are my notes:

How to remove the hypersonice db from JBoss

1. Remove datasource:
   delete deploy/hsqldb-ds.xml
2. Add new datasource:
   for MySql add a file named deploy/mysql-ds.xml or whatever you like with something like:

   <datasources>
       <local-tx-datasource>
           <jndi-name>MySqlDS</jndi-name>
           <connection-url>jdbc:mysql://localhost:3306/datasource</connection-url>
           <driver-class>com.mysql.jdbc.Driver</driver-class>
           <user-name>myuser</user-name>
           <password>mypwd</password>
           <exception-sorter-class-name>
               org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter
           </exception-sorter-class-name>
   
           <metadata>
               <type-mapping>mySQL</type-mapping>
           </metadata>
       </local-tx-datasource>
   </datasources>

   You should use MySqlDS as the jndi-name or you have to edit mysql-jdbc2-service.xml later

3. Use new datasource:
   find all references to DefaultDS and replace them with MySqlDS and all references to Hypersonic SQL with mySQL
4. Configure jms:
   delete deploy/jms/hsqldb-jdbc2-service.xml and replace it with doc/examples/jms/mysql-jdbc2-service.xml and don’t forget to edit mysql-jdbc2-service.xml

   Edit the persistence configuration and change the line :-

   SELECT_MAX_TX = SELECT MAX(TXID) FROM (SELECT MAX(TXID) AS TXID FROM JMS_TRANSACTIONS UNION SELECT MAX(TXID) AS TXID FROM JMS_MESSAGES)

   to: -

   SELECT_MAX_TX = SELECT MAX(TXID) FROM JMS_MESSAGES

So it seems like Java is slowly getting more humane

Bloated Exceptionhandling

Why do I have to write so much more code to get a reliable solution? Part of the blame is on Java, because of its verbose exception handling – there is no elegant way of catching 2 or more exceptions[1] without catching Exception or Throwable, which I try to avoid where possible. Ruby has this simple solution compared to the bloated solution in java, especially with EJB where you have to catch half a dozend different exceptions.

begin
  eval string
rescue SyntaxError, NameError => boom
  print "String doesn't compile: " + boom
rescue StandardError => bang
  print "Error running script: " + bang
end

Retry

Repeating whole blocks of code needs too much code, too. Ruby has the retry command, which restarts the current block:

c = 0
for i in 1..100
  tries = 0
  begin
    c = c + 1                 # dummy code
    if c % 4 != 0             # to create
      puts "failed for #{i}"  # a few
      raise "uups"            # exceptions
    end
    puts "action #{i}"
  rescue
    puts "rescue"
    tries = tries + 1
    retry if tries < 3
  end
end

This is just another name for goto, which might be harmful. Actually, I wouldn’t use this solution anyway because there is a better, more reusable way, to achieve the same.

closures

In ruby, it is possible (and very simple) to pass some code to a method. This allows me to create a method which excecutes my code multiple times, if an exceptions occurs:

def try(max_tries = 3)
  tries = 0
  begin
    yield
  rescue
    puts "rescue"
    tries = tries + 1
    retry if tries < max_tries
  end
end

c = 0
for i in 1..100
  try do
    c = c + 1                 # dummy code
    if c % 4 != 0             # to create
      puts "failed for #{i}"  # a few
      raise "uups"            # exceptions
    end
    puts "action #{i}"
  end
end

When I started this article, I just wanted to write a short rant about the missing features for errorhandling in java. While writing, I noticed that Ruby has them. Perhaps that’s the reason why I enjoy programming in ruby so much

[1]to clarify this point just for Jason: In general, there is no elegant way of catching two or more exceptions. If you look at the number of direct subclasses in java.lang.Exception, it is nearly impossible to catch the exceptions you want using a superclass without catching some ‘innocent bystanders’.
I would very much like to see a elegant solution which catches only java.sql.SQLException and java.util.concurrent.TimeoutException, you may use as much OOP and polymorphism as you like. This might not be the fault of the language but the plattform but as I cannot get one without the other, it doesn’t really matter to me. Don’t get me wrong, I think Java is pretty damn good, but there is still a lot of room to improve. And Ruby is showing some of the things which can be done better.

Additionally, the document contains a lot of useful pointers for further reading.

Are there other classes out there (I’m not talking about yet another cool third party jar but about foundation classes) that I haven’t found yet?

This article shows how to use AOP with nothing but java – No code generation or bytecode manipulation.

Sample Scenario:
You want to insert logging statements for every call to every method of a certain class. This sounds like the default example used to promote AOP, but there is an easier solution if you know about java.lang.reflect.Proxy and java.lang.reflect.InvocationHandler.

Let’s take a random interface like

public interface MyInterface {
  public void methodA(int i, String s, String t) throws IOException ;
}

Use a factory to get the Implementation or the proxy and anything you like to switch between using a proxy and not using it.

public class MyInterfaceFactory {
  public static MyInterface getMyInterface()  {
    Object impl = new MyInterfaceImpl();
    String proxySwitch = System.getProperty("myinterface.logging");

    if (proxySwitch == null) {
      return (MyInterface) impl;
    }
    InvocationHandler proxy = new LoggingProxy(impl);
    MyInterface bf2 = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(),
                  new Class[] { MyInterface.class }, proxy);
    return bf2;
  }
}

An implement InvocationHandler to create a LoggingProxy. To keep this example simple, I used System.out.println, use any flavor of logging you like in the real world.

public class LoggingProxy implements InvocationHandler {
  private Object target;
  public LoggingProxy(Object t) {
    target = t;
  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("Method " + method.getName());
    for (int i = 0, l = args.length; i < l; i++) {
      System.out.println("Object[" + i + "] " + args[i].getClass().getName() + " " + args[i]);
    }

      return method.invoke(target, args);
  }
}

This implementation looks like it will work, but it has the slight problem, that it might change the behaviour of your application

Finally Ant 1.6. supports a macrodef target. This article provides a not so short example to see macrodefs in action.

There are three different ways to pass arguments to a macro:

• as an attribute – this is the easiest way and the one you will most likely use the most
• as text content – if you have to pass large amounts of text to your macro, this is probably the way to go
• as element content – if you have to pass complex data or other ant tasks into your macro

And you can combine these ways as you can see in fancy-echo-comb.

<?xml version="1.0"?>
<project name="whatever" default="help" basedir=".">

  <!-- parameter as attribute -->
  <macrodef name="fancy-echo">
    <attribute name="text" default="default value"/>
    <sequential>
      <echo message="by attribute"/>
      <echo message="this is the simple example with parameter @{text}"/>
    </sequential>
  </macrodef>

  <!-- parameter as text content -->
  <macrodef name="fancy-echo-2">
    <text name="text"/>
    <sequential>
      <echo message="by text"/>
      <echo message="@{text}"/>
    </sequential>
  </macrodef>

  <!-- parameter as child element -->
  <macrodef name="fancy-echo-element">
    <element name="content"/>
    <sequential>
      <echo message="by element"/>
      <content/>
    </sequential>
  </macrodef>

  <!-- parameter as text content and attribute-->
  <macrodef name="fancy-echo-comb">
    <attribute name="text-attr" default="default value"/>
    <text name="text"/>
    <sequential>
      <echo message="a combination"/>
      <echo message="text content"/>
      <echo message="@{text}"/>
      <echo message="text attribute"/>
      <echo message="@{text-attr}"/>
    </sequential>
  </macrodef>

  <!-- usage examples -->
  <target name="help" description="print this help">
    <fancy-echo text="some text"/>
    <echo/>
    <fancy-echo/>
    <echo/>
    <fancy-echo-2>use this way for longer text with
with newlines etc.</fancy-echo-2>
    <echo/>
    <fancy-echo-element>
      <content>
        <echo>To pass an ant task into a macro, this is the way to go.</echo>
      </content>
    </fancy-echo-element>
    <echo/>
    <fancy-echo-comb text-attr="and an additional attribute">longer text with
with newlines
etc.</fancy-echo-comb>
  </target>
</project>

prints:

Buildfile: build.xml

help:
     [echo] by attribute
     [echo] this is the simple example with parameter some text

     [echo] by attribute
     [echo] this is the simple example with parameter default value

     [echo] by text
     [echo] longer text with
     [echo] with newlines
     [echo] etc.

     [echo] by element
     [echo] To pass an ant task into a macro, this is the way to go.

     [echo] a combination
     [echo] text content
     [echo] use this way for longer text with
     [echo] with newlines etc.
     [echo] text attribute
     [echo] and an additional attribute

BUILD SUCCESSFUL
Total time: 0 seconds

BTW, here are two books you might find useful, if you work with ant:

edited 28.2.05
I was wrong. Now that Vicky mentioned it, I found a paragraph at the bottom of the comparison page saying just that. Still the bonus is not enough to change my existing code, but I’m sure I’ll soon have to write some new tests, where I can give it a try. During the discussion at theserverside.com Vicky mentioned something about a eclipse plugin which will raise my chances of actually using it greatly. Unfortunatly, no info about when it will be available…

Why Janino? Why not use the Sun SDK?

… compiling Java programs with SUN’s JDK is a relatively resource-intensive process (disk access, CPU time, …).

This is where Janino comes into play… a leight-weight, “embedded” Java compiler that compiles simple programs in memory into Java bytecode which executes within the JVM of the running program.
…

here’s a short example:

String[] names = new String[] { "a", "b", "c", "d", "e" };
Class[] types = new Class[] { Boolean.TYPE, Boolean.TYPE,
                              Boolean.TYPE, Boolean.TYPE,
                              Boolean.TYPE };
String expr = "(a & b || c && d ) & !e";
ExpressionEvaluator ee = new ExpressionEvaluator(expr,
                                                 Boolean.TYPE,
                                                 names,
                                                 types);

Class[] values = new Object[] { Boolean.FALSE, Boolean.TRUE,
                                Boolean.TRUE, Boolean.TRUE,
                                Boolean.FALSE};
System.out.println(ee.evaluate(values));

Interesting fact: Groovy uses Janino, too.

In Mock Objects in Unit Tests Lu Jian writes about two tools (EasyMock and Mocquer) which generate mock objects. Here’s my most frequently used mock object.

Disclaimer: I know one could argue whether this is a ‘real’ mock object or more of a mock object facade bastard thingy.

I use Clock everywhere I would call System.currentTimeMillis() or call Calendar.get(...). This gives me an easy way to fast-forward in time without sleeps during unit tests.

public class Clock {

// some methods left out for clarity

  private static boolean debugMode = false;

  /**
   * dummy time, default value of 0 produced some strange errors in some tests
   */
  private static long lMillis = 12341234;
  private static int hour;

  private Clock() {
    // no instances needed
  }
  /**
   * facade for System.currentTimeMillis()
   */
  public static long currentTimeMillis() {
    if (debugMode) {
      return lMillis;
    }
    return System.currentTimeMillis();
  }

  /**
   * facade for Calendar.get(Calendar.HOUR_OF_DAY)
   */
  public static int getHour() {
    if (debugMode) {
      return hour;
    }
    final Calendar c = Calendar.getInstance();
    return c.get(Calendar.HOUR_OF_DAY);
  }

  public static void setDebugMode(boolean b) {
    debugMode = b;
  }

  private static void checkDebug() {
    if (!debugMode) {
      throw new IllegalStateException("You cannot set or change time now. Turn on debug mode first");
    }
  }

  public static void setCurrentTimeMillis(final long l) {
    checkDebug();
    lMillis = l;
  }

  public static void addCurrentTimeMillis(final long l) {
    checkDebug();
    lMillis += l;
  }

  public static void setHour(final int i) {
    checkDebug();
    if (i < 0 || i > 23) {
      throw new IllegalArgumentException("hour '" + i + "'");
    }
    hour = i;
  }
}

Here’s a little addon to Eric M. Burke pretty good article “Top 15 Ant Best Practices”.

Concerning help he wrote:

4. Provide Good Help
Strive to make the buildfile self-documenting. Adding target descriptions is the easiest way to accomplish this. When you type ant -projecthelp, you see a listing of each target containing a description. For example, you might define a target like this:

<target name="compile"
  description="Compiles code, output goes to the build dir.">

The simple rule is to include descriptions for all of the targets you wish programmers to invoke from the command line. Internal targets should not include description attributes. Internal targets may include targets that perform intermediate processing, such as generating code or creating output directories.

Another way to provide help is to include XML comments in the buildfile. Or, define a target named help that prints detailed usage information when programmers type ant help.

<target name="help"
        description="Display detailed usage information">
  <echo>Detailed help...</echo>
</target>

You can combine these two things to get a simple help target without much effort. You call ant -p/-projecthelp ‘from the inside’ via the exec task. This way you don’t have to write a seperate help target.

<project name="whatever" default="help" basedir=".">
 <target name="compile" description="compile my code"/>
 <target name="jar"     description="build my jar"/>
 <target name="clean"   description="cleanup"/>
 
 <target name="help"    description="print this help">
  <exec executable="ant">
   <arg value="-p"/>
  </exec>
 </target>
</project>

prints

$ ant
Buildfile: build.xml

help:
     [exec] Buildfile: build.xml

     [exec] Main targets:

     [exec]  clean    cleanup
     [exec]  compile  compile my code
     [exec]  help     print this help
     [exec]  jar      build my jar
     [exec] Default target: help

BUILD SUCCESSFUL
Total time: 1 second

I found a nice article about the use of the final keyword in java at IBM Developerworks.

Declaring methods or classes as final in the early stages of a project for performance reasons is a bad idea for several reasons. First, early stage design is the wrong time to think about cycle-counting performance optimizations, especially when such decisions can constrain your design the way using final can. Second, the performance benefit gained by declaring a method or class as final is usually zero. And declaring complicated, stateful classes as final discourages object-oriented design and leads to bloated, kitchen-sink classes because they cannot be easily refactored into smaller, more coherent classes.

Like many myths about Java performance, the erroneous belief that declaring classes or methods as final results in better performance is widely held but rarely examined. The argument goes that declaring a method or class as final means that the compiler can inline method calls more aggressively, because it knows that at run time this is definitely the version of the method that’s going to be called. But this is simply not true. Just because class X is compiled against final class Y doesn’t mean that the same version of class Y will be loaded at run time. So the compiler cannot inline such cross-class method calls safely, final or not. Only if a method is private can the compiler inline it freely, and in that case, the final keyword would be redundant.

didn’t know that. Guess I will declare less methods final. But I think the author is too negative and that final can have a place in object-oriented design. I use final methods often to enforce a certain behaviour, e.g. to make sure one of my Nodes can only be initialized once I use this init method:

private boolean init = false;
public final void init(...) throws NodeException {
  if (init) {
    log.warn("Already initialized! Call to init was ignored.");
    return;
  }
  basicSetup(...);

  try {
    doInit(...);
  } catch (Throwable e) {
    fail("exception in doInit", e);
  }
  init = true;
}

Sure, I could leave out the final but I couldn’t imagine a scenario where I would want to extend the init in a way I couldn’t do in doInit. And by using final I made sure that an unnamed colleague couldn’t screw up too badly.

If you must use final classes or methods, document why
In any event, when you do choose to declare a method or class final, document the reasons why. Otherwise, future maintainers will likely be confused about whether there was a good reason (since there often isn’t) and will be constrained by your decision without the benefit of your motivation.

Another valid point. And I have to plead guilty to not having done this so far. I’ll try to remember this (and write some docu right now ).

The rest of the article confirms my thoughts about the use of final fields, at least I was doing the sensible thing here…

some final words from JoS

The final modifier is not about performance enhancement, but about stronger typing and cleaner, clearer code.

You should keep your code in good state at all times, with the correct typing in all scopes.
Dino
Thursday, January 13, 2005