Sets the java.class.path property before run

Author: notoon

pom.xml

@@ -19,7 +19,7 @@
 
     <groupId>org.seedstack</groupId>
     <artifactId>seedstack-maven-plugin</artifactId>
-    <version>2.4.2-SNAPSHOT</version>
+    <version>2.4.3-SNAPSHOT</version>
     <packaging>maven-plugin</packaging>
 
     <properties>

src/license/THIRD-PARTY.properties

@@ -12,7 +12,7 @@
 # Please fill the missing licenses for dependencies :
 #
 #
-#Tue Apr 18 16:56:02 CEST 2017
+#Tue May 02 16:01:09 CEST 2017
 classworlds--classworlds--1.1-alpha-2=
 commons-collections--commons-collections--3.1=
 dom4j--dom4j--1.6.1=

src/main/java/org/seedstack/maven/AbstractExecutableMojo.java

@@ -31,25 +31,35 @@ public class AbstractExecutableMojo extends AbstractMojo {
 
     @Parameter(defaultValue = "${project}", required = true, readonly = true)
     private MavenProject project;
+
     @Parameter(defaultValue = "${project.build.outputDirectory}", required = true)
     private File classesDirectory;
+
     @Parameter(defaultValue = "${project.build.testOutputDirectory}", required = true)
     private File testClassesDirectory;
+
     @Parameter(property = "args")
     private String args;
 
     private final IsolatedThreadGroup isolatedThreadGroup = new IsolatedThreadGroup("seed-app");
+
     private final Object monitor = new Object();
+
     private boolean testMode = false;
+
     protected Runnable runnable;
 
     @Override
     public void execute() throws MojoExecutionException, MojoFailureException {
         // Create an isolated thread
         Thread bootstrapThread = new Thread(isolatedThreadGroup, runnable, "main");
+        File[] classPathFiles = getClassPathFiles();
+
+        // Set the system property for proper detection of classpath
+        System.setProperty("java.class.path", buildCpProperty(classPathFiles));
 
         // Start the launcher thread
-        bootstrapThread.setContextClassLoader(new URLClassLoader(getClassPathUrls()));
+        bootstrapThread.setContextClassLoader(buildClassLoader(classPathFiles));
         bootstrapThread.start();
 
         // Wait for the application to launch
@@ -72,6 +82,30 @@ public void execute() throws MojoExecutionException, MojoFailureException {
         joinNonDaemonThreads(isolatedThreadGroup);
     }
 
+    private ClassLoader buildClassLoader(File[] classPathFiles) throws MojoExecutionException {
+        URL[] classPathUrls = new URL[classPathFiles.length];
+        for (int i = 0; i < classPathFiles.length; i++) {
+            try {
+                classPathUrls[i] = classPathFiles[i].toURI().toURL();
+            } catch (MalformedURLException e) {
+                throw new MojoExecutionException("Unable to create URL from " + classPathFiles[i]);
+            }
+        }
+        return new URLClassLoader(classPathUrls);
+    }
+
+    private String buildCpProperty(File[] classPathFiles) {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = 0; i < classPathFiles.length; i++) {
+            File classPathFile = classPathFiles[i];
+            stringBuilder.append(classPathFile);
+            if (i < classPathFiles.length - 1) {
+                stringBuilder.append(File.pathSeparator);
+            }
+        }
+        return stringBuilder.toString();
+    }
+
     protected void enableTestMode() {
         this.testMode = true;
     }
@@ -122,46 +156,46 @@ private Thread[] getGroupThreads(final ThreadGroup group) {
         return java.util.Arrays.copyOf(threads, n);
     }
 
-    private URL[] getClassPathUrls() throws MojoExecutionException {
-        List<URL> urls = new ArrayList<URL>();
+    private File[] getClassPathFiles() throws MojoExecutionException {
+        List<File> files = new ArrayList<>();
 
         try {
             if (testMode) {
                 // Project test resources
-                addResources(this.testClassesDirectory, this.project.getTestResources(), urls);
+                addResources(this.testClassesDirectory, this.project.getTestResources(), files);
 
                 // Project test classes
-                urls.add(this.testClassesDirectory.toURI().toURL());
+                files.add(this.testClassesDirectory);
             }
 
             // Project resources
-            addResources(this.classesDirectory, this.project.getResources(), urls);
+            addResources(this.classesDirectory, this.project.getResources(), files);
 
             // Project classes
-            urls.add(this.classesDirectory.toURI().toURL());
+            files.add(this.classesDirectory);
 
             // Project dependencies (scope is dependent upon the @Mojo annotation and the already executed phase)
-            addArtifacts(this.project.getArtifacts(), urls);
+            addArtifacts(this.project.getArtifacts(), files);
         } catch (MalformedURLException e) {
             throw new MojoExecutionException("Unable to build classpath", e);
         }
 
-        return urls.toArray(new URL[urls.size()]);
+        return files.toArray(new File[files.size()]);
     }
 
-    private void addArtifacts(Collection<Artifact> artifacts, List<URL> urls) throws MalformedURLException {
+    private void addArtifacts(Collection<Artifact> artifacts, List<File> files) throws MalformedURLException {
         for (Artifact artifact : artifacts) {
             File file = artifact.getFile();
             if (file.getName().endsWith(".jar")) {
-                urls.add(file.toURI().toURL());
+                files.add(file);
             }
         }
     }
 
-    private void addResources(File classesDirectory, List<Resource> resources, List<URL> urls) throws MalformedURLException {
+    private void addResources(File classesDirectory, List<Resource> resources, List<File> files) throws MalformedURLException {
         for (Resource resource : resources) {
             File directory = new File(resource.getDirectory());
-            urls.add(directory.toURI().toURL());
+            files.add(directory);
             removeDuplicatesFromOutputDirectory(classesDirectory, directory);
         }
     }