i haz teh codez

Code Dump: Stripping out HTML

2009-12-03T15:38:00.000Z

Two solutions for this seam to pop up - Regex and using HTMLEditorKit. The first is very broken and can not handle escape characters, the latter works well but does not maintain formatting. So here is my expanded version which also breaks when it encounters a tag that breaks the flow.

package ihaztehcodez.utils;
 
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.Arrays;
import java.util.Collection;
 
import javax.swing.text.MutableAttributeSet;
import javax.swing.text.html.HTML;
import javax.swing.text.html.HTMLEditorKit;
import javax.swing.text.html.parser.ParserDelegator;
 
/** Strips HTML from text. 
 * 
 * @author mlk
 *
 */
public final class StripHtml {
 
 /** Utility class. */
 private StripHtml() { }
 
 /** Strips HTML from the content given.
  * 
  * @param value The string to strip.
  * @return A textual representation.
  */
 public static String stripped(final String value) {
  try {
   return stripped(new StringReader(value));
  } catch(final IOException ioe) {
   // This should never happen as the StringReader can not throw an IOE.
   throw new RuntimeException(ioe);
  }
 
 }
 
 /** Strips HTML from the content given.
  * 
  * @param value The content to strip.
  * @return A textual representation.
  */
 public static String stripped(final Reader value) throws IOException {
  ParserDelegator delegator = new ParserDelegator();
  StripOMatic matic = new StripOMatic();
  delegator.parse(value, matic, true);
 
  return matic.toString();
 }
 
 /** Read in the text file and adds a new line when a breaking tag is encountered.
  * 
  * @author Michael Lee
  *
  */
 private static class StripOMatic extends HTMLEditorKit.ParserCallback {
  /** The string value. */
  private final StringBuilder value = new StringBuilder();
  /** Some tags should be ignored. */
  private static Collection<HTML.Tag> ignore = Arrays.asList(HTML.Tag.HTML, 
    HTML.Tag.BODY, HTML.Tag.HEAD);
 
  /** If the tag breaks the flow then add a new line, otherwise ignore.
   * {@inheritDoc} 
   */
  public void handleStartTag(final HTML.Tag t, final MutableAttributeSet a, final int pos) {
   if (ignore.contains(t)) {
    return;
   }
   if (t.breaksFlow()) {
    value.append("\n");
   }
  }
 
  /** Delegates to handleStartTag.
   * {@inheritDoc} 
   */
  public void handleSimpleTag(final HTML.Tag t, final MutableAttributeSet a, final int pos) {
   handleStartTag(t, a, pos);
  }
 
  /** Adds the following chunk of text.
   * 
   * {@inheritDoc}
   */
  public void handleText(final char[] text, final int pos) {
   value.append(text);
  }
 
  /** @return The text version of the data parsed so far. */
  public String toString() {
   return value.toString();
  }
 }
}

Code Dump: Stubbing with a map

2009-11-30T15:28:00.002Z

A year or so back I wrote a cool little utility class MyInvocationHandler. This is used by simply creating a map of the proprieties and their values simply as I felt that:

Map backing = new HashMap();

backing.put("title", "ihaztehcodez");

backing.put("getURL",

            "ihaztehcodez.michael-lloyd-lee.me.uk");

Blog thisHereBlog = create(backing, Blog.class);

was easier on the eyes that the EasyMock styled

Blog thisHereBlog = createNiceMock(Blog.class);

expect(thisHereBlog.getTitle())

   .andReturn("ihaztehcodez").anyTimes();

expect(thisHereBlog.getURL())

    .andReturn("ihaztehcodez.michael-lloyd-lee.me.uk")

    .anyTimes();

replay(thisHereBlog);

However I was wrong to use either method. If I was to do so again I'd use write a BlogBuilder. It is a good chunk more work up front, but it leads to significantly better reading code.

Blog thisHereBlog = new BlogBuilder()

     .withTitle("ihaztehcodez")

     .withURL( "ihaztehcodez.michael-lloyd-lee.me.uk")

