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 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.

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.

-Dcom.sun.management.jmxremote.port=port
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false

For further details on JMX and how to configure access, consult Sun’s Java JMX Management Guide.

Using UnitFormat.label(), we can override the String representation to something more compatible, useful, or just different.  Here’s how I changed degrees Celsius to be more compatible with my co-workers Windows systems.

UnitFormat.getInstance().label(SI.CELSIUS, "\u00B0" + "C");

And here’s how I changed knots to be represented by kts instead of the default, kn.

UnitFormat.getInstance().label(NonSI.KNOT, "kts");