Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2012-2023 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.maven;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.project.MavenProject;
import org.apache.maven.toolchain.ToolchainManager;
import org.springframework.boot.loader.tools.FileUtils;
/**
* Base class to run a Spring Boot application.
*
* @author Phillip Webb
* @author Stephane Nicoll
* @author David Liu
* @author Daniel Young
* @author Dmytro Nosan
* @since 1.3.0
* @see RunMojo
* @see StartMojo
*/
public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
/**
* The Maven project.
* @since 1.0.0
*/
@Parameter(defaultValue = "${project}", readonly = true, required = true)
private MavenProject project;
/**
* The current Maven session. This is used for toolchain manager API calls.
* @since 2.3.0
*/
@Parameter(defaultValue = "${session}", readonly = true)
private MavenSession session;
/**
* The toolchain manager to use to locate a custom JDK.
* @since 2.3.0
*/
@Component
private ToolchainManager toolchainManager;
/**
* Add maven resources to the classpath directly, this allows live in-place editing of
* resources. Duplicate resources are removed from {@code target/classes} to prevent
* them from appearing twice if {@code ClassLoader.getResources()} is called. Please
* consider adding {@code spring-boot-devtools} to your project instead as it provides
* this feature and many more.
* @since 1.0.0
*/
@Parameter(property = "spring-boot.run.addResources", defaultValue = "false")
private boolean addResources = false;
/**
* Path to agent jars.
* @since 2.2.0
*/
@Parameter(property = "spring-boot.run.agents")
private File[] agents;
/**
* Flag to say that the agent requires -noverify.
* @since 1.0.0
*/
@Parameter(property = "spring-boot.run.noverify")
private boolean noverify = false;
/**
* Current working directory to use for the application. If not specified, basedir
* will be used.
* @since 1.5.0
*/
@Parameter(property = "spring-boot.run.workingDirectory")
private File workingDirectory;
/**
* JVM arguments that should be associated with the forked process used to run the
* application. On command line, make sure to wrap multiple values between quotes.
* @since 1.1.0
*/
@Parameter(property = "spring-boot.run.jvmArguments")
private String jvmArguments;
/**
* List of JVM system properties to pass to the process.
* @since 2.1.0
*/
@Parameter
private Map systemPropertyVariables;
/**
* List of Environment variables that should be associated with the forked process
* used to run the application.
* @since 2.1.0
*/
@Parameter
private Map environmentVariables;
/**
* Arguments that should be passed to the application.
* @since 1.0.0
*/
@Parameter
private String[] arguments;
/**
* Arguments from the command line that should be passed to the application. Use
* spaces to separate multiple arguments and make sure to wrap multiple values between
* quotes. When specified, takes precedence over {@link #arguments}.
* @since 2.2.3
*/
@Parameter(property = "spring-boot.run.arguments")
private String commandlineArguments;
/**
* The spring profiles to activate. Convenience shortcut of specifying the
* 'spring.profiles.active' argument. On command line use commas to separate multiple
* profiles.
* @since 1.3.0
*/
@Parameter(property = "spring-boot.run.profiles")
private String[] profiles;
/**
* The name of the main class. If not specified the first compiled class found that
* contains a 'main' method will be used.
* @since 1.0.0
*/
@Parameter(property = "spring-boot.run.main-class")
private String mainClass;
/**
* Additional directories besides the classes directory that should be added to the
* classpath.
* @since 1.0.0
*/
@Parameter(property = "spring-boot.run.directories")
private String[] directories;
/**
* Directory containing the classes and resource files that should be packaged into
* the archive.
* @since 1.0.0
*/
@Parameter(defaultValue = "${project.build.outputDirectory}", required = true)
private File classesDirectory;
/**
* Flag to include the test classpath when running.
* @since 1.3.0
*/
@Parameter(property = "spring-boot.run.useTestClasspath", defaultValue = "false")
private Boolean useTestClasspath;
/**
* Skip the execution.
* @since 1.3.2
*/
@Parameter(property = "spring-boot.run.skip", defaultValue = "false")
private boolean skip;
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (this.skip) {
getLog().debug("skipping run as per configuration.");
return;
}
String startClass = (this.mainClass != null) ? this.mainClass
: SpringBootApplicationClassFinder.findSingleClass(this.classesDirectory);
run(startClass);
}
private void run(String startClassName) throws MojoExecutionException, MojoFailureException {
List args = new ArrayList<>();
addAgents(args);
addJvmArgs(args);
addClasspath(args);
args.add(startClassName);
addArgs(args);
JavaProcessExecutor processExecutor = new JavaProcessExecutor(this.session, this.toolchainManager);
File workingDirectoryToUse = (this.workingDirectory != null) ? this.workingDirectory
: this.project.getBasedir();
run(processExecutor, workingDirectoryToUse, args, determineEnvironmentVariables());
}
/**
* Run the application.
* @param processExecutor the {@link JavaProcessExecutor} to use
* @param workingDirectory the working directory of the forked JVM
* @param args the arguments (JVM arguments and application arguments)
* @param environmentVariables the environment variables
* @throws MojoExecutionException in case of MOJO execution errors
* @throws MojoFailureException in case of MOJO failures
* @since 3.0.0
*/
protected abstract void run(JavaProcessExecutor processExecutor, File workingDirectory, List args,
Map environmentVariables) throws MojoExecutionException, MojoFailureException;
/**
* Resolve the application arguments to use.
* @return a {@link RunArguments} defining the application arguments
*/
protected RunArguments resolveApplicationArguments() {
RunArguments runArguments = (this.arguments != null) ? new RunArguments(this.arguments)
: new RunArguments(this.commandlineArguments);
addActiveProfileArgument(runArguments);
return runArguments;
}
/**
* Resolve the environment variables to use.
* @return an {@link EnvVariables} defining the environment variables
*/
protected EnvVariables resolveEnvVariables() {
return new EnvVariables(this.environmentVariables);
}
private void addArgs(List args) {
RunArguments applicationArguments = resolveApplicationArguments();
Collections.addAll(args, applicationArguments.asArray());
logArguments("Application argument(s): ", applicationArguments.asArray());
}
private Map determineEnvironmentVariables() {
EnvVariables envVariables = resolveEnvVariables();
logArguments("Environment variable(s): ", envVariables.asArray());
return envVariables.asMap();
}
/**
* Resolve the JVM arguments to use.
* @return a {@link RunArguments} defining the JVM arguments
*/
protected RunArguments resolveJvmArguments() {
StringBuilder stringBuilder = new StringBuilder();
if (this.systemPropertyVariables != null) {
stringBuilder.append(this.systemPropertyVariables.entrySet()
.stream()
.map((e) -> SystemPropertyFormatter.format(e.getKey(), e.getValue()))
.collect(Collectors.joining(" ")));
}
if (this.jvmArguments != null) {
stringBuilder.append(" ").append(this.jvmArguments);
}
return new RunArguments(stringBuilder.toString());
}
private void addJvmArgs(List args) {
RunArguments jvmArguments = resolveJvmArguments();
Collections.addAll(args, jvmArguments.asArray());
logArguments("JVM argument(s): ", jvmArguments.asArray());
}
private void addAgents(List args) {
if (this.agents != null) {
if (getLog().isInfoEnabled()) {
getLog().info("Attaching agents: " + Arrays.asList(this.agents));
}
for (File agent : this.agents) {
args.add("-javaagent:" + agent);
}
}
if (this.noverify) {
args.add("-noverify");
}
}
private void addActiveProfileArgument(RunArguments arguments) {
if (this.profiles.length > 0) {
StringBuilder arg = new StringBuilder("--spring.profiles.active=");
for (int i = 0; i < this.profiles.length; i++) {
arg.append(this.profiles[i]);
if (i < this.profiles.length - 1) {
arg.append(",");
}
}
arguments.getArgs().addFirst(arg.toString());
logArguments("Active profile(s): ", this.profiles);
}
}
private void addClasspath(List args) throws MojoExecutionException {
try {
StringBuilder classpath = new StringBuilder();
for (URL ele : getClassPathUrls()) {
if (classpath.length() > 0) {
classpath.append(File.pathSeparator);
}
classpath.append(new File(ele.toURI()));
}
if (getLog().isDebugEnabled()) {
getLog().debug("Classpath for forked process: " + classpath);
}
args.add("-cp");
args.add(classpath.toString());
}
catch (Exception ex) {
throw new MojoExecutionException("Could not build classpath", ex);
}
}
protected URL[] getClassPathUrls() throws MojoExecutionException {
try {
List urls = new ArrayList<>();
addUserDefinedDirectories(urls);
addResources(urls);
addProjectClasses(urls);
addDependencies(urls);
return urls.toArray(new URL[0]);
}
catch (IOException ex) {
throw new MojoExecutionException("Unable to build classpath", ex);
}
}
private void addUserDefinedDirectories(List urls) throws MalformedURLException {
if (this.directories != null) {
for (String directory : this.directories) {
urls.add(new File(directory).toURI().toURL());
}
}
}
private void addResources(List urls) throws IOException {
if (this.addResources) {
for (Resource resource : this.project.getResources()) {
File directory = new File(resource.getDirectory());
urls.add(directory.toURI().toURL());
FileUtils.removeDuplicatesFromOutputDirectory(this.classesDirectory, directory);
}
}
}
private void addProjectClasses(List urls) throws MalformedURLException {
urls.add(this.classesDirectory.toURI().toURL());
}
private void addDependencies(List urls) throws MalformedURLException, MojoExecutionException {
Set artifacts = (this.useTestClasspath) ? filterDependencies(this.project.getArtifacts())
: filterDependencies(this.project.getArtifacts(), new ExcludeTestScopeArtifactFilter());
for (Artifact artifact : artifacts) {
if (artifact.getFile() != null) {
urls.add(artifact.getFile().toURI().toURL());
}
}
}
private void logArguments(String message, String[] args) {
if (getLog().isDebugEnabled()) {
getLog().debug(Arrays.stream(args).collect(Collectors.joining(" ", message, "")));
}
}
/**
* Format System properties.
*/
static class SystemPropertyFormatter {
static String format(String key, String value) {
if (key == null) {
return "";
}
if (value == null || value.isEmpty()) {
return String.format("-D%s", key);
}
return String.format("-D%s=\"%s\"", key, value);
}
}
}