.build();

This does mean I now have a mini project to start. Write a JPA thingie to generate a builder.

Preventing multiple instances of an application from running.

2009-11-25T11:16:00.003Z

This is a common question, with a very common answer - create a machine wide semaphore. The most common recommendation in Java is to use a socket. However this answer has a flaw. In a multi-user environment you do not want a machine-wide, you want a user-wide semaphore. I have seen some very complex solutions to this issue but there is a very simple answer. Use a file lock.
The common reason against using files is that they are not automatically cleaned when the application is forcible terminated (for example hitting the big red button). This is true if you use the existence of a file to determine if a previous instance is running, but there is a better option than this. Use the FileLock for a file in the users home directory. FileLocks are automatically cleaned by the OS should the application die without unlocking and can be placed in a location that will be local to the user allowing this solution to work on multi-user environment such as Windows Terminal Server.

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;
import java.util.logging.Level;
import java.util.logging.Logger;

/** Prevents two instances of the application from starting at the same time.
*
* @author Mlk
*
*/
public final class InstanceChecker {
    /** A singleton instance. */
    public static final InstanceChecker INSTANCE = new InstanceChecker();
    /** The file channel to be locked. */
    private FileChannel channel;
    /** The lock on the file. */
    private FileLock lock;
    /** The file to be locked. */
    private final File file = new File(new File(System.getProperty("user.home")), "/APPLICATION_NAME.lock");
    /** Logger. */
    private Logger log = Logger.getLogger(getClass().getName());



    /** ctor. */
    private InstanceChecker() {    }

    /** Is this the only instance of this application currently executing.
    *
    * @return should the application be allowed to start up.
    */
    public boolean onlyInstance() {

        try {
            channel = new RandomAccessFile(file, "rw").getChannel();

            try {
                lock = channel.tryLock();
            } catch (OverlappingFileLockException e) {
                return false;
            }
            if (lock == null) {
                return false;
            }

            Runtime.getRuntime().addShutdownHook(new Thread() {
                public void run() {
                    close();
                }
            });
        } catch (IOException e) {
            log.log(Level.WARNING, "Failed to lock file: " + file, e);
            return false;
        }
        return true;
    }

    /** Unlocks the file. */
    private void close() {
        try {
            if (lock != null) {
                lock.release();
            }
            if (channel != null) {
                channel.close();
            }

            file.delete();
        } catch (final IOException e) {
            System.err.println("Failed to unlock file!");
        }
    }
}

And you use it:

public static void main(String argv...) {

     if( !InstanceChecker.INSTANCE.onlyInstance()) {

     // Die!

  }

}

It currently lacks the inter application communication, but I think that would be easily added by also having a "ping" file that would be touched during the die section of code.

How to render HTML in Java then save this as an image

2009-11-02T13:15:00.000Z

A few Java based HTML renders exist, all with different sets of drawbacks. The most common is the one built in. This is quite simple and can only render fairly basic HTML. The most interesting I know of is The Flying Saucer Project. This can render fairly complex XHTML but you will have to convert HTML before you can use it (JTindy or may be able to help here). Taking a Swing component and creating a image is fairly simple, you just pass an BufferedImages graphics object and pass it to the Swing components paint method. Then splat that out with ImageIO.

A big advantage to this would be that the renderer would be headless. The disadvantage is that it would not be a perfect rendering and it would lack any plugin support.

The second option requires you to start a web browser, work out where it is and then take a screen shot. Optionally you may also wish to strip out all the Firefox/IE/Opera/etc menus leaving you with just image. To get the dimensions of the web browser the simplest option would be to start it full screen. The other option would be to use something like JDICs browser component to include it as part of the Java application. It would then be able to specify where the HTML is being rendered on screen and then simply use Robot to create a screen shot of that area.

The big advantage to this is that it will give a perfect rendering (for a given browser). The two disadvantages is that it would require native code (or at least using a native component) and it could not be headless¹.

