Need a tutorial for JNLP?

This first of two articles on JNLP by Mauro Marinilli introduces the Java Network Launching Protocol and illustrates a simple Java application. This article and the second one in this series ("A JNLP Tutorial: Part 2An Example") cover the essentials of the Java Network Launching Protocol (JNLP). They are intended for a wide audience, mainly developers, and especially those new to this technology. At the end of this tutorial, you will have a clearer idea of this Java technology, and hopefully you will be able to use it directly in your applications.

A Web-Centered Protocol
Our story begins at the end. After your application is finished, you are ready to install it onto your client machines. This phase is called the software deployment phase. You should install the proper JRE and copy your JAR files on the client computers. Now, imagine that you publish all the JAR files on your Web site. Then, when everything is ready, you send an email to your customersasking them to point their Web browsers to a given URL. They do so, and after all needed installations take place automatically (the wanted JRE and your JAR files, plus all the other resources you need for your Java application to run), your clients can happily run your program. Then, whenever you update the JAR files on your Web server (say for the 1.2 release), they are automatically installed on client machines the next time your software is launched. So users always have the latest version of your applicationtransparently to them. Everything works through the Web browser and the MIME type mechanism. The very first time users click on your application URL the browser will ask if that associated plug-in is to be installed. That plug-in is a JRE, with a little native executable (the JNLP Client) that will manage the whole protocol on your client's machines. Sun provides this executable freely for the most popular platforms (it is called Java Web Start) but other vendors and open source initiatives provide similar software for all the major OS. Starting from the Java 2 version 1.4 on, it comes included with the standard JRE package.

What Is JNLP All About?

JNLP is an XML-based technology for launching Java executables over the Web. Just imagine that you could specify the classpath resources in your application (images, JAR files, properties, files, etc.), scattered over the Web and giving their URLs, instead of relying on the local file system as normal Java applications do. This feature would give you the capability of deploying your application automatically (that is, installing needed application files and launching them properly) just by declaring where your files are on the Web. Then imagine adding capabilities, such as distinguishing between versions of the same file depending on some local parameter, and so on. That would be great. Imagine you could say "If the locale is 'Chinese,'

use the input framework extension and those JAR files there." Or "If the client platform is 'Windows', launch this installer here before running the application." That would save a lot of coding effort (and such installation problems are very common), and would allow developers to have a great number of new unimagined capabilities. But there is a subtlety. Who will configure the JVM to launch your application this way? The most obvious answer is: another applicationa kind of launcher. This will prepare everything for the JVM to correctly execute your program. Remember that the JVM needs files copied locally on the file system in order to use them. The JNLP protocol consists basically of a set of rules that describe how this launching mechanism should be implemented. Instead of setting the classpath variable, you will write a special XML file (or more than one) that describes carefully what the launcher (called the JNLP Client) should do before setting up a JVM instance to run your application.

What Do I Have to Pay for It?

You must have a JNLP Client already installed on your client machines. That is not a big problem because the JNLP Client installation can be made automatic, so end users will see the client launcher automatically downloaded and installed before the Java application the first time they launch the latter. You can set up the whole mechanism with little trouble for the end user. This is important because you can take advantage of this technology in a transparent way to your users. There are some drawbacks as well, however: y The JNLP Client (for example Java Web Start) has to be launched before your Java application will begin to run. y The user will see a splash screen that appears right before the application ever runs. (This screen informs the user of the JNLP Client initialization time.) End users may ask "What's that screen that appears?" In the second article, you will see all pros and cons of this protocol. Now, you will see how it works.

A First Look
Our first very simple JNLP file is shown in Listing 1.

Listing 1. A Simple JNLP File

01 <?xml version="1.0" encoding="UTF-8"?> 02 <jnlp spec="1.0+" 03 codebase="file:///c:/test/" 04 href="test.jnlp"> 05 06 07 08 09 10 11 12 13 14 15 <information> <title>Hello JNLP</title> <homepage href="http://www.marinilli.com" /> <vendor>Mauro's</vendor> <offline/> </information> <resources> <j2se version="1.2+" /> <jar href="bin/test.jar" /> </resources> <application-desc />

16 </jnlp>

You will see this file better in the second article of this tutorial. Here you just receive an intuitive description of the basic JNLP file syntax. The jnlp element means that this XML file is a JNLP file. Sun provides all the details of the syntax (element definitions, schema, and so on) on its Web site. If you don't know about XML, try this site:http://www.xml.org/xml/. Anyway, you don't need any deep XML knowledge to use JNLP. Just run the following example, and try to modify it to your needs. JNLP is not a difficult protocol, and there are a number of free JNLP packaging tools around (see the links section at the end of the Part 2). The information element provides some data about your application to the JNLP Client program. At lines 1114, the resources element (the core of the protocol, as you will see later) describes all the files that compose your application. After having introduced a little taste of the JNLP syntax, you turn to its general mechanism.

