Add support for multi-release jar in Maven Mojo.

Author: raphw

byte-buddy-gradle-plugin/src/main/java/net/bytebuddy/build/gradle/AbstractByteBuddyTask.java

@@ -632,8 +632,8 @@ protected static ClassLoader of(ClassLoader classLoader, @MaybeNull Iterable<Fil
             for (File file : discoverySet) {
                 try {
                     urls.add(file.toURI().toURL());
-                } catch (MalformedURLException e) {
-                    throw new IllegalStateException(e);
+                } catch (MalformedURLException exception) {
+                    throw new IllegalStateException(exception);
                 }
             }
             return urls.isEmpty()

byte-buddy-gradle-plugin/src/main/java/net/bytebuddy/build/gradle/ObjectFactory.java

@@ -137,16 +137,16 @@ protected ForApi4CapableGradle(Method getObjects, Method newInstance) {
             public Object newInstance(Project project, Class<?> type, Object... argument) {
                 try {
                     return newInstance.invoke(getObjects.invoke(project), type, argument);
-                } catch (IllegalAccessException e) {
-                    throw new IllegalStateException(e);
-                } catch (InvocationTargetException e) {
-                    Throwable cause = e.getCause();
+                } catch (IllegalAccessException exception) {
+                    throw new IllegalStateException(exception);
+                } catch (InvocationTargetException exception) {
+                    Throwable cause = exception.getCause();
                     if (cause instanceof RuntimeException) {
                         throw (RuntimeException) cause;
                     } else if (cause instanceof Error) {
                         throw (Error) cause;
                     } else {
-                        throw new RuntimeException(e);
+                        throw new RuntimeException(exception);
                     }
                 }
             }

byte-buddy-gradle-plugin/src/main/java/net/bytebuddy/build/gradle/Transformation.java

@@ -194,8 +194,8 @@ protected Class<? extends Plugin> toPlugin(@MaybeNull ClassLoader classLoader) {
                     throw new GradleException(type.getName() + " does not implement " + Plugin.class.getName());
                 }
                 return type;
-            } catch (ClassNotFoundException e) {
-                throw new GradleException("Cannot locate plugin class " + pluginName + " by its name", e);
+            } catch (ClassNotFoundException exception) {
+                throw new GradleException("Cannot locate plugin class " + pluginName + " by its name", exception);
             }
         } else {
             throw new GradleException("No plugin or plugin name defined for transformation");
@@ -266,8 +266,8 @@ public static Class<?> wrap(ClassLoader parent, Class<?> type) {
                 System.out.println(Plugin.class.getClassLoader());
                 System.out.println(parent);
                 return t;
-            } catch (ClassNotFoundException e) {
-                throw new IllegalStateException("Failed to wrap plugin type " + type.getName(), e);
+            } catch (ClassNotFoundException exception) {
+                throw new IllegalStateException("Failed to wrap plugin type " + type.getName(), exception);
             }
         }
 

byte-buddy-maven-plugin/src/main/java/net/bytebuddy/build/maven/ByteBuddyMojo.java

@@ -52,12 +52,16 @@
 import org.sonatype.plexus.build.incremental.BuildContext;
 
 import java.io.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.*;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
+import java.util.zip.ZipFile;
 
 /**
  * A Maven plugin for applying Byte Buddy transformations during a build.
@@ -74,6 +78,26 @@ public abstract class ByteBuddyMojo extends AbstractMojo {
      */
     private static final String JAVA_CLASS_EXTENSION = ".class";
 
+    /**
+     * A dispatcher for creating a {@link JarFile}.
+     */
+    private static final JarFileFactory JAR_FILE_FACTORY;
+
+    /*
+     * Creates a factory for creating a jar file.
+     */
+    static {
+        JarFileFactory jarFileFactory;
+        try {
+            Method runtimeVersion = JarFile.class.getMethod("runtimeVersion");
+            Constructor<JarFile> constructor = JarFile.class.getConstructor(File.class, boolean.class, int.class, runtimeVersion.getReturnType());
+            jarFileFactory = new JarFileFactory.ForMultiReleaseVm(constructor, runtimeVersion);
+        } catch (Exception ignored) {
+            jarFileFactory = JarFileFactory.ForLegacyVm.INSTANCE;
+        }
+        JAR_FILE_FACTORY = jarFileFactory;
+    }
+
     /**
      * The Maven project.
      */
