Package org.codehaus.mojo.exec

Class AbstractExecJavaBase

java.lang.Object
org.apache.maven.plugin.AbstractMojo
org.codehaus.mojo.exec.AbstractExecMojo
org.codehaus.mojo.exec.AbstractExecJavaBase
All Implemented Interfaces:
org.apache.maven.plugin.ContextEnabled, org.apache.maven.plugin.Mojo
Direct Known Subclasses:
ExecJavaMojo
public abstract class AbstractExecJavaBase extends AbstractExecMojo
Abstract base class for ExecJavaMojo implementations (Java 8 and Java 9+). Contains all common code shared between the Java 8 base and Java 9+ version.
Since:
3.6.2

  • Field Details

    • THREAD_STOP_UNAVAILABLE

      protected static final String THREAD_STOP_UNAVAILABLE
      See Also:

    • mainClass

      @Parameter(required=true, property="exec.mainClass") protected String mainClass
      The main class to execute.
      With Java 9 and above you can prefix it with the modulename, e.g. com.greetings/com.greetings.Main Without modulename the classpath will be used, with modulename a new modulelayer will be created.

      Note that you can also provide a Runnable fully qualified name. The runnable can get constructor injections either by type if you have maven in your classpath (can be provided) or by name (ensure to enable -parameters Java compiler option) for loose coupling. Current support loose injections are:

      • systemProperties: Properties, session system properties
      • systemPropertiesUpdater: BiConsumer<String, String>, session system properties update callback (pass the key/value to update, null value means removal of the key)
      • userProperties: Properties, session user properties
      • userPropertiesUpdater: BiConsumer<String, String>, session user properties update callback (pass the key/value to update, null value means removal of the key)
      • projectProperties: Properties, project properties
      • projectPropertiesUpdater: BiConsumer<String, String>, project properties update callback (pass the key/value to update, null value means removal of the key)
      • highestVersionResolver: Function<String, String>, passing a groupId:artifactId you get the latest resolved version from the project repositories
      Since:
      1.0

    • preloadCommonPool

      @Parameter(property="exec.preloadCommonPool", defaultValue="0") protected int preloadCommonPool
      Forces the creation of fork join common pool to avoids the threads to be owned by the isolated thread group and prevent a proper shutdown. If set to zero the default parallelism is used to precreate all threads, if negative it is ignored else the value is the one used to create the fork join threads.
      Since:
      3.0.1

    • arguments

      @Parameter(property="exec.arguments") protected String[] arguments
      The class arguments.
      Since:
      1.0

    • systemProperties

      @Parameter protected AbstractProperty[] 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 protected 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") protected boolean includeProjectDependencies
      Indicates if the project dependencies should be used when executing the main class.
      Since:
      1.1-beta-1

    • cleanupDaemonThreads

      @Parameter(property="exec.cleanupDaemonThreads", defaultValue="true") protected 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") protected 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") protected 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.

      Note: In JDK 20+, the long deprecated Thread.stop() (since JDK 1.2) has been removed and will throw an UnsupportedOperationException. This will be handled gracefully, yielding a log warning "Thread.stop() is unavailable in this JRE version, cannot force-stop any threads" once and not trying to stop any further threads during the same execution.

      Since:
      1.1-beta-1

    • originalSystemProperties

      protected Properties originalSystemProperties

    • additionalClasspathElements

      @Parameter protected List<String> additionalClasspathElements
      Additional elements to be appended to the classpath.
      Since:
      1.3

    • classpathFilenameExclusions

      @Parameter protected List<String> classpathFilenameExclusions
      List of file to exclude from the classpath. It matches the jar name, for example slf4j-simple-1.7.30.jar.
      Since:
      3.0.1

    • forcedJvmPackages

      @Parameter protected List<String> forcedJvmPackages
      Additional packages to load from the jvm even if a classpath dependency matches.
      Since:
      3.5.0

    • excludedJvmPackages

      @Parameter protected List<String> excludedJvmPackages
      Additional packages to NOT load from the jvm even if it is in a flat classpath. Can enable to reproduce a webapp behavior for example where library is loaded over the JVM.
      Since:
      3.5.0

    • blockSystemExit

      @Parameter(property="exec.blockSystemExit", defaultValue="false") protected boolean blockSystemExit
      Whether to try and prohibit the called Java program from terminating the JVM (and with it the whole Maven build) by calling System.exit(int). When active, loaded classes will replace this call by a custom callback. In case of an exit code 0 (OK), it will simply log the fact that System.exit(int) was called. Otherwise, it will throw a SystemExitException, failing the Maven goal as if the called Java code itself had exited with an exception. This way, the error is propagated without terminating the whole Maven JVM. In previous versions, users had to use the exec instead of the java goal in such cases, which now with this option is no longer necessary.
      Since:
      3.2.0

    • container

      protected final org.codehaus.plexus.PlexusContainer container

  • Constructor Details

    • AbstractExecJavaBase

      @Inject protected AbstractExecJavaBase(org.eclipse.aether.RepositorySystem repositorySystem, org.codehaus.plexus.PlexusContainer container)

  • Method Details

    • 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...

    • doExecClassLoader

      protected void doExecClassLoader(String bootClassName) throws Throwable
      Throws:
      Throwable

    • doExecModulePath

      protected abstract void doExecModulePath(String moduleName, String bootClassName) throws Throwable
      Execute using module path (Java 9+ JPMS). Subclasses must implement this method to provide version-specific module path execution.
      Parameters:
      moduleName - the module name
      bootClassName - the fully qualified class name
      Throws:
      Throwable - if execution fails

    • executeMainMethod

      protected void executeMainMethod(Class<?> bootClass) throws Throwable
      Execute the main method. Subclasses may override to provide version-specific behavior (e.g., Module opening logic for Java 9+).
      Parameters:
      bootClass - the class containing the main method
      Throws:
      Throwable - if execution fails

    • findMethod

      protected Method findMethod(Class<?> clazz, String methodName, boolean isStatic, Class<?>[] parameterTypes)
      Finds a method with the given name, parameter types, and static modifier requirement. Searches the class hierarchy including inherited methods. Only matches methods with void return type (for JSR-512 compliance).
      Parameters:
      clazz - the class to search
      methodName - the method name
      isStatic - whether the method should be static
      parameterTypes - the parameter types
      Returns:
      the matching method, or null if not found

    • newInstance

      protected Object newInstance(Class<?> bootClass) throws InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException
      Throws:
      InvocationTargetException
      InstantiationException
      IllegalAccessException
      NoSuchMethodException

    • doRun

      protected void doRun(Class<?> bootClass) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
      Throws:
      InstantiationException
      IllegalAccessException
      InvocationTargetException
      NoSuchMethodException

    • lookupParam

      protected Object lookupParam(Parameter param) throws org.codehaus.plexus.component.repository.exception.ComponentLookupException
      Throws:
      org.codehaus.plexus.component.repository.exception.ComponentLookupException

    • lookup

      protected Object lookup(Parameter param, String name) throws org.codehaus.plexus.component.repository.exception.ComponentLookupException
      Throws:
      org.codehaus.plexus.component.repository.exception.ComponentLookupException

    • resolveVersion

      protected Function<String,String> resolveVersion(Function<org.eclipse.aether.resolution.VersionRangeResult,Object> fn)

    • propertiesUpdater

      protected BiConsumer<String,String> propertiesUpdater(Properties props)

    • preloadCommonPool

      protected void preloadCommonPool()
      To avoid the exec:java to consider common pool threads leaked, let's pre-create them.

    • joinNonDaemonThreads

      protected void joinNonDaemonThreads(ThreadGroup threadGroup)

    • joinThread

      protected void joinThread(Thread thread, long timeoutMsecs)

    • terminateThreads

      protected void terminateThreads(ThreadGroup threadGroup)

    • getActiveThreads

      protected Collection<Thread> getActiveThreads(ThreadGroup threadGroup)

    • setSystemProperties

      protected void setSystemProperties()
      Pass any given system properties to the java system properties.

    • getClassLoader

      protected URLClassLoader 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

      protected void addAdditionalClasspathElements(List<Path> path)

    • addRelevantPluginDependenciesToClasspath

      protected void addRelevantPluginDependenciesToClasspath(List<Path> 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

      protected void addRelevantProjectDependenciesToClasspath(List<Path> path)
      Add any relevant project dependencies to the classpath. Takes includeProjectDependencies into consideration.
      Parameters:
      path - classpath of URL objects

    • waitFor

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