To make Sun’s Java 6 JDK available on Ubuntu 10.04, 10.10 or later, add the new repository like so:

add-apt-repository "deb http://archive.canonical.com/ lucid partner" && aptitude update

Then, be sure to follow my previous instructions for installing the JDK.

To do so when using ehcache within a webapp, simply add its ShutdownListener as a listener in web.xml.

<listener>
    <listener-class>net.sf.ehcache.constructs.web.ShutdownListener</listener-class>
</listener>

Alternatively, or when not using ehcache inside a webapp, instruct ehcache to register its own shutdown hook by setting a system property.

net.sf.ehcache.enableShutdownHook=true

If you forget one of the above, your persisted cache may not be up-to-date, or worse, not persisted at all.

Caphyon, the maker of Advanced Installer, provides code samples and documentation on licensing integration for C++ and C# applications. To use this feature, the application must make a call into an Advanced Installer library and handle its return code.

The library is a gatekeeper to the rest of the application, effectively deciding whether or not the application is allowed to run. It determines the software’s trial status and displays a registration dialog, terminates the application, or returns a code, accordingly. The Java implementation of this feature works a little differently.

For those using the Java Launcher, integrating the licensing feature is easy: simply add the Java Product on the Licensing Options tab. But, what about those who don’t use Java Launcher? Or those that wish to enable users to register from within the application?

There is no official documentation which answers these questions, but based on a discussion following a request for help I posted on the Advanced Installer forums, I was able integrate AI’s licensing feature into my Java application without using the Java Launcher.

My solution mirrors the C++ implementation and is remarkably simple. Thanks to Cosmin, a member of the Advanced Installer support team, for sending me in the right direction.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class LicenseChecker {
    private static final String LIBRARY_KEY = "Replace this String with the Trialware/Registration Library Key";
 
    public static void main(String args[]) {
        int i = TrialLibrary.INSTANCE.ReadSettingsStr(LIBRARY_KEY, null);
        switch (i) { //http://www.advancedinstaller.com/user-guide/qa-trial-using.html
        case 0:
            System.out.println("Thank you for registering this program.");
            break;
        case 2:
            System.out.println("Thank you for trying this program.");
            break;
        default:
            System.exit(i);
        }
        System.out.println("Program will continue.");
        // ...
    }
 
    interface TrialLibrary extends Library {
        final TrialLibrary INSTANCE = (TrialLibrary) Native.loadLibrary("Trial", TrialLibrary.class); // loads Trial.dll
        int ReadSettingsStr(String keyCode, HWND hwnd);
        int DisplayRegistrationStr(String keyCode, HWND hwnd);
    }
}

Note: The above uses Java Native Access (JNA) to invoke the Advanced Installer library.

There are quite a few obfuscators for Java — at least a dozen when I looked — most of which are easily used from an Ant script.

For my use I selected one with a ready-to-use Ant task: yGuard. Unfortunately, yGuard operates on .jar files only, not individual .class files or webapp .war files. Thus, I have written my own Ant script which uses yGuard and built-in Ant tasks to obfuscate .war files.

Before you try using my Ant script, read yGuard’s documentation and be sure you fully understand how it works. You should pay special attention to the inoutpairs, keep, and hints and troubleshooting sections.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

<!-- prepare a temporary directory in which the war file is expanded and obfuscated -->
<tempfile property="unwar.dir" destdir="${java.io.tmpdir}" deleteonexit="yes"/>
<mkdir dir="${unwar.dir}"/>
<unwar src="webapp.war" dest="${unwar.dir}"/>
 
<!-- create a jar of webapp classes (required by yguard) for obfuscation -->
<jar destfile="${unwar.dir}/WEB-INF/lib/webapp.jar" whenempty="fail">
    <zipfileset dir="${unwar.dir}/WEB-INF/classes"/>
</jar>
<delete dir="${unwar.dir}/WEB-INF/classes"/>
 
<!-- create a fileset of internal libraries to be obfuscated -->
<fileset dir="${unwar.dir}/WEB-INF/lib" id="internal.lib.set">
    <include name="myLibrary.jar"/>
    <include name="myOtherLibrary.jar"/>
</fileset>
 
<!-- move the internal libraries to a temporary directory and make a fileset out of them -->
<tempfile property="obfuscation.dir" destDir="${java.io.tmpdir}" deleteonexit="yes"/>
<mkdir dir="${obfuscation.dir}"/>
<move todir="${obfuscation.dir}">
    <fileset refid="internal.lib.set"/>
</move>
 
<!-- create a jar of web.xml (required by yguard) for obfuscation -->
<jar destfile="${obfuscation.dir}/web.xml.jar" whenempty="fail">
    <zipfileset dir="${unwar.dir}/WEB-INF" includes="web.xml"/>
</jar>
<delete file="${unwar.dir}/WEB-INF/web.xml"/>
 
<!-- make a fileset of all jars to be obfuscated -->
<fileset dir="${obfuscation.dir}" includes="*.jar" id="in-out.set"/>
 
<!-- make a fileset of the remaining libraries, these are not obfuscated -->
<path id="external.lib.path">
    <fileset dir="${unwar.dir}/WEB-INF/lib" includes="*.jar"/>
</path>
 
<taskdef name="yguard"
    classname="com.yworks.yguard.YGuardTask"
    classpath="yguard.jar"/>
 
<yguard>
    <inoutpairs>
        <!-- these filesets are inputs to be obfuscated -->
        <fileset refid="in-out.set"/>
    </inoutpairs>
    <externalclasses refid="external.lib.path"/>  <!-- external libs, not obfuscated -->
    <rename>
        <adjust replaceContent="true">
            <include name="web.xml"/>  <!-- modified to reference the obfuscated Servlet -->
        </adjust>
        <keep>
            <!-- classes, packages, methods, and fields which should not obfuscated are specified here -->
        </keep>
    </rename>
