Question

in my Java project I am using an H2 in-memory database, for which I have to load the JDBC driver when I initialize my application. I want/need to load the H2 .jar file dynamically, so I do the following:

String classname = "org.h2.Driver";
URL u = new URL("jar:file:libs/h2.jar!/");
URLClassLoader ucl = new URLClassLoader(new URL[] { u });
Driver d = (Driver) Class.forName(classname, true, ucl).newInstance();
DriverManager.registerDriver(new DriverShim(d));

When I put the H2 .jar file into a “libs” folder outside my Java source code folder (that is, in Eclipse, this “libs” directory is on the same level as the “src” folder), then this approach works fine. However, unfortunately I have to put this H2 .jar file into a folder within the source code folder tree, but below the main class folder.

For example, my Java package structure looks like this in Eclipse:

<project>/src/my/app/MyApp.java              // main class of my application
<project>/src/my/app/sub/package/h2.jar      // how to access this?
<project>/libs/h2.jar                        // loading from here works

I know this is stupid, but unfortunately I have to work with this strange setup. But what I don’t know: how can I edit my Java code (listed above) in order to work with this setup?

EDIT: This has to work outside Eclipse as well, so adding the JAR file to the Java Build Path in Eclipse is no option for me.

EDIT2: I already tried to load “jar:file:my/app/sub/package/h2.jar!/”, but that did not work for me.

Thanks in advance for all helpful ideas!

Kind regards, Matthias

Answer 1

In some frameworks referring to files inside JARs can be done using the classpath: prefix. I doubt URLClassLoader supports it natively, but it’s worth a try (e.g. classpath:/my/app/sub/package/h2.jar). But since that doesn’t work with URLClassLoader, here are other ways:

One way to do it would be to write your own ClassLoader which reads the JAR file from classpath (using getResourceAsStream), uncompresses it (using ZipInputStream) to memory (e.g. a map of byte arrays) and loads the classes from there.

Another, slightly easier way, is to read the JAR file from classpath and write it into a temporary file. Then you can use the plain URLClassLoader to load classes from it. This has the disadvantage that the file must be written to a file and the file probably cannot be removed until the JVM exits (unless using Java 7 or higher).

I’m using the second approach (copying to a temp file) in one project, though I’m using it to launch an external process. I would be curious to hear why you have such a requirement. If it’s just a matter of having the whole application in one JAR, there are numerous simpler methods for achieving that (Maven Assembly Plugin, Maven Shade Plugin, Jar Jar Links, One-JAR to name a few).

---

No it’s not a homework, but an online build system that uses my classes under my/app/* and several other classes (not from me) to automatically build the whole solution. Anyway, I can’t give you more details on the internals of this system, as I don’t know them. As said, I simply have to live with it, and that is why I am asking here…

Sounds like you are working in a WTF environment (does it have a name?), so here are some ways to start hacking around it:

Find out more about your environment, especially absolute file paths of the following: directory where the source files are saved, directory where the generated .class files are saved, and the current working directory when the program is run.

If you can get any kind of output of what your program prints during runtime, you can put into your application some debug code where you use File.listFiles() to crawl the machine’s directory trees. If you can get output only from what happens when compiling, it might be possible to execute your own code during compile by creating your own annotation processor (apt is part of javac since Java 6), though I’m not sure whether the annotation processor must be compiled first separately.

The working directory can be read from the user.dir system property and the location of class files can be probably gotten from the java.class.path system property (unless custom class loaders are used). There is no guarantee that a JAR file in the source directory would be copied to the classpath, so you might need to do some looking around.

Then when you know the file path of the JAR file, then you can get an URL to it using new File("path/to/h2.jar").toURI().toURL() which you can then pass to URLClassLoader.

If nothing else works, upload the source code of the libraries and compile them together with your project.

In the long run, try to replace the WTF build environment with one that uses a standard build tool (such as Maven) and a common CI server (such as Jenkins). It’s normal for projects to have lots of library dependencies, so you shouldn’t need to hack around a build environment to use them.