Jar application referencing Jars into its own Jar

I'm not sure I follow you but I'll take a stab at it:

If I have 2 jar files (each with routines the other may need to call) ... I have to do a couple of things:

1) Each jar file must have a manifest and in that manifest the jar files should reference each other:

Jar 1 needs functions in jar 2:

Class-Path: jar2.jar <-- some entry in Jar1's manifest

Jar 2 needs functions in jar 1:

Class-Path: jar1.jar <-- some entry in Jar2's manifest

I can't think of a good reason why you would store a "jar in a jar" at all....it would be very inefficient and it's not necessary.

Now, *IF* you mean you want to load and instantiate some object from classes stored in a .jar file, that is a totally different thing. It can be done, but man it ain't easy and it ain't pretty.

smg123 at 2007-7-2 13:56:11 >

Well, one thing you can do is UNjar all the jar files you want to reside together. (jar -xf jarname) - but do it in some base directory (perhaps called \stage). Under that directory make another directory (perhaps \MyApp).

*Copy all jar files to \stage and issue that jar -xf command

As you unpack, you will create the directory structures in the jars under the \MyApp path. Once all the jars are unpacked. re-pack them in a single jar using the jar command:

jar -cvfm Whatever.jar manifest.mf -C stage .

Again, you issue this command from the \stage directory. When all is done, you'll have ONE jar called "Whatever.jar" in the \stage directory. The only catch is make sure your manifest is set up right (which I know you already know....)

smg123 at 2007-7-2 13:56:11 >

Ron,

You are right. Is it possible to nest jars into a war in J2EE. Unhappily I am not using J2EE, just plain J2SE, and it is not my intention to instantiate a new class loader object to control all that things.

I supposed J2SE provides some way to do that kind of things automatically, but it seams there is not such a way.

Anyway thank you for your answer. Good hints.

- Daniel

Dmazzuca at 2007-7-2 13:56:11 >

I think you can do it. There are classes (and a package) for reading jars and jar entries from wihtin java code. So what you do is read an entry that is a jar, and then read its entries. At that point you have the class files and can use a class loader to load the bytes.

there is some discussion in this forum about reading and writing jars programmatically. Find that and also info on classloaders and i'll bet you can do it.

6tr6tr at 2007-7-2 13:56:14 >

I know this is an ancient topic, and that my included solution IS NOT exactly what the original author was looking for, but it does work.

As a further disclaimer, might I also add that I realize that this idea of nesting jars inside of jars has been hotly debated and that many believe it is a poor idea. Regardless, here is the solution I came up with....

Usage: java StandAlone.Builder MainClassName NewJar jar1 [jar2] [...]

This will create a jar file capable of running alone via "java -jar".

I managed to piece this code together out of several partial solutions I found on the web. The majority of the code included below I found in snippets elsewhere on the web (so if some of it is yours, thanks!). This is, however, the first completely working solution I've seen.

File StandAlone/Builder.java

--

package StandAlone;

import java.net.URLClassLoader;

import java.net.URL;

import java.io.*;

import java.util.*;

import java.util.jar.*;

public class Builder

{

static private void copyFile( OutputStream out, InputStream in )

throws IOException

{

byte buffer[] = new byte[4096];

while (true) {

int r = in.read( buffer );

if (r<=0) {

break;

}

out.write( buffer, 0, r );

}

}

static private void copyFile( OutputStream out, String infile )

throws IOException

{

FileInputStream fin = new FileInputStream( infile );

copyFile( out, fin );

fin.close();

}

static private void addFile(JarOutputStream jout, String path) throws IOException

{

JarEntry je = new JarEntry( path );

jout.putNextEntry( je );

System.out.println( "adding " + path );

copyFile( jout, path );

jout.closeEntry();

}

static private void addFile(JarOutputStream jout, String path, InputStream in) throws IOException

{

JarEntry je = new JarEntry( path );

jout.putNextEntry( je );

System.out.println( "adding " + path );

copyFile( jout, in );

jout.closeEntry();

}

static private void addJar(JarOutputStream jout, String path) throws IOException

{

String fname = path;

int index = fname.lastIndexOf("/");

if(index >= 0)

{

fname = fname.substring(index);

}

fname = "jars/" + fname;

JarEntry je = new JarEntry( fname );

jout.putNextEntry( je );

System.out.println( "adding " + fname );

copyFile( jout, path );

jout.closeEntry();

}

static public void main(String args[]) throws Exception

{

if(args.length < 3)

{

System.err.println("Usage: java StandAlone.Builder MainClassName NewJar jar1 [jar2] [...]");

System.exit(1);

}

String manifest = "Manifest-Version: 1.0\nMain-Class: StandAlone.Runner\nClass-Path: ";

for(int i=2; i<args.length; ++i)

{

manifest += args[i];

manifest += " ";

}

manifest += "\n";

FileOutputStream fout = new FileOutputStream( args[1] );

JarOutputStream jout = new JarOutputStream( fout , new Manifest(new ByteArrayInputStream(manifest.getBytes())));

String props = "MainClass="+args[0]+"\n";

addFile( jout, "StandAlone/Settings.properties", new ByteArrayInputStream(props.getBytes()) );

addFile( jout, "StandAlone/Runner.class" );

for(int i=2; i><args.length; ++i)

{

addJar(jout, args[i]);

}

jout.close();

fout.close();

}

}

File StandAlone/Runner.java

--

package StandAlone;

import java.net.URLClassLoader;

import java.net.URL;

import java.lang.reflect.*;

import java.util.ResourceBundle;

public class Runner

{

public static void main(String args[]) throws Exception

{

ResourceBundle props = ResourceBundle.getBundle("StandAlone.Settings");

String mainClassName = props.getString("MainClass");

URL urls[] = new URL[] { Runner.class.getResource("/jars/") };

URLClassLoader classLoader = URLClassLoader.newInstance(urls);

Class mainClass = Class.forName(mainClassName, true, classLoader);

Class argTypes[] = new Class[] { args.getClass() };

Method m = mainClass.getMethod("main", argTypes);

m.setAccessible(true);

int mods = m.getModifiers();

if (m.getReturnType() != void.class || !Modifier.isStatic(mods) ||

!Modifier.isPublic(mods)) {

throw new NoSuchMethodException("main");

}

try {

m.invoke(null, new Object[] { args });

} catch (IllegalAccessException e) {

// This should not happen, as we have disabled access checks

}

}

}

>

wyrickre at 2007-7-2 13:56:14 >