</yguard>
 
<!-- move our newly obfuscated classes back into the lib area -->
<move todir="${unwar.dir}/WEB-INF/lib">
    <fileset dir="${obfuscation.dir}" includes="*_obf.jar"/>
</move>
 
<!-- unjar the adjusted web.xml --> 
<unzip dest="${unwar.dir}/WEB-INF/" src="${unwar.dir}/WEB-INF/lib/web.xml_obf.jar">
    <patternset includes="web.xml"/>
</unzip>
<delete>
    <fileset dir="${unwar.dir}/WEB-INF/lib" includes="web.xml*.jar"/>
</delete>
 
<!-- rebuild the war file -->
<war destfile="webapp_obf.war" basedir="${unwar.dir}"/>

yWorks, the creator of yGuard, is perhaps best known for yDoc a UML diagram generator for JavaDocs.

There is, of course, a hitch: for any non-trivial application or problem, you will be quickly buried by a mountainous log file.  The longer your application runs, the larger the log file.  It keeps growing, and growing, and…

GCViewer

What will you do?  Write a second Java app, one that parses the log file — attempt a homegrown analysis tool?  No!  Instead, I suggest you use GCViewer, a free open-source tool for visualizing the Java gc log file.

GCViewer helps you get a quick and comprehensive look at how your application is behaving.  Things like total heap vs. heap used and full GC events become very apparent.  Useful statistics such as time spent during GC are calculated for your convenience.

GCViewer is created by tagtraum industries and is available under an LGPL license.

Here’s how I installed Ant on Ubuntu without GCJ. Be sure to check out (easier) alternatives suggested in the comments, below.

1. Download the current .tar.bz2 distribution of Ant from http://www.ibiblio.org/pub/mirrors/apache/ant/binaries/.
2. Unpack archive using tar.

tar -xjvf apache-ant-*-bin.tar.bz2

3. Move the unpacked directory to /usr/local/ant.
4. Change that directory’s owner to root.

chown -R root:root /usr/local/ant

5. Add the following lines to /etc/bash.bashrc.

export ANT_HOME=/usr/local/ant
export PATH=${PATH}:${ANT_HOME}/bin

From a new shell, run ant. You should see the following:

Buildfile: build.xml does not exist!
Build failed

Yes, it’s a failure message. But it means Ant is working as expected.

SeaFlow screenshot from Dec. 18, 2008.

Late in 1999, UltiMeth Systems created SeaFlow, a Java-based application for monitoring Seattle-area traffic conditions.  SeaFlow is a powerful desktop version of WSDOT’s web-based traffic map.  It uses the same WSDOT data but shows greater detail, allows customization, and reduces network traffic.

SeaFlow displays vehicle speeds, density, and count metrics.  (WSDOT’s map shows only density which is certainly useful, but not a complete picture.)  The visual color representation of each metric can be customized in SeaFlow.

In times of peak demand, such as December 18, 2008, WSDOT’s website may become overwhelemed and yield partial or missing maps.  SeaFlow’s use of the smaller WSDOT data file — with maps rendered on the client-side — reduces demand on WSDOT’s site and can provide more reliable and complete updates.

SeaFlow is a great Java desktop app — small, efficient, and cross-platform.  Its license is GPL.

• memory usage (object count and size)
• heap size (initial and over time)
• GC metrics (frequency, pause time, and amount freed)

So, now you can answer questions like “how much memory is my app using,” “how much time is being spent doing garbage collection,” and “how big is the heap over time.”

For help analyzing and visualizing a GC log file, be sure to check out GCViewer, a garbage collection and heap analysis tool.

GC logging is enabled using JVM arguments; below are the arguments I use. (Note: the log file specified as file is reset each time the VM starts.)

-verbose:gc -Xloggc:file

Here’s an example GC log file which shows three GC events including one full GC.

[GC 19062K->7172K(60800K), 0.0087190 secs]
[GC 9346K->7525K(60800K), 0.0052810 secs]
[Full GC 7525K->7477K(60800K), 0.0615190 secs]

In the first event, garbage collection takes just under nine thousandths of a second to collect 11,890K memory used by objects (19,062K to 7,172K) while the heap is 60,800K.  The last event is a full GC lasting just over six hundredths of a second to free up 48K with no change in the heap.

Data like this can be invaluable in saving one’s sanity or ending arguments! For further details on garbage collection, see Sun’s GC Portal and Virtual Machine Garbage Collection Tuning documentation.

Let’s use an example to discover just how easy embedding Jetty can be.  Say we have two servlets, one should be mapped to /service/one and the other /service/two, served on port 8080.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Server server = new Server();
Connector connector = new SelectChannelConnector();
connector.setPort(8080);
server.addConnector(connector);
 
ContextHandlerCollection contexts = new ContextHandlerCollection();
server.setHandler(contexts);
 
Context context = new Context(contexts, "/service");
context.addServlet(ServiceOne.class, "/one");
context.addServlet(ServiceTwo.class, "/two");
 
server.start();
server.join();

That’s it; easy.  For information and more examples on embedding Jetty in your Java application, read Embedding Jetty.

And things get more interesting when the code is running on a different or remote machine.  Luckily, Java has a great remote debugging facility. Here’s an example of how I enable remote debugging using command-line arguments.

-agentlib:jdwp=transport=dt_socket,address=8000,server=y,suspend=n

In this example, the remote application will start and run normally while listening in the background for a debugger to connect on port 8000.  For further details on how to enable and configure remote debugging, see Sun’s JPDA Connection and Invocation guide.