maven scala plugin 实现jvmArgs,执行过程原理解析笔记

2016-07-04 13:16:00

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

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处。如若内容有涉嫌抄袭侵权/违法违规/事实不符，请点击举报进行投诉反馈！

标签：业界 maven scala

上一篇 > Thrift｜Thrift安装初体验
下一篇 > Git实战详解