1) You could use a virtual frame buffer. But that is outside Java.

Sad day. Sad sad day.

2009-10-29T11:45:00.000Z

Today I found out that schmidt.devlib.org has been eaten by the great Noodly One in the sky. A real shame it was a very useful resource for Java developer.

Hopefully it has found a new home.

Mocking System Classes

2009-10-27T13:46:00.003Z

Today I answered a question about mocking system classes in Java on Stack Overflow. I found the documentation for doing this somewhat limited, so I'm going to rework and repost my answer here.

First things first. If you have to mock system classes then do you have anything slightly smelly in your design? Can you work the direct link between the two out by say introducing a facade between the real dependency (java.lang.System) and the SUT.

Assuming that you can not or do not want to then you have at least two options: PowerMock and JMockIt.

Lets first make a class to test EnvOMatic. EnvOMatic has one method, clean This loads a value from the Environment and cleans of dirty words.

public class EnvOMatic {
    public String clean(String key) {
       String value = System.getenv(key);
       if (value==null) {
           return null;
       }
       return value.replaceAll("Groovy", "naughty");
   }
}

PowerMock
Power Mock has some decent documentation for mocking system classes, but lets show an example of it
here.
package playtest;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.legacy.PowerMockRunner;

import static org.powermock.api.easymock.PowerMock.*;
import static org.easymock.EasyMock.*;
import static junit.framework.Assert.*;

@RunWith(PowerMockRunner.class)
@PrepareForTest( { EnvOMatic.class })
public class TestPowerMock {

    @Test
    public void assertThatMockingOfFinalSystemClassesWorks() throws Exception {
            mockStatic(System.class);

            final String key = "boo";
            final String expected = "Bye";

            expect(System.getenv(key)).andReturn(expected);
            replayAll();

            assertEquals(expected, new EnvOMatic().clean(key));

            verifyAll();
    }
}

So in this we tell JUnit to use the PowerMock runner, then specify the SUT that uses the System class via annotations. Then in the test class we inform PowerMock that we are mocking java.lang.System and finally use it as we would use any other EasyMock mock.

One thing that caught me out was that the JUnit 4.7 provided in the "With Dependencies" download did not work. JUnit 4.4 shipped Eclipse did.

JMockIt
Unlike PowerMock above I could not find any documentation on how to do this. The code below is various examples super glued together until it worked.

import org.junit.*;
import org.junit.runner.RunWith;

@RunWith(JMockit.class)
public class TestJMockIt {

    @Test
    public void assertThatMockingOfFinalSystemClassesWorks() {
        Mockit.setUpMocks(MockSystem.class);

        final String key = "boo";
        final String expected = "Bye";

        MockSystem.put(key, expected);

        assertEquals(expected, new EnvOMatic().clean(key));

    }

    @MockClass(realClass = System.class)
    public static class MockSystem {
        static Map env = new HashMap();

        static void put(String key, String value) {
            env.put(key, value);
        }

        @Mock
        public static String getenv(String key) {
            return env.get(key);
        }
    }

}

One thing to note about this is that we are not mocking but stubbing java.lang.System. Now in this case I don't think this is a problem.
To make this work we need to use a custom runner again, this time JMockit. This runner does requires JUnit 4.5 or above.
Then we create a class with static methods stubs defined.
Finally we inform MockIt of the stub implementation.

So there you have two ways of stubbing and mocking java.lang.System. They both have same restriction - a custom runner, and I'm sure they are equally as powerful, so the choice of which to use will depend solely on your API preference.

headbash

2009-10-22T10:56:00.002+01:00

I got sucked into the evil time vortex that is StackOverflow again and decided to have a go on a PMD question.

My god people put some sodding docs up.

I spend the last few hours digging about for any documentation that I could find on the tree structure and just could not find a damn thing. I had to spend my time scanning other peoples rules to attempt to work out what was going on.

So please developers of open source projects think for a few seconds about the poor bastards that actually use your software and invest a little time into the very unsexy act of writing documentation.
Thanks.