@@ -267,7 +291,7 @@ public void execute() throws MojoExecutionException, MojoFailureException {
                     for (String element : elements) {
                         File artifact = new File(element);
                         if (artifact.isFile()) {
-                            JarFile file = new JarFile(artifact);
+                            JarFile file = JAR_FILE_FACTORY.make(artifact);
                             try {
                                 JarEntry entry = file.getJarEntry(Plugin.Engine.Default.PLUGIN_FILE);
                                 if (entry != null) {
@@ -889,6 +913,9 @@ protected List<String> resolveImplicitClassPathElements() throws MojoFailureExce
         }
     }
 
+    /**
+     * Transforms all jars for a folder containing jar files, typically project dependencies.
+     */
     @Mojo(name = "transform-dependencies", defaultPhase = LifecyclePhase.PROCESS_CLASSES, threadSafe = true, requiresDependencyResolution = ResolutionScope.COMPILE)
     public static class ForDependencyFolder extends ByteBuddyMojo {
 
@@ -941,6 +968,90 @@ protected void apply(List<Transformer> transformers, List<String> elements, Map<
         }
     }
 
+    /**
+     * A factory for creating {@link JarFile}.
+     */
+    protected interface JarFileFactory {
+
+        /**
+         * Creates a {@link JarFile}.
+         *
+         * @param file The file to represent as a {@link JarFile}.
+         * @return Returns a {@link JarFile}.
+         * @throws IOException If an I/O exception occurs.
+         */
+        JarFile make(File file) throws IOException;
+
+        /**
+         * A dispatcher for a legacy VM that does not support multi-release jars.
+         */
+        enum ForLegacyVm implements JarFileFactory {
+
+            /**
+             * The singleton instance.
+             */
+            INSTANCE;
+
+            /**
+             * {@inheritDoc}
+             */
+            public JarFile make(File file) throws IOException {
+                return new JarFile(file, false, ZipFile.OPEN_READ);
+            }
+        }
+
+        /**
+         * A factory for creating a {@link JarFile} which resolves multi-release properties.
+         */
+        class ForMultiReleaseVm implements JarFileFactory {
+
+            /**
+             * The {@code JarFile#JarFile(File, boolean, int, Runtime.Version)} constructor.
+             */
+            private final Constructor<JarFile> constructor;
+
+            /**
+             * The {@code JarFile#runtimeVersion()} method.
+             */
+            private final Method runtimeVersion;
+
+            /**
+             * Creates a jar file factory that is multi-release capable.
+             *
+             * @param constructor    The {@code JarFile#JarFile(File, boolean, int, Runtime.Version)} constructor.
+             * @param runtimeVersion The {@code JarFile#runtimeVersion()} method.
+             */
+            protected ForMultiReleaseVm(Constructor<JarFile> constructor, Method runtimeVersion) {
+                this.constructor = constructor;
+                this.runtimeVersion = runtimeVersion;
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public JarFile make(File file) throws IOException {
+                try {
+                    return constructor.newInstance(file, false, ZipFile.OPEN_READ, runtimeVersion.invoke(null));
+                } catch (IllegalAccessException exception) {
+                    throw new IllegalStateException(exception);
+                } catch (InstantiationException exception) {
+                    throw new IllegalStateException(exception);
+                } catch (InvocationTargetException exception) {
+                    Throwable cause = exception.getCause();
+                    if (cause instanceof RuntimeException) {
+                        throw (RuntimeException) cause;
+                    } else if (cause instanceof Error) {
+                        throw (Error) cause;
+                    } else if (cause instanceof IOException) {
+                        throw (IOException) cause;
+                    } else {
+                        throw new RuntimeException(exception);
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * A {@link BuildLogger} implementation for a Maven {@link Log}.
      */