maven scala plugin 实现jvmArgs,执行过程原理解析笔记
scala-maven-plugin 构建scala,springboot工程
我们在使用maven构建scala工程的时候, 要使用scala-maven-plugin插件,常规配置如下 :
org.scala-tools maven-scala-plugin pdata com.pdata.PDataApplication --> arg1--> --> -Xmx1024m -Dsword.autokey.port=9202这样,就可以直接使用如下命令动态注入sword.autokey.prot的值, 启动应用:
mvn scala:run -Dlauncher=pdata实现原理剖析
源码地址:
https://github.com/universsky/scala-maven-plugin
mvn scala:run -Dlauncher=pdata 执行过程讲解
自己动手编写Maven插件
参考: (Maven Plugin示例：自己动手编写Maven插件: http://blog.csdn.net/vking_wang/article/details/8612981 )
Maven插件项目的POM有两个特殊的地方：
它的packaging必须为maven-plugin，这种特殊的打包类型能够控制Maven为其在生命周期阶段绑定插件处理相关的目标，例如在compile阶段，Maven需要为插件项目构建一个特殊插件描述符文件。
maven-plugin-api依赖中包含了插件开发所必须得类。
首先，每个插件目标类，或者说MOJO，都必须继承AbstractMojo类并实现execute()方法，只有这样Maven才能识别该插件目标，并执行execute()方法中的行为。
mvn scala:run -Dlauncher=pdata 执行过程
项目运行run生命周期对应的处理类 scala_maven.ScalaRunMojo
package scala_maven;import org.apache.maven.toolchain.Toolchain;import org.codehaus.plexus.util.StringUtils;import scala_maven_executions.JavaMainCaller;import scala_maven_executions.JavaMainCallerByFork;import scala_maven_executions.MainHelper;/ * Run a Scala class using the Scala runtime * * @goal run * @requiresDependencyResolution test * @execute phase="test-compile" * @threadSafe */public class ScalaRunMojo extends ScalaMojoSupport { / * The class to use when launching a scala program * * @parameter property="launcher" */ protected String launcher; / * Additional parameter to use to call the main class * Using this parameter only from command line ("-DaddArgs=arg1|arg2|arg3|..."), not from pom.xml. * @parameter property="addArgs" */ protected String addArgs; / * A list of launcher definition (to avoid rewriting long command line or share way to call an application) * launchers could be define by : * * * * myLauncher * my.project.Main * * arg1 * * * -Xmx64m * * * * myLauncher2 * ... * * * * * @parameter */ protected Launcher[] launchers; / * Main class to call, the call use the jvmArgs and args define in the pom.xml, and the addArgs define in the command line if define. * * Higher priority to launcher parameter) * Using this parameter only from command line (-DmainClass=...), not from pom.xml. * @parameter property="mainClass" */ protected String mainClass; @Override protected void doExecute() throws Exception { JavaMainCaller jcmd = null; Toolchain toolchain = toolchainManager.getToolchainFromBuildContext("jdk", session); if (StringUtils.isNotEmpty(mainClass)) { jcmd = new JavaMainCallerByFork(this, mainClass, MainHelper.toMultiPath(project.getTestClasspathElements()), jvmArgs, args, forceUseArgFile, toolchain); } else if ((launchers != null) && (launchers.length > 0)) { if (StringUtils.isNotEmpty(launcher)) { for(int i = 0; (i "+ launchers[i].mainClass ); jcmd = new JavaMainCallerByFork(this, launchers[i].mainClass, MainHelper.toMultiPath(project.getTestClasspathElements()), launchers[i].jvmArgs, launchers[i].args, forceUseArgFile, toolchain); } } } else { getLog().info("launcher '"+ launchers[0].id + "' selected => "+ launchers[0].mainClass ); jcmd = new JavaMainCallerByFork(this, launchers[0].mainClass, MainHelper.toMultiPath(project.getTestClasspathElements()), launchers[0].jvmArgs, launchers[0].args, forceUseArgFile, toolchain); } } if (jcmd != null) { if (StringUtils.isNotEmpty(addArgs)) { jcmd.addArgs(StringUtils.split(addArgs, "|")); } jcmd.run(displayCmd); } else { getLog().warn("Not mainClass or valid launcher found/define"); } }}JavaMainCaller
package scala_maven_executions;import java.io.File;/ * This interface is used to create a call on a main method of a java class. * * The important implementations are JavaCommand and ReflectionJavaCaller * * @author J. Suereth * */public interface JavaMainCaller { / Adds an environemnt variable */ public abstract void addEnvVar(String key, String value); / Adds a JVM arg. Note: This is not available for in-process "forks" */ public abstract void addJvmArgs(String... args); / Adds arguments for the process */ public abstract void addArgs(String... args); / Adds option (basically two arguments) */ public abstract void addOption(String key, String value); / Adds an option (key-file pair). This will pull the absolute path of the file */ public abstract void addOption(String key, File value); / Adds the key if the value is true */ public abstract void addOption(String key, boolean value); / request run to be redirected to maven/requester logger */ public abstract void redirectToLog(); // TODO: avoid to have several Thread to pipe stream // TODO: add support to inject startup command and shutdown command (on :quit) public abstract void run(boolean displayCmd) throws Exception; / Runs the JavaMain with all the built up arguments/options */ public abstract boolean run(boolean displayCmd, boolean throwFailure) throws Exception; / * run the command without stream redirection nor waiting for exit * * @param displayCmd * @return the spawn Process (or null if no process was spawned) * @throws Exception */ public abstract SpawnMonitor spawn(boolean displayCmd) throws Exception;}ToolchainManager
这个接口是maven-core里面的.
Launcher领域对象模型
package scala_maven;public class Launcher { protected String id; protected String mainClass; / * Jvm Arguments * * @parameter */ protected String[] jvmArgs; / * compiler additionnals arguments * * @parameter */ protected String[] args;}核心处理类ScalaMojoSupport, ScalaCompilerSupport
这个处理类中, 有对scala编译器和运行时依赖的实现处理.
基于 Zinc 的编译器:
com.typesafe.zinc:zinc:0.3.5
我们来看一下源码:
package com.typesafe.zincclass Compiler(scalac : sbt.compiler.AnalyzingCompiler, javac : xsbti.compile.JavaCompiler) extends scala.AnyRef { def compile(inputs : com.typesafe.zinc.Inputs)(log : xsbti.Logger) : sbt.inc.Analysis = { /* compiled code */ } def compile(inputs : com.typesafe.zinc.Inputs, cwd : scala.Option[java.io.File])(log : xsbti.Logger) : sbt.inc.Analysis = { /* compiled code */ } def autoClasspath(classesDirectory : java.io.File, allScalaJars : scala.Seq[java.io.File], javaOnly : scala.Boolean, classpath : scala.Seq[java.io.File]) : scala.Seq[java.io.File] = { /* compiled code */ } override def toString() : scala.Predef.String = { /* compiled code */ }}object Compiler extends scala.AnyRef { val CompilerInterfaceId : java.lang.String = { /* compiled code */ } val JavaClassVersion : java.lang.String = { /* compiled code */ } val compilerCache : com.typesafe.zinc.Cache[com.typesafe.zinc.Setup, com.typesafe.zinc.Compiler] = { /* compiled code */ } val residentCache : xsbti.compile.GlobalsCache = { /* compiled code */ } val analysisCache : com.typesafe.zinc.Cache[com.typesafe.zinc.FileFPrint, scala.Option[scala.Tuple2[sbt.inc.Analysis, sbt.CompileSetup]]] = { /* compiled code */ } def apply(setup : com.typesafe.zinc.Setup, log : xsbti.Logger) : com.typesafe.zinc.Compiler = { /* compiled code */ } def getOrCreate(setup : com.typesafe.zinc.Setup, log : xsbti.Logger) : com.typesafe.zinc.Compiler = { /* compiled code */ } def create(setup : com.typesafe.zinc.Setup, log : xsbti.Logger) : com.typesafe.zinc.Compiler = { /* compiled code */ } def newScalaCompiler(instance : sbt.ScalaInstance, interfaceJar : java.io.File, log : xsbti.Logger) : sbt.compiler.AnalyzingCompiler = { /* compiled code */ } def newJavaCompiler(instance : sbt.ScalaInstance, javaHome : scala.Option[java.io.File], fork : scala.Boolean) : xsbti.compile.JavaCompiler = { /* compiled code */ } def createResidentCache(maxCompilers : scala.Int) : xsbti.compile.GlobalsCache = { /* compiled code */ } def analysisStore(cacheFile : java.io.File) : sbt.inc.AnalysisStore = { /* compiled code */ } def analysis(cacheFile : java.io.File) : sbt.inc.Analysis = { /* compiled code */ } def analysisIsEmpty(cacheFile : java.io.File) : scala.Boolean = { /* compiled code */ } def scalaInstance(setup : com.typesafe.zinc.Setup) : sbt.ScalaInstance = { /* compiled code */ } def scalaLoader(jars : scala.Seq[java.io.File]) : java.net.URLClassLoader = { /* compiled code */ } def scalaVersion(scalaLoader : java.lang.ClassLoader) : scala.Option[scala.Predef.String] = { /* compiled code */ } def compilerInterface(setup : com.typesafe.zinc.Setup, scalaInstance : sbt.ScalaInstance, log : xsbti.Logger) : java.io.File = { /* compiled code */ } def interfaceId(scalaVersion : scala.Predef.String) : java.lang.String = { /* compiled code */ }}可以看出,编译的过程是,
scalac把scala代码编译成.class文件
ClassLoader对.class文件的读写操作, 寻找classpath下面的类, 加载到jvm执行引擎中
最后在jvm中执行.class字节码.
增量编译: ScalaCompilerSupport.incrementalCompile
//// Incremental compilation//@SuppressWarnings("unchecked")protected int incrementalCompile(List classpathElements, List sourceRootDirs, File outputDir, File cacheFile, boolean compileInLoop) throws Exception, InterruptedException { List sources = findSourceWithFilters(sourceRootDirs); if (sources.isEmpty()) { return -1; } if (incremental == null) { File libraryJar = getLibraryJar(); File compilerJar = getCompilerJar(); List extraJars = getCompilerDependencies(); extraJars.remove(libraryJar); String sbtGroupId = SbtIncrementalCompiler.SBT_GROUP_ID; String xsbtiArtifactId = SbtIncrementalCompiler.XSBTI_ARTIFACT_ID; String compilerInterfaceArtifactId = SbtIncrementalCompiler.COMPILER_INTERFACE_ARTIFACT_ID; String compilerInterfaceClassifier = SbtIncrementalCompiler.COMPILER_INTERFACE_CLASSIFIER; String sbtVersion = findVersionFromPluginArtifacts(sbtGroupId, SbtIncrementalCompiler.COMPILER_INTEGRATION_ARTIFACT_ID); File xsbtiJar = getPluginArtifactJar(sbtGroupId, xsbtiArtifactId, sbtVersion); List zincArgs = StringUtils.isEmpty(addZincArgs) ? new LinkedList() : (List) Arrays.asList(addZincArgs.split("\\|")); File interfaceSrcJar = getPluginArtifactJar(sbtGroupId, compilerInterfaceArtifactId, sbtVersion, compilerInterfaceClassifier); incremental = new SbtIncrementalCompiler(useZincServer, zincPort, libraryJar, compilerJar, extraJars, xsbtiJar, interfaceSrcJar, getLog(), zincArgs); } classpathElements.remove(outputDir.getAbsolutePath()); List scalacOptions = getScalaOptions(); List javacOptions = getJavacOptions(); Map cacheMap = getAnalysisCacheMap(); try { incremental.compile(project.getBasedir(), classpathElements, sources, outputDir, scalacOptions, javacOptions, cacheFile, cacheMap, compileOrder); } catch (xsbti.CompileFailed e) { if (compileInLoop) { compileErrors = true; } else { throw e; } } return 1;}调用的compile方法:
public void compile(File baseDir, List classpathElements, List sources, File classesDirectory, List scalacOptions, List javacOptions, File cacheFile, Map cacheMap, String compileOrder) throws Exception { if (useServer) { zincCompile(baseDir, classpathElements, sources, classesDirectory, scalacOptions, javacOptions, cacheFile, cacheMap, compileOrder); } else { if (log.isDebugEnabled()) log.debug("Incremental compiler = " + compiler + " [" + Integer.toHexString(compiler.hashCode()) + "]"); List classpath = pathsToFiles(classpathElements); Inputs inputs = Inputs.create(classpath, sources, classesDirectory, scalacOptions, javacOptions, cacheFile, cacheMap, compileOrder, defaultOptions(), true); if (log.isDebugEnabled()) Inputs.debug(inputs, logger); compiler.compile(inputs, logger); }}如果useServer编译,执行zincCompile方法:
private void zincCompile(File baseDir, List classpathElements, List sources, File classesDirectory, List scalacOptions, List javacOptions, File cacheFile, Map cacheMap, String compileOrder) throws Exception { List arguments = new ArrayList(extraArgs); arguments.add("-log-level"); arguments.add(logLevelToString(log)); arguments.add("-scala-compiler"); arguments.add(compilerJar.getAbsolutePath()); arguments.add("-scala-library"); arguments.add(libraryJar.getAbsolutePath()); arguments.add("-scala-extra"); List extraPaths = new ArrayList(); for (File extraJar : extraJars) { extraPaths.add(extraJar.getAbsolutePath()); } arguments.add(MainHelper.toMultiPath(extraPaths)); if (!classpathElements.isEmpty()) { arguments.add("-classpath"); arguments.add(MainHelper.toMultiPath(classpathElements)); } arguments.add("-d"); arguments.add(classesDirectory.getAbsolutePath()); for (String scalacOption : scalacOptions) { arguments.add("-S" + scalacOption); } for (String javacOption : javacOptions) { arguments.add("-C" + javacOption); } arguments.add("-compile-order"); arguments.add(compileOrder); arguments.add("-analysis-cache"); arguments.add(cacheFile.getAbsolutePath()); arguments.add("-analysis-map"); arguments.add(cacheMapToString(cacheMap)); for (File source : sources) { arguments.add(source.getAbsolutePath()); } int exitCode = zinc.run(arguments, baseDir, System.out, System.err); if (exitCode != 0) { xsbti.Problem[] problems = null; throw new sbt.compiler.CompileFailed(arguments.toArray(new String[arguments.size()]), "Compile failed via zinc server", problems); }}ZincClient.run方法
/ * Java API for sending a zinc command to a currently running nailgun server. * All output goes to specified output streams. Exit code is returned. * @throws java.net.ConnectException if the zinc server is not available */@throws(classOf[java.net.ConnectException])def run(args: JList[String], cwd: File, out: OutputStream, err: OutputStream): Int = send("zinc", args.asScala, cwd, out, err)/ * Send a command to a currently running nailgun server. * Possible commands are "zinc", "status", and "shutdown". * All output goes to specified output streams. Exit code is returned. * @throws java.net.ConnectException if the zinc server is not available */def send(command: String, args: Seq[String], cwd: File, out: OutputStream, err: OutputStream): Int = { val socket = new Socket(address, port) val sockout = socket.getOutputStream val sockin = new DataInputStream(socket.getInputStream) sendCommand(command, args, cwd, sockout) val exitCode = receiveOutput(sockin, out, err) sockout.close(); sockin.close(); socket.close() exitCode}ZincClient是
Client for talking directly to a nailgun server from another JVM.
增量编译是只编译那些源代码在上一次编译之后有修改的类，及那些受这些修改影响到的类，它可以大大减少 Scala 的编译时间。频繁编译代码的增量部分是非常有用的，因为在开发时我们经常要这样做。
Scala 插件现在通过集成 Zinc 来支持增量编译， 它是 sbt 增量 Scala 编译器的一个单机版本。
com.typesafe.zinc.Compiler.compile方法
/ * Run a compile. The resulting analysis is also cached in memory. */def compile(inputs: Inputs, cwd: Option[File])(log: Logger): Analysis = { import inputs._ if (forceClean && Compiler.analysisIsEmpty(cacheFile)) Util.cleanAllClasses(classesDirectory) val getAnalysis: File => Option[Analysis] = analysisMap.get _ val aggressive = new AggressiveCompile(cacheFile) val cp = autoClasspath(classesDirectory, scalac.scalaInstance.allJars, javaOnly, classpath) val compileOutput = CompileOutput(classesDirectory) val globalsCache = Compiler.residentCache val progress = None val maxErrors = 100 val reporter = new LoggerReporter(maxErrors, log, identity) val skip = false val incOpts = incOptions.options val compileSetup = new CompileSetup(compileOutput, new CompileOptions(scalacOptions, javacOptions), scalac.scalaInstance.actualVersion, compileOrder, incOpts.nameHashing) val analysisStore = Compiler.analysisStore(cacheFile) val analysis = aggressive.compile1(sources, cp, compileSetup, progress, analysisStore, getAnalysis, definesClass, scalac, javac, reporter, skip, globalsCache, incOpts)(log) if (mirrorAnalysis) { SbtAnalysis.printRelations(analysis, Some(new File(cacheFile.getPath() + ".relations")), cwd) } SbtAnalysis.printOutputs(analysis, outputRelations, outputProducts, cwd, classesDirectory) analysis}关键字：scala, maven
版权声明
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处。如若内容有涉嫌抄袭侵权/违法违规/事实不符，请点击 举报 进行投诉反馈！