My Nifty Idea

2009-10-20T16:35:00.000+01:00

I have had a cool idea floating at the back of my mind for a little while and today as I have work I really don't want to do I worked out how to make it work and have thrown together a prototype. So first some background. I find myself writing a fair amount of database code. A lot of this is simple wrappers around a oracle package. The JDBC gods demand a fair amount of boiler plate. Even without going all the way to a ORM tool like Hibernate I know APIs exist to reduce said boilerplate but I've always felt (rightly or not) that I'd still end up doing a fair bit of boilerplate code even so or they were tied to an API I don't already use (i.e. Spring JDBC is slightly tried to Spring). I know the proper answer is likely to bite the bullet and use Spring. But sod that, I want to roll my own.
Mmm. Sorry slipping into irrelevant babbling. What I want out of an API is to define an interface and have that magically fill in the blanks. So for example if I define:



public interface Queue {

int getCount

();
}

then all I'd have to do would be add some annotations to tell the Magic what I want and it would go ahead and make it happen. So today I created a prototype.
First the annotation:



package playtest;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface Execute {
String script();
}
You then annotate the method you want to be magical.



package playtest;

public interface Queue {

@Execute(script="{? = call Queue.getCount}")
Integer getCount();
}

Next the magic. Note: I'm using a Guice provider to get hold of the database. I'm not 100% that is the right way to go as while I'm very likely to use Guice do I really want to tie the implementation down to Guice? This play test of an implementation can only return void or Integer. If I was to go forward with this I'd have to get it to be able to return all primitive types at least and ideally be able to marshal complex types. Likely via annotations in the complex types. Maybe what I really want is JPA.



package playtest;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.SQLException;

import java.sql.Statement;

import java.sql.Types;

import java.util.logging.Level;

import java.util.logging.Logger;

import com.google.inject.Provider;

public class QuickAndDirtySQLHandler implements InvocationHandler {

private final Logger log = Logger.getLogger(getClass().getName());

private final Provider connectionProvider;

public QuickAndDirtySQLHandler(final Provider connectionProvider) {

this.connectionProvider = connectionProvider;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

Execute execute = method.getAnnotation(Execute.class);

if (execute == null) {

throw new IllegalStateException("Required annotation missing!");

}

boolean returnsValue = false;

if (method.getReturnType().equals(Integer.class)) {

returnsValue = true;

}

Connection connection = connectionProvider.get();

CallableStatement statement = null;

try {

statement = connection.prepareCall(execute.script());

if (returnsValue) {

statement.registerOutParameter(1, Types.INTEGER);

}

statement.execute();

if (returnsValue) {

return statement.getInt(1);

} else {

return null;

}

} finally {

close(statement);

connection.close();

}

}

private void close(Statement s) {
if (s == null) {
return;
}
try {
s.close();
} catch(SQLException sqle) {
log.log(Level.WARNING, "Failed to close statement", sqle);
}
}
}
Next a helper class to handle database access.



package playtest.db;

import java.sql.Connection;

import java.sql.SQLException;

import org.apache.commons.dbcp.BasicDataSource;

import com.google.inject.Provider;

public class ExampleDatabaseProvider implements Provider{

  private final BasicDataSource ds = new BasicDataSource();

  public ExampleDatabaseProvider(String driver, String username,

     String password, String url) {

    ds.setDriverClassName(driver);

    ds.setUsername(username);

    ds.setPassword(password);

    ds.setUrl(url);

    ds.setMaxActive(1);

    ds.setDefaultAutoCommit(false);

  }

  @Override

  public Connection get() {

    try {

     return ds.getConnection();

    } catch(SQLException sqle) {

    // Switch to a throwing provider?

     throw new IllegalStateException(sqle);

    }

  }

public void close() throws SQLException {
ds.close();
}
}
And finally some magic:



package playtest;

import java.lang.reflect.Proxy;

import playtest.db.ExampleDatabaseProvider;

