Deliver Your Java Application in One-JAR™ !

Deliver Your Java Application in One-JAR™! Copyright 2004-2007 by P. Simon Tuffs, All Rights Reserved.
http://www.simontuffs.com

One-JAR Appgen

Caution -- Advanced Topic Ahead: this information is not required to use the Appgen capability.

The One-JAR Application Generator (one-jar-appgen) creates a fully-functional One-JAR Eclipse/Ant project, based on the structure of a template project. This is similar in nature to the way that Grails lets you build projects using code-generators that can be customized by changing template documents.

The default project template is contained inside the one-jar-appgen-0.97.jar/one-jar-$project$.jar file and it has the following directory structure:

The key elements of this template are:

src -- Source-code for the main program
test -- Source code for a stand-alone test
junit -- Source code to bridge between JUnit and the stand-alone test
one-jar -- Distribution of the One-JAR software for use building and testing the project: the project is self-contained
lib -- A directory into which dependent libraries can be placed for building into a One-JAR
build.xml -- A build script that can build a project into the various artifacts (runnable jars)

one-jar-appgen processes this directory structure (and the files inside it), performing token substitution with the data entered by the user. The substituted tokens are:

$project$ -- the path of the project: the last element of which is used as a project name.
$package$ -- the package name for the project (Java package, '.' separators)

For example, when one-jar-appgen creates a project named path/test in a package called foo.bar, $project$ will expand to test, and $package$ will expand to foo.bar. The output files will be written under path.

The template build.xml file starts out as:

<?xml version="1.0" encoding="UTF-8"?>
<project name="one-jar-$project$" basedir="." default="build">

and is transformed to:

<?xml version="1.0" encoding="UTF-8"?>
<project name="one-jar-test" basedir="." default="build">

etc. The end result is a new project which builds two One-JAR archives:

build/$project$.jar -- A simple main program example
build/test-$project$.jar -- A stand-alone test program that can be hooked into JUnit

The test-$project$.jar is special: it has a main.jar with a Test class that acts as the main entry point. This class extends com.simontuffs.onejar.test.Testable, which can be used by the $package$.test.$project$Suite class to run a JUnit test suite. This is demonstrated by the junit.$project$ target in the build.xml file.

Roll Your Own Project Template

one-jar-appgen is extensible: if you supply your own one-jar-$project$.jar as a third argument to the program it will be used for template expansion instead of the built-in template.

The best way to roll-your-own template is to first extract and unpack the one-jar-$project$.jar file from inside the one-jar-appgen jar. You can then build it in-place (it does build itself) using Ant, and start adding in your own new files (with the tokens $project$ and $package in the appropriate places in file-content, filenames and directories.

Once the appgen results are what you want, running with the extra third argument, you can repack the one-jar-appgen jar file with the new template, and start using it (and sending it to your customers).

Roll Your Own Appgen

If you need more information, unpack the one-jar-appgen jar file and look at the Appgen source code which is under main.jar/src in the distribution. There is no significant magic there, but there is some logic which might not be obvious surrounding camel-case and conversion of '-' to '_' in various places that you might wish to modify as you "roll-your-own appgen" too.