How To Make A JAR File

JAR files are Java's version of ZIP files. In fact, JAR uses the ZIP file
format. There are two main uses for JAR files which I shall explain here. The
first use is to compress (make a smaller size) a number of files into one file
(archiving). The second use is to make a Java executable JAR file.

Compress Files To A Java Archive (JAR)

This is by far the most common use for JAR files: to compress multiple files
into a single JAR archive. JAR files can be opened with
WinZip or
WinRar. In terms of Java applications, the ability to archive any number of
source or class files into one single archive represents the biggest advantage -
distributing one file containing hundreds of files is so much easier than
distributing hundreds of files separately!

The jar utility program is run
from the command line (DOS prompt or bash for example, depending on your OS).
Here is how to create a compressed JAR file:

   jar cf archive_name.jar files

Let's look at each part of that command line.

jar

The command to run the jar utility.

CF

Create a new archive with the file name specified. These two options are
from this list of common options:

- c create new archive
- t list table of contents for
archive
- x extract named (or all)
files from archive
- u update existing archive
- v generate verbose output on
standard output
- f specify archive file name
- m include manifest
information from specified manifest file
- 0 store only; use no ZIP
compression
- M do not create a manifest
file for the entries
- i generate index information
for the specified jar files
- C change to the specified
directory and include the following file

Multiple options can be used together. They all must appear after the "jar"
command with no white space separating them.

archive_name.jar

Name of the JAR file. This can only be included if you use the 'f' option.

files

Names of all the files you want to put in the jar file. This could be just
one name or a list of multiple names separated by space. Names can use pattern
matching characters to match multiple files.

Common Examples

Let's say I have a Java application consisting of three source files that I
wish to distribute:

One.java 
Two.java 
Three.java

I also want to call my JAR file
example.jar. To make a JAR file with just
One.java:

   jar CF example.jar One.java

To make a file with all three files listed separately:

   jar CF example.jar One.java Two.java Three.java

To make a file with all three files using a pattern match:

   jar CF example.jar *.java

It goes (almost) without saying that the source files are in the same
directory you are running the jar command in.

Compress Files To An Executable Java Archive (JAR)

It is also possible to make an archive that can be executed (run) by Java and
even by a double click through your OS, if you have it set up correctly. Of
course, to do this you must store compiled class files in the archive, as well
as or instead of Java source files, since Java source files cannot be run!

Continuing the example above, I now compile my Java source files:

   javac *Java

   javac One.java Two.java Three.java

Create An Executable JAR

All JAR files contain something called a manifest file which holds
information Java wants to know. One piece of information a manifest file may
contain is the name of a class that will be run if the JAR file is executed.

The first thing you must do is create a text file that lists the "main" class
- the class that has the main method you want executed when the JAR is executed.
Let's say that Three from the
above example has the main method I want executed. I create a text file called "mainClass.txt"
with the following text:

Main-Class: Three

IMPORTANT: the text file only needs the one
line of text for this purpose. However, the file must end with a blank
line or this will not work, ie the file has two lines in it - the second one is
empty. Note too the class is called "Three" and not "Three.java" (the
file containing the source code) or "Three.class" (the file containing the byte
codes). If your class file is in a package hierarchy, you must use the fully
qualified name of the class (eg "myPackage.MyClass").

I then run the jar utility with this command line:

   jar cmf mainClass.txt example.jar *.class

With this line, I told jar to create a JAR file (option
c) with modifications to the
manifest file (option m) as
specified within mainClass.txt,
naming the JAR file (option f) as
example.jar and including
everything that matches the pattern
*Class

Running An Executable JAR From Command Line

I can run it from the command line like this:

   java -jar example.jar

Running An Executable JAR From Explorer (Windows)

Within Windows, it is also possible to set up Windows Explorer so that you
can double click on the JAR file icon to execute the file (handy for GUI
applications). The first thing you must do is set up the correct association
with the 'javaw.exe' application that JDK for Windows will have.

If there is no JAR file type, create it. Give it a description like

   jar - Executable Jar File

to ensure it sorts under 'jar'. Create or edit the action called "open" and
associate it with the following action:

   "C:Javajdk1.4.0binjavaw.exe" -jar "%1"

Of course, you will replace "C:\Java\jdk1.4.0\bin\javaw.exe" with whatever
path is correct on your machine.

IMPORTANT: include the double quotes to take
care of names with spaces.

Java Code

Wednesday, February 14, 2007