Class ExecJavaMojo

  • All Implemented Interfaces:
    org.apache.maven.plugin.ContextEnabled, org.apache.maven.plugin.Mojo

    @Mojo(name="java",
          threadSafe=true,
          requiresDependencyResolution=TEST)
    public class ExecJavaMojo
    extends AbstractExecMojo
    Executes the supplied java class in the current VM with the enclosing project's dependencies as classpath.
    Since:
    1.0
    • Field Detail

      • artifactResolver

        @Component
        private org.apache.maven.artifact.resolver.ArtifactResolver artifactResolver
      • artifactFactory

        @Component
        private org.apache.maven.artifact.factory.ArtifactFactory artifactFactory
      • metadataSource

        @Component
        private org.apache.maven.artifact.metadata.ArtifactMetadataSource metadataSource
      • localRepository

        @Parameter(readonly=true,
                   required=true,
                   defaultValue="${localRepository}")
        private org.apache.maven.artifact.repository.ArtifactRepository localRepository
        Since:
        1.0
      • remoteRepositories

        @Parameter(readonly=true,
                   required=true,
                   defaultValue="${project.remoteArtifactRepositories}")
        private java.util.List<org.apache.maven.artifact.repository.ArtifactRepository> remoteRepositories
        Since:
        1.1-beta-1
      • projectBuilder

        @Component
        private org.apache.maven.project.MavenProjectBuilder projectBuilder
        Since:
        1.0
      • pluginDependencies

        @Parameter(readonly=true,
                   defaultValue="${plugin.artifacts}")
        private java.util.List<org.apache.maven.artifact.Artifact> pluginDependencies
        Since:
        1.1-beta-1
      • mainClass

        @Parameter(required=true,
                   property="exec.mainClass")
        private java.lang.String mainClass
        The main class to execute.
        Since:
        1.0
      • arguments

        @Parameter(property="exec.arguments")
        private java.lang.String[] arguments
        The class arguments.
        Since:
        1.0
      • systemProperties

        @Parameter
        private Property[] systemProperties
        A list of system properties to be passed. Note: as the execution is not forked, some system properties required by the JVM cannot be passed here. Use MAVEN_OPTS or the exec:exec instead. See the user guide for more information.
        Since:
        1.0
      • keepAlive

        @Parameter(property="exec.keepAlive",
                   defaultValue="false")
        @Deprecated
        private boolean keepAlive
        Deprecated.
        since 1.1-alpha-1
        Indicates if mojo should be kept running after the mainclass terminates. Use full for server like apps with daemon threads.
        Since:
        1.0
      • includeProjectDependencies

        @Parameter(property="exec.includeProjectDependencies",
                   defaultValue="true")
        private boolean includeProjectDependencies
        Indicates if the project dependencies should be used when executing the main class.
        Since:
        1.1-beta-1
      • includePluginDependencies

        @Parameter(property="exec.includePluginsDependencies",
                   defaultValue="false")
        private boolean includePluginDependencies
        Indicates if this plugin's dependencies should be used when executing the main class.

        This is useful when project dependencies are not appropriate. Using only the plugin dependencies can be particularly useful when the project is not a java project. For example a mvn project using the csharp plugins only expects to see dotnet libraries as dependencies.

        Since:
        1.1-beta-1
      • cleanupDaemonThreads

        @Parameter(property="exec.cleanupDaemonThreads",
                   defaultValue="true")
        private boolean cleanupDaemonThreads
        Whether to interrupt/join and possibly stop the daemon threads upon quitting.
        If this is false, maven does nothing about the daemon threads. When maven has no more work to do, the VM will normally terminate any remaining daemon threads.

        In certain cases (in particular if maven is embedded), you might need to keep this enabled to make sure threads are properly cleaned up to ensure they don't interfere with subsequent activity. In that case, see daemonThreadJoinTimeout and stopUnresponsiveDaemonThreads for further tuning.

        Since:
        1.1-beta-1
      • daemonThreadJoinTimeout

        @Parameter(property="exec.daemonThreadJoinTimeout",
                   defaultValue="15000")
        private long daemonThreadJoinTimeout
        This defines the number of milliseconds to wait for daemon threads to quit following their interruption.
        This is only taken into account if cleanupDaemonThreads is true. A value <=0 means to not timeout (i.e. wait indefinitely for threads to finish). Following a timeout, a warning will be logged.

        Note: properly coded threads should terminate upon interruption but some threads may prove problematic: as the VM does interrupt daemon threads, some code may not have been written to handle interruption properly. For example java.util.Timer is known to not handle interruptions in JDK <= 1.6. So it is not possible for us to infinitely wait by default otherwise maven could hang. A sensible default value has been chosen, but this default value may change in the future based on user feedback.

        Since:
        1.1-beta-1
      • stopUnresponsiveDaemonThreads

        @Parameter(property="exec.stopUnresponsiveDaemonThreads",
                   defaultValue="false")
        private boolean stopUnresponsiveDaemonThreads
        Wether to call Thread.stop() following a timing out of waiting for an interrupted thread to finish. This is only taken into account if cleanupDaemonThreads is true and the daemonThreadJoinTimeout threshold has been reached for an uncooperative thread. If this is false, or if Thread.stop() fails to get the thread to stop, then a warning is logged and Maven will continue on while the affected threads (and related objects in memory) linger on. Consider setting this to true if you are invoking problematic code that you can't fix. An example is Timer which doesn't respond to interruption. To have Timer fixed, vote for this bug.
        Since:
        1.1-beta-1
      • killAfter

        @Parameter(property="exec.killAfter",
                   defaultValue="-1")
        @Deprecated
        private long killAfter
        Deprecated.
        since 1.1-alpha-1
        Deprecated this is not needed anymore.
        Since:
        1.0
      • originalSystemProperties

        private java.util.Properties originalSystemProperties
      • additionalClasspathElements

        @Parameter
        private java.util.List<java.lang.String> additionalClasspathElements
        Additional elements to be appended to the classpath.
        Since:
        1.3
    • Constructor Detail

      • ExecJavaMojo

        public ExecJavaMojo()
    • Method Detail

      • execute

        public void execute()
                     throws org.apache.maven.plugin.MojoExecutionException,
                            org.apache.maven.plugin.MojoFailureException
        Execute goal.
        Throws:
        org.apache.maven.plugin.MojoExecutionException - execution of the main class or one of the threads it generated failed.
        org.apache.maven.plugin.MojoFailureException - something bad happened...
      • joinNonDaemonThreads

        private void joinNonDaemonThreads​(java.lang.ThreadGroup threadGroup)
      • joinThread

        private void joinThread​(java.lang.Thread thread,
                                long timeoutMsecs)
      • terminateThreads

        private void terminateThreads​(java.lang.ThreadGroup threadGroup)
      • getActiveThreads

        private java.util.Collection<java.lang.Thread> getActiveThreads​(java.lang.ThreadGroup threadGroup)
      • setSystemProperties

        private void setSystemProperties()
        Pass any given system properties to the java system properties.
      • getClassLoader

        private java.lang.ClassLoader getClassLoader()
                                              throws org.apache.maven.plugin.MojoExecutionException
        Set up a classloader for the execution of the main class.
        Returns:
        the classloader
        Throws:
        org.apache.maven.plugin.MojoExecutionException - if a problem happens
      • addAdditionalClasspathElements

        private void addAdditionalClasspathElements​(java.util.List<java.net.URL> path)
      • addRelevantPluginDependenciesToClasspath

        private void addRelevantPluginDependenciesToClasspath​(java.util.List<java.net.URL> path)
                                                       throws org.apache.maven.plugin.MojoExecutionException
        Add any relevant project dependencies to the classpath. Indirectly takes includePluginDependencies and ExecutableDependency into consideration.
        Parameters:
        path - classpath of URL objects
        Throws:
        org.apache.maven.plugin.MojoExecutionException - if a problem happens
      • addRelevantProjectDependenciesToClasspath

        private void addRelevantProjectDependenciesToClasspath​(java.util.List<java.net.URL> path)
                                                        throws org.apache.maven.plugin.MojoExecutionException
        Add any relevant project dependencies to the classpath. Takes includeProjectDependencies into consideration.
        Parameters:
        path - classpath of URL objects
        Throws:
        org.apache.maven.plugin.MojoExecutionException - if a problem happens
      • determineRelevantPluginDependencies

        private java.util.Set<org.apache.maven.artifact.Artifact> determineRelevantPluginDependencies()
                                                                                               throws org.apache.maven.plugin.MojoExecutionException
        Determine all plugin dependencies relevant to the executable. Takes includePlugins, and the executableDependency into consideration.
        Returns:
        a set of Artifact objects. (Empty set is returned if there are no relevant plugin dependencies.)
        Throws:
        org.apache.maven.plugin.MojoExecutionException - if a problem happens resolving the plufin dependencies
      • getExecutablePomArtifact

        private org.apache.maven.artifact.Artifact getExecutablePomArtifact​(org.apache.maven.artifact.Artifact executableArtifact)
        Get the artifact which refers to the POM of the executable artifact.
        Parameters:
        executableArtifact - this artifact refers to the actual assembly.
        Returns:
        an artifact which refers to the POM of the executable artifact.
      • resolveExecutableDependencies

        private java.util.Set<org.apache.maven.artifact.Artifact> resolveExecutableDependencies​(org.apache.maven.artifact.Artifact executablePomArtifact)
                                                                                         throws org.apache.maven.plugin.MojoExecutionException
        Resolve the executable dependencies for the specified project
        Parameters:
        executablePomArtifact - the project's POM
        Returns:
        a set of Artifacts
        Throws:
        org.apache.maven.plugin.MojoExecutionException - if a failure happens
      • waitFor

        private void waitFor​(long millis)
        Stop program execution for nn millis.
        Parameters:
        millis - the number of millis-seconds to wait for, 0 stops program forever.