public class KickStart {
public static void main(String argv[]) throws Exception {
    ExampleDatabaseProvider dbProvider =
      new ExampleDatabaseProvider(
        "jdbc.driver","username", "password", "jdbc:database");

    Queue example = (Queue)Proxy.newProxyInstance(
      KickStart.class.getClassLoader(),
      new Class[] {Queue.class},
      new QuickAndDirtySQLHandler(dbProvider));

   System.out.println(example.getCount());

   dbProvider.close();
}
}
I think that would be much better than raw JDBC for projects that demand the use of stored procedures (like all projects at my current employer). I should really look at how JPA handles forced use of stored procedures.

I think this is a cool idea and I plan to run with it (if I can find the time). I'll post updates here under the tag magic-procedures. The GitHub site is: http://github.com/mlk/magic-procedures and the public repository is git@github.com:mlk/magic-procedures.git

Code now on GitHub

2009-10-20T15:23:00.001+01:00

I need to play with Git for a bit as I just don't understand what all the fuss is about. So I've thrown the code I've written for this blog on to GitHub. The public repository is:
git://github.com/mlk/ihaztehcodez.git

JUnit 4.7 - TemporaryFolder

2009-10-20T11:21:00.001+01:00

JUnit 4.7 adds a cool looking new feature - Rules. These should get rid of the need to write a new Runner every time you want something nifty to happen.
One of the rules is TemporaryFolder. This automatically creates and destroys a temporary folder at the start and end of a test. A neat extra and something I'd already thrown together for my own use. However my version did one thing different - it destroyed on start up not shut down. Why? The same reason my database tests do this. When testing I can quickly go back to any test and check the files it created and attempt to work out why a test is failing.

Mocking a Get/Set Pair using EasyMock

2009-10-20T10:56:00.002+01:00

Once again I'm going to tart up a post of SO and throw it on here:

Say you have an interface with a get/set pair that get populated and retrieved. And you need these to match.

public interface GetSetId {

    public int getID();

    public void setID(int id);

    public void somethingThatMakesThisNotAValueObject();

}

When it comes to testing items that depend on this you need to either - be able to know the get/set values in advance or write a little wrapper to remember the get/sets. In order to simplify this I humbly present:

public class GetSetAnswers<T> {
    private T value;
    public IAnswer<Object> set() {
        return new IAnswer<Object>() {
            @Override
            public Object answer() throws Throwable {
                Object[] arguments = getCurrentArguments();
                value = (T) arguments[0];
                return null;
            }
        };
    }

    public IAnswer<T> get() {
        return new IAnswer<T>() {
            @Override
            public T answer() throws Throwable {
                return value;
            }
        };
    }
}

You can then use it thusly:
public class TestGetSet {
    @Test
    public void testSetGet() {
        GetSetAnswers<Integer> value = new GetSetAnswers<Integer>();

        GetSetId id = createMock(GetSetId.class);
        id.setID(anyInt());
        expectLastCall().andAnswer(value.set());
        expect(id.getID()).andAnswer(value.get());

        replay(id);
        int generatedValue = (int) (Math.random() * 100.0);
        id.setID(generatedValue);
        Assert.assertEquals(generatedValue, id.getID());
        verify(id);
    }
}

Integration vs Unit test for the database layer

2009-10-01T15:39:00.000+01:00

A commonly posted question on Stack Overflow is how to unit testing the database layer. Any question about this generally ends up with two diverse answers. The first is that all database activities should be mocked and tested during integration testing, the second is that a real database should be used.

I feel that testing against a database is important and should be done frequently. As it needs to be done frequently it should be quick to set up and execute. Now setting up a database may sound like work, but if all developers have access to a dedicated database that sits either on the local machine or on a decent sized box in the background and the dataset are restricted to use what is reliant to the test then this take little time to connect to and set up.

As I'm a lazy git I don't really want to be using different technologies for different sets of tests. Any test that wants to run frequently and is fast to run just becomes a JUnit test.

