merge multiple jars into one jar?

[Geoffrey Falk]

I need to merge a couple jar files into one jar using Ant.

It is easy to do this for a fixed list of jarfiles, using <zipfileset>. The problem is, I want to do this in a generic way, and avoid hard-coding the names of the jar files.

Here is a section of my build file:

 
  <property name="dependencies" value="dependency-A.jar dependency-B.jar dependency-C.jar" />
 
  <classpath id="build.classpath">
    <fileset dir="lib" includes="${dependencies}" />
  </classpath>
 
  <jar jarfile="myapp.jar" manifest="src/MANIFEST.MF">
    <fileset dir="classes" includes="**/*.class" />
    <zipfileset src="lib/dependency-A.jar" excludes="META-INF/*" />
    <zipfileset src="lib/dependency-B.jar" excludes="META-INF/*" />
    <zipfileset src="lib/dependency-C.jar" excludes="META-INF/*" />
  </jar>

I have to specify the dependencies twice: Once for my build classpath, and once in the jar task. It would be nice to use the ${dependencies} property for both. Unfortunately I don't see how to make the <zipfileset> do that.

Thanks
Geoffrey

[Andy Hahn]

I wouldn't recommend doing this. However to do this, you will have to either hard code the jar names in the mainfest file OR find a neat way to read the jar file names (using java.io) and build up the manifest file.

[Geoffrey Falk]

Why don't you recommend doing this? The obvious purpose is just to make a single application file (executable jar) that can run with "java -jar". My program has dependencies on some other jars (all open source). Merging everything into one jar seems to be the simplest way. As long as I obey the open source license, there aren't any legal issues.

I did not put the classpath in the Manifest file. I am not doing anything fancy with classloaders. The only thing I specified in the Manifest is the Main-Class.

Anyways, since I couldn't think of a way to do this using <zipfileset>, now I am expanding all the jars into a temp directory and then jarring it up again. This is a bit slower but it works.

Thanks
Geoffrey

[Glenn Seg]

I see that in your orignal approach (naming each file) and in the new approach, you are omitting the data in the META-INF directory. Actually, in the second way, the contents of the META-INF directory gets overwritten for each jar file that is expanded.

Are you planning to merge the manifest files in a future revision of the build file? In addition to having possible legal problems (dependent on the jar files you are using), you are losing data that may or may not be important. Do you think that not having the manifest information will cause problems?

The reason I ask is that I am doing the same thing and I can't afford for this to cause some unforseen problem.

[Lewin Chan]

http://one-jar.sourceforge.net/

This achieves what you specified as your aim. As to how you can do it in ant generically...

Well, you could wrap the ant build in a shell script and do.

list=`ls -1A`
for dir in $list
do
  jarfiles=`echo ${dir}`
done
$ANT_HOME/bin/ant -Djar.files=${jarfiles} -f ${BUILDFILE}

And then do something with the foreach task from ant-contrib. Or keeping it all anty you just write your own task to do it. For instance :-

 
/** A custom unjar task that performs the following tasks.
 *  <ul>
 *  <li>Un-Jar a number of jars, based on some fileset and filter</li>
 *  <li>Read any MANIFEST.MF file that is present from the unjarred file</li>
 *  <li>Re-write the manifest for all the jars that have been unjarred</li>
 *  </ul>
 * @author lchan
 */
public class Unjar extends Task {
  private String mainClass;
  private List filesets = new LinkedList();
  private String filterString;
  private Manifest manifest;
  private File manifestOutput;
  private File destDir;
 
  /** @see Object#Object()
   *
   *
   */
  public Unjar() {
    filterString = "*";
  }
 
  /**
   *  @see org.apache.tools.ant.Task#init()
   */
  public void init() throws BuildException {
   ;
  }
 
  /** Add a fileset to be processed by this task.
   *
   * @param fs the fileset to add.
   */
  public void addFileset(FileSet fs) {
    filesets.add(fs);
  }
 
  /**
   *  @see org.apache.tools.ant.Task#execute()
   */
  public void execute() throws BuildException {
    try {
      GlobFilenameFilter fileFilter = new GlobFilenameFilter(filterString);
      ArrayList fileList = new ArrayList();
 
      manifest = new Manifest();
      File parent = null;
      for (Iterator it = filesets.iterator(); it.hasNext() ; )  {
        FileSet fs = (FileSet) it.next();
        DirectoryScanner ds = fs.getDirectoryScanner(getProject());
        parent = ds.getBasedir();
        String[] files = ds.getIncludedFiles();
        for (int i = 0; i < files.length; i++) {
          log(files[i], Project.MSG_INFO);
          if (fileFilter.accept(new File(files[i]))) {
            fileList.add(files[i]);
          }
        }
      }
      log(fileList.toString(), Project.MSG_INFO);
      for (Iterator it = fileList.iterator(); it.hasNext() ; )  {
        String filename = it.next().toString();
        performUnjar(new File(parent, filename));
        readCurrentManifest();
      }
      writeFinalManifest();
    }
    catch (IOException e) {
      BuildException be = new BuildException(e.getMessage());
      be.initCause(e);
      throw be;
    }
  }
  /** Set the filter for this Task.
   *
   * @param s the filter, matching a Glob style regexp.
   */
  public void setFilter(String s) {
    filterString = s;
  }
 
  /** Set the destination where the jars will be unjarred to.
   *
   * @param f the destination directory.
   */
  public void setDest(File f) {
    destDir = f;
  }
 
  /** Set the manifest that will be written.
   *
   * @param f the manifest file that will be written.
   */
  public void setManifest(File f) {
    manifestOutput = f;
  }
 
  /** Set the Main-Class that will be written to the Manifest.
   *  <p>If not set, then any that are merged from the Manifest files are used.
   * @param s the main class.
   */
  public void setMain(String s) {
    mainClass = s;
  }
 
  private void performUnjar(File file) throws BuildException {
    Expand unjar = new Expand();
    unjar.setProject(getProject());
    unjar.setTaskName(this.getTaskName());
    unjar.setLocation(this.getLocation());
    unjar.setDest(destDir);
    unjar.setSrc(file);
    unjar.setOverwrite(true);
    unjar.execute();
  }
 
  /** Read the manifest that was just extracted.
   *
   * @throws IOException
   */
  private void readCurrentManifest() throws IOException {
    File manifestFile =
      new File(
        destDir.getCanonicalFile()
          + File.separator
          + "META-INF"
          + File.separator
          + "MANIFEST.MF");
    if (manifestFile.exists()) {
      FileInputStream input = new FileInputStream(manifestFile);
      manifest.read(input);
      input.close();
    }
  }
 
  private void writeFinalManifest() throws IOException {
    Attributes a = manifest.getMainAttributes();
    a.putValue("Built-By", getProject().getProperty("user.name"));
    a.remove(new Attributes.Name("Ant-Version"));
    a.remove(new Attributes.Name("Created-By"));
    if (mainClass != null) {
      a.putValue("Main-Class", mainClass);
    }
    FileOutputStream output = new FileOutputStream(manifestOutput);
    manifest.write(output);
    output.close();
  }
}

Compile errors are yours to fix
[ September 21, 2005: Message edited by: Lewin Chan ]

[Glenn Seg]

Thanks...I will take a look at the link you posted. Also, there is a 'Manifest' class in the Ant jar file that has a merge method.