Groovy’s Grape dependency management is pretty handy if you just want to write Groovy scripts and don’t want to use a full-blown dependency manager (gradle, maven). You just annotate @Grab to your Groovy script and it downloads the defined libs (powered by Ivy).
In some constellations, pain starts when the systemclassloader doesn’t know about the loaded classes/libs.
This can be fixed by setting @GrabConfig(systemClassLoader = true) (see e.g. mrhaki). But it’s getting really ugly when you don’t have a suitable ClassLoader (see groovy.grape.GrapeIvy <isValidTargetClassLoaderClass>) like GroovyClassLoader or RootLoader.
You’ll find this situation when running compiled groovy-code with java (e.g. when deploying your groovy code in a fatjar/shadowjar/uberjar). What you actually can do is to instantiate a GroovyClassLoader and call Grape.grab using this one. But you’ll end up in the same situation when you have to call @GrabConfig(systemClassLoader = true), like I said above. Running compiled groovy code with java means your SystemClassLoader is not a suitable one. You just can’t replace existing loaders by a GroovyClassLoader or inject it somehow somewhere.
I had this situation the other day in my open-source project Grip. I’m deploying with gradle and the shadowJar-plugin, so I run the compiled code with java and NOT groovy. Grip has an Interpreter to execute groovy scripts with some extras like scheduling, easy DB access and so on. And I want to provide grab in the scripts to allow users to import whatever they want.
Due to the fact that you can use Grape.grab with your own GroovyClassLoader, the basic mechanism works (dependencies are getting resolved). But what needs to be done is to transfer the information about the downloaded libs to the existing SystemClassLoader.
This is a hack, of course. But to me there’s no other way to deal with it (except to renounce Grape.grab):
After some research, I found a way to add libs to the SystemClassLoader. See ClassPathHacker.java: http://www.javafaq.nu/java-example-code-895.html
Now having ClassPathHacker, I was able to add the resolved dependencies
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
def groovyLoader = new GroovyClassLoader() //grab dependencies using a GroovyClassLoader Grape.grab(classLoader: groovyLoader, dependencies) //using org.reflections.util.ClasspathHelper to get the URLs def urls = ClasspathHelper.forClassLoader(groovyLoader).toArray() as URL[] //and finally adding the URLs to the SystemClassLoader with ClassPathHacker def cph = new ClassPathHacker() urls.each { URL url -> if (url.file.endsWith('jar')) { cph.addFile(url.file) } } |
That’s it. Libs loaded by Grape are now known by the SystemClassLoader.
When calling ClasspathHelper.forClassLoader, some errors appeard in the logfile: could not create Vfs.Dir from url (see https://github.com/ronmamo/reflections/issues/80). Those can be avoided by using this Helper https://gist.github.com/nonrational/287ed109bb0852f982e8
Find the whole implementation in package de.metacode.grip.core.classloaderhack in the project https://github.com/codeeraser/grip