So finally when should I write it? Well I know before starting a second of code what the data should look like before and after the test runs. So I write the test first. Now I could set up a mocked Statement, ResultSet and all that fun stuff but really that is a lot more work than creating the XML files for dbUnit and I'm going to have to set up all this data for integration tests. So why repeat myself.

I think the name used is not as important as the doing. Still if I had to pick a side, it would be "unit test".

Options for deploying desktop software in Java

2009-09-22T09:33:00.001+01:00

Like my yesterday I'm going to copy & paste an answer from Stack Overflow.

Java software can be release in a number of ways depending on the target market.

The simplest for the developer (but hardest for the end user) is to just release a jar file (or set of Jar files). On many systems the JAR will be "double-click-able", and so act as an executable. But if the end user does not have Java installed it will not work.
Good if you control the target environment. Also good if you want to target Windows, Mac and Linux all at once. Any platform with Java can run it, including platforms you had not considered.
Bad if you are targeting normal users. It can not do "install tasks", set up anything in the start menu or associate itself with a file type.

Java Web Start is my preference in most cases. It gives a Java based installer and can set up the start menu, associate file types and all that goodness. But does bring up a security box on install.
Good for most cases. You have just the one link for all OSes.
Bad if you suspect the user does not have a JRE installed or you don't want the end user to be aware that the application is written in Java.

You could release a zip file with the Jars in and a .bat file and a .sh file to get the going.
Good for administrators, developers and command line applications.
Bad for end users who don't really know what a bat and shell script are and would have no idea what to do if the script was broken for their system.

A thin .exe wrapper round the Jar file. This gives the impression to the end user that the application is native. They normally come with...

A Java aware installer. This is a native installer (so different installers for Windows, Mac & Linux). This will be able to detect if the target machine has Java installed and if not be able to kick off the installation of the JRE. It will also be able to do all the fun post-install stuff such as setting file associations and add items to the start menu.
Good for most cases.
Bad if you are targeting multiply platforms as you will need to maintain an installer for each platform. Also bad if one of the target platforms does not have a Java aware installer (you will then need to use of of the other methods above for that one platform).

Native EXE. Using a Java-to-native compiler (Jet or GCJ) you create a native executable.
Good if you really don't want people to know you are using Java.
Bad as people think that this will magically make the application faster when it will not.

Randomly Ordered JUnit Tests

2009-09-21T17:26:00.003+01:00

Could not be arsed to work for a bit, so got sucked into Stack Overview for a bit.

Never a good thing. Anyway one question was about how to run JUnit tests in a random order. So I sat down and looked over the APIs and gave it a bash:



import java.util.Collections;
import java.util.List;

import org.junit.runners.BlockJUnit4ClassRunner;

import org.junit.runners.model.FrameworkMethod;

import org.junit.runners.model.InitializationError;

/** Runs JUnit tests in a random order.

* 

* @author mlk

*

*/

public class RandomBlockJUnit4ClassRunner extends BlockJUnit4ClassRunner {

   public RandomBlockJUnit4ClassRunner(Class klass)

      throws InitializationError {

      super(klass);

   }

   /** {@inheritDoc} */

   protected java.util.List computeTestMethods() {

      List methods = super.computeTestMethods();

      Collections.shuffle(methods);

      return methods;

   }

}

Annotate any class you want the unit tests to run in a random order with "@RunWith(RandomBlockJUnit4ClassRunner.class)" and hey presto randomly ordered unit tests. (Note: This required JUnit 4.5 or above).
Now JUnit does have a Sortable interface, but I've no idea how to actually ruddy use it. :'(

How to become a developer

2008-08-03T23:00:00.002+01:00

Every now and again I see a request on the JDC for teh magick knowledge that will turn a person from random guy to developer. So for the second time today I'd like to vomit my wisdom all over the internets.

First learn how to use the command line. Ideally both Unix (Cygwin if you don't have access to Unix-a-like) and Windows Command Processor. I'm not saying you should have mad hacker skillz, just be able to navigate the directory structure, set (and check) environment variables, start new applications and maybe some basic control structures (if statements and loops).
While you improve your development skills, try to also update you knowledge of the command line. Commands like grep, tail, awk, cut and paste have simplified many an awkward job.

I don't think I need to tell you to learn the basics of your chosen language, but I've just been bitten for assuming people don't need to be told the obvious so I'll state it here. Learn the basics of your chosen language.
That done, the people at The Pragmatic Bookshelf have asked themselves the same question I'm now answering, and came up with the following three books - Pragmatic Version Control, Pragmatic Unit Testing and Pragmatic Automation. I agree completely with the subjects they have selected. Get yourself a book, or some online tutorials on all three subjects.
Now what you need most is experience. Knowing cool shit like patterns will help in the long run, but without the experience to place them in context they will be of limited use. So go out and play. Think of a project and do it so you can learn from your cock ups.

Defensive Coding

2008-08-03T13:17:00.004+01:00

Google Testing recently recommended against being defensive. The rationale behind this was that testers found it easier to simply pass a null when testing than passing in a constructed object. I disagree with this. Creating a null object either with an existing mock object framework or by using the proxy capabilities in Java makes passing a null object no harder than passing null.
Now some codez:
package ihaztehcodez.nullobject;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import static java.lang.reflect.Proxy.newProxyInstance;

/** Provides a simple alternative to passing null.
* @author Mike Lee
*/
public class NullObjectFactory {
/** Utility class, should never be created. */
private NullObjectFactory() { }

public static T createNullObject(Class<T> clazz) {
return (T) newProxyInstance(ClassLoader.getSystemClassLoader(),
new Class [] { clazz }, new SadInvocationHandler() );
}
}

class SadInvocationHandler implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) {
throw new IllegalStateException("Proxy does not support method calls.");
}
}

package ihaztehcodez.fourtehnalzobj;

import static ihaztehcodez.fourtehnalzobj.NullObjectFactory.createNullObject;

public class NullObjectFactoryExample {
public void testThingie() {
Thingie thingie = new Thingie(createNullObject(Whatsit.class));
}
}

class Thingie {
Thingie(Whatsit whatsit) {
}
}

interface Whatsit {
}

Generating Word Documents In Java

2008-08-02T22:06:00.003+01:00

UPDATE: I think need to depricated this post. Go with FOP.

Very now and again I see this on the JDC, and as I have recently needed to do this I thought it would be good to write down how to do this.

Are you creating word documents or editing existing Word documents? If the latter then here you go. Good luck.

If you need to create a new Word document then first it might be worth using RTF. Word 97 used RTF instead of Words native format so don't worry; no-one will ever know our dirty little secret. The advantage of using RTF is it is a text file not a scary binary file and the specification is a free download. Java also has some primitive support for RTFs.

I am going to guess that you don't simply wish to create a free-form word document but rather you will be applying a model to a simple template?

For those who do not know what that means:

Lets give this a little context, we want to send a bill out, so we some key details about our customer, and the order.

customer_name=Bob MacBobby