But How Does It Work, Exactly?

The whole protocol works on a classic client-server scheme. The JNLP Client reads the XML file (called the JNLP file), and executes what's written in it, eventually contacting a JNLP server or a normal Web server for some help. The JNLP client is an application that runs locally on the client machine. Popular JNLP Clients are Java Web Start from Sun and OpenJNLP, an open source implementation. Both are free, like the whole technology (that is, you don't have to pay for using JNLP in your programs). The JNLP Server is usually implemented by a servlet, and is used only for some advanced features of the protocol. See the references section at the end of Part 2 for the URL of a free implementation of a JNLP server. See Figure 1 for the details of the launching process. Figure 1 The JNLP mechanism. Indeed, you may have different types of JNLP files, depending on what they describe. You always have a main JNLP file that points to all other files (JAR files, other JNLP files, and so on) as shown in Figure 2. Figure 2 The JNLP mechanism through XML files. Actually, the objective of the JNLP client is to correctly initialize a JVM instance in order to execute the needed application. JNLP allows you to do many more things than specifying where application files should be downloaded. Given the presence of a JNLP client, there is a wide range of features that could be supported by the JNLP protocol, as follows: y A richer client environment at runtime. Developers can use a new API that leverages the underlying JNLP Client, allowing standard runtime services to access system resources. y A secure deployment solution. End users can trust a reliable JNLP Client because it will not allow any harmful behavior by client applications. y Versioning and incremental updates. Each resource can be tagged with a version id and managed accordingly. Incremental updates are obtained using the JARDiff format. y y Multiple JREs management and automatic installation of additional JREs and optional packages. Offline operation. Deployed applications can work even without a connection with the deployment server. Even if it is a somewhat minimal feature, it is widely used in practice.

Automatic installation of native code/libraries. Some Java programs may need some platformspecific support for running.

JNLP Client management console. Although not part of the specifications, the JNLP Client is providing to end users a form of graphical configuration console (for instance, the management console of Java Web Start).

The capability of using platform-dependent facilities such as shortcuts, accelerators, and the like. Deployed applications are integrated on the native OSproviding shortcuts and launching scripts or other platform-dependent mechanisms So your Java application will look like a native application with a little effort.

You will now see a simple yet complete example of JNLP at work.

An Example
You now create your first JNLP file that will launch a dummy application over the Web. If you don't have a Web server, you can modify the example in order to let it work from the local file system as well. The JNLP file in Listing 1 did that. Specifically, see line 3 for an example of how to use the local file system with JNLP.

The Application
Suppose you have an application, a common Java application that you have created before you knew about JNLP. The application is reported in Listing 2.

Listing 2. A Simple Example Application

00 import java.awt.*; 01 import javax.swing.*; 02 import java.awt.event.*; 03 04 /** 05 * An Example Application 06 * "Hello JNLP!" 07 * Just pops up a dialog 08 * 09 * @author Mauro Marinilli 10 * @version 1.0 11 */ 12 public class Example extends JDialog {

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

JPanel panel1 = new JPanel(); BorderLayout borderLayout1 = new BorderLayout(); JLabel jLabel = new JLabel(); JPanel southPanel = new JPanel(); JButton okButton = new JButton();

public Example(Frame frame, String title, boolean modal) { super(frame, title, modal); try { initUI(); pack(); } catch(Exception ex) { ex.printStackTrace(); } }

public Example() { this(null, "", true); }

void initUI() throws Exception { panel1.setLayout(borderLayout1); jLabel.setHorizontalAlignment(SwingConstants.CENTER); jLabel.setHorizontalTextPosition(SwingConstants.CENTER); jLabel.setLabelFor(okButton); jLabel.setText("<html><body><h1>Hello JNLP!"); okButton.setToolTipText("close the example dialog"); okButton.setText("<html><body><tt>OK"); okButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(ActionEvent e) { dismiss(); } }); setTitle("Example Dialog"); addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing(WindowEvent e) { dismiss();

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 } 75

} }); getContentPane().add(panel1); panel1.add(jLabel, BorderLayout.NORTH); panel1.add(southPanel, BorderLayout.SOUTH); southPanel.add(okButton, null); pack(); setVisible(true); }

/** * the Main method */ static public void main(String[] args) { Example e = new Example(); }

/** * dismiss the dialog */ void dismiss() { System.exit(0); }

This is just an example that shows a message dialog box.