items=(

         (name="blow up sheep", cost=12.5),

         (name="Fun with Goats, the motion picture", cost=9.99

        )

total_untaxed= 22.49

vat= 3.94

total= 26.43

And we want:

Dear Bob MacBobby,

Item: blow up sheep
Cost: 12.5
Item: Fun with Goats, the motion picture
Cost: 9.99

Total (without tax): 22.49
VAT: 3.94
Total: 26.46

Doing this is very easy. First we need to go get a templating engine. I've used Freemarker before and it works nicely.

The only issue with this is that creating a RTF template can be a bit of a bitch, the way to do it is to create the RTF document looks how you want it to look in say Word. Where you need a variable don't use ${blah} that Freemarker requires but use an all uppercase word. This is because RTF uses { }.

Now we need to edit it so it is a valid freemarker template. Open the document in a plain text editor. Find the INSERT_XXX_HERE and replace them with the Freemarker syntax: ${xxx?rtf}. Take note of the ?rtf.
Finally we need the loop. Simply add <#list …> to the line above the items you want to loop over, and to the line below. The template file is alas not a valid RTF document, but running Freemarker over it will create a nice valid RTF document.

{\rtf1\ansi\ansicpg1252\uc1\deff0\stshfdbch0\stshfloch0\stshfhich0\stshfbi0\deflang2057\deflangfe2057{\fonttbl{\f0\froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f36\froman\fcharset238\fprq2 Times New Roman CE;}
{\f37\froman\fcharset204\fprq2 Times New Roman Cyr;}{\f39\froman\fcharset161\fprq2 Times New Roman Greek;}{\f40\froman\fcharset162\fprq2 Times New Roman Tur;}{\f41\froman\fcharset177\fprq2 Times New Roman (Hebrew);}
{\f42\froman\fcharset178\fprq2 Times New Roman (Arabic);}{\f43\froman\fcharset186\fprq2 Times New Roman Baltic;}{\f44\froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;
\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;
\red128\green128\blue128;\red192\green192\blue192;}{\stylesheet{\ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \fs24\lang2057\langfe2057\cgrid\langnp2057\langfenp2057 \snext0 Normal;}{\*\cs10 \additive \ssemihidden
Default Paragraph Font;}{\*\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tscellwidthfts0\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv
\ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \fs20\lang1024\langfe1024\cgrid\langnp1024\langfenp1024 \snext11 \ssemihidden Normal Table;}}{\*\latentstyles\lsdstimax156\lsdlockeddef0}{\*\rsidtbl \rsid14418598\rsid15407471
\rsid16010694}{\*\generator Microsoft Word 11.0.5604;}{\info{\title Dear INSERT_NAME_HERE}{\author Michael Lee}{\operator Michael Lee}{\creatim\yr2008\mo8\dy2\hr21\min49}{\revtim\yr2008\mo8\dy2\hr21\min55}{\version1}{\edmins3}{\nofpages1}{\nofwords30}
{\nofchars177}{\*\company Your Company Name}{\nofcharsws206}{\vern24689}}\paperw11906\paperh16838 \widowctrl\ftnbj\aenddoc\noxlattoyen\expshrtn\noultrlspc\dntblnsbdb\nospaceforul\formshade\horzdoc\dgmargin\dghspace180\dgvspace180\dghorigin1701
\dgvorigin1984\dghshow1\dgvshow1\jexpand\viewkind4\viewscale100\pgbrdrhead\pgbrdrfoot\splytwnine\ftnlytwnine\htmautsp\nolnhtadjtbl\useltbaln\alntblind\lytcalctblwd\lyttblrtgr\lnbrkrule\nobrkwrptbl\snaptogridincell\allowfieldendsel\wrppunct
\asianbrkrule\rsidroot14418598\newtblstyruls\nogrowautofit \fet0\sectd \linex0\headery708\footery708\colsx708\endnhere\sectlinegrid360\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2
\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6
\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang
{\pntxtb (}{\pntxta )}}\pard\plain \ql \li0\ri0\widctlpar\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \fs24\lang2057\langfe2057\cgrid\langnp2057\langfenp2057 {\insrsid14418598 Dear }{\b\insrsid14418598\charrsid14418598 ${customer_name}}{
\insrsid16010694
\par }{\insrsid14418598
\par Thank you for your order. Now pay up.
\par
<#list items as item>
\par }{\b\insrsid14418598\charrsid14418598 Item}{\insrsid14418598 : ${item.name?rtf}
\par Cost: ${item.cost}
</#list>
\par
\par Total (without tax): ${total_untaxed}
\par VAT: ${vat}
\par Total: ${total}
\par }}

This alas is not perfect. While static images are simple enough, just add them into the template file, I have no idea how to do dynamic images. Which is why I'm now looking into Apache FOP.