Java Commandline类代码示例

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
public void testEndOptions()
        throws Exception {
    File[] includePaths = {new File("p1"), new File("p2")};
    config.setIncludePaths(includePaths);

    String[] startOptions = {"-s1", "-s2"};
    String[] middleOptions = {"-m1", "-m2"};
    String[] endOptions = {"-e1", "-e2"};
    config.setStartOptions(startOptions);
    config.setMiddleOptions(middleOptions);
    config.setEndOptions(endOptions);

    Commandline cl = compiler.getCommandLine(sourceFile, objectFile, config);

    assertArrayEquals(new String[]{"gcc", "-s1", "-s2", "-Ip1", "-Ip2", "-m1", "-m2", simpleArgv[0], simpleArgv[1], simpleArgv[2], simpleArgv[3], "-e1", "-e2"}, cl.getCommandline());
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
public void testEndOptions()
    throws Exception
{
    File[] includePaths = { new File( "p1" ), new File( "p2" ) };
    config.setIncludePaths( includePaths );

    String[] startOptions = { "-s1", "-s2" };
    String[] middleOptions = { "-m1", "-m2" };
    String[] endOptions = { "-e1", "-e2" };
    config.setStartOptions( startOptions );
    config.setMiddleOptions( middleOptions );
    config.setEndOptions( endOptions );

    Commandline cl = compiler.getCommandLine( sourceFile, objectFile, config );

    assertArrayEquals(new String[] {"gcc", "-s1", "-s2", "-Ip1" ,"-Ip2", "-m1", "-m2", simpleArgv[0], simpleArgv[1], simpleArgv[2], simpleArgv[3], "-e1", "-e2"}, cl.getCommandline() );
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
public static void setupCommandlineEnv( Commandline cl, EnvFactory envFactory )
    throws NativeBuildException
{
    if ( envFactory != null )
    {
        Map envs = envFactory.getEnvironmentVariables();

        Iterator iter = envs.keySet().iterator();

        while ( iter.hasNext() )
        {
            String key = (String) iter.next();
            cl.addEnvironment( key, (String) envs.get( key ) );
        }
    }
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
public static void execute( Commandline cl, Logger logger )
    throws NativeBuildException
{
    int ok;

    try
    {
        DefaultConsumer stdout = new DefaultConsumer();

        DefaultConsumer stderr = stdout;

        logger.info( cl.toString() );

        ok = CommandLineUtils.executeCommandLine( cl, stdout, stderr );
    }
    catch ( CommandLineException ecx )
    {
        throw new NativeBuildException( "Error executing command line", ecx );
    }

    if ( ok != 0 )
    {
        throw new NativeBuildException( "Error executing command line. Exit code:" + ok );
    }
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
private void execute(Commandline jDepsCommand) throws CommandLineException {
	StringStreamConsumer errorConsoleConsumer = new StringStreamConsumer();

	MojoLogging.logger().debug(format("Running JDeps: %s", jDepsCommand));
	MojoLogging.logger().debug(String.format(
			"(JDeps output is forwarded here. "
					+ "Lines are marked: %s = recognized as dependency; %s = not recognized.)",
			ViolationParser.MESSAGE_MARKER_JDEPS_LINE,
			ViolationParser.MESSAGE_MARKER_UNKNOWN_LINE));

	int exitCode = CommandLineUtils.executeCommandLine(
			jDepsCommand, jDepsOutputConsumer::accept, errorConsoleConsumer);

	MojoLogging.logger().debug(format("JDeps completed with exit code %d.", exitCode));

	if (exitCode != 0)
		throwCommandLineException(jDepsCommand, exitCode, errorConsoleConsumer.getOutput());
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
private static boolean isSvn18()
{
    Commandline cl = new Commandline();
    cl.setExecutable( "svn" );

    StringStreamConsumer stdout = new StringStreamConsumer();
    StringStreamConsumer stderr = new StringStreamConsumer();

    try
    {
        CommandLineUtils.executeCommandLine( cl, stdout, stderr );
        return stdout.getOutput().contains( "svn, version 1.8." );
    }
    catch ( CommandLineException e )
    {
    }

    return false;
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
private static String getDotExecutable() {
  Commandline cmd = new Commandline();
  String finderExecutable = isWindows() ? "where.exe" : "which";

  cmd.setExecutable(finderExecutable);
  cmd.addArguments(new String[]{"dot"});

  CommandLineUtils.StringStreamConsumer systemOut = new CommandLineUtils.StringStreamConsumer();
  CommandLineUtils.StringStreamConsumer systemErr = new CommandLineUtils.StringStreamConsumer();

  try {
    int exitCode = CommandLineUtils.executeCommandLine(cmd, systemOut, systemErr);
    if (exitCode != 0) {
      return null;
    }
  } catch (CommandLineException e) {
    return null;
  }

  return systemOut.getOutput();
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
public Process start() throws ExecutionException {
  Commandline commandline = getCommandLine();

  String[] shellCommandline = commandline.getShellCommandline();

  if (LOGGER.isDebugEnabled()) {
    LOGGER.debug(PHANTOMJS_COMMAND, Arrays.asList(shellCommandline));
  }

  ProcessBuilder processBuilder = new ProcessBuilder(shellCommandline);

  if (commandline.getWorkingDirectory() != null) {
    processBuilder.directory(commandline.getWorkingDirectory());
  }

  try {
    return processBuilder.start();
  } catch(IOException e) {
    throw new ExecutionException(UNABLE_TO_START,e);
  }
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
private Commandline getCommandLine() throws ExecutionException {
  Commandline commandline = new Commandline(this.phantomJsBinary);

  if (configFile != null && configFile.exists()) {
    commandline.createArg().setValue("--config=" + configFile.getAbsolutePath());
  } else {
    commandline.addArguments(this.getCommandLineOptions(commandLineOptions));
  }
  if (script != null) {
    commandline.createArg().setValue(script);
  }
  if (arguments != null) {
    commandline.addArguments(arguments.toArray(new String[arguments.size()]));
  }
  if (workingDirectory != null) {
    commandline.setWorkingDirectory(workingDirectory);
  }

  return commandline;
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
/**
 * Method to add on any additional command line arguments for this mode of invoking the
 * DataNucleus Enhancer.
 * @param cl The current CommandLine
 * @param args Args that will be updated with anything appended here
 */
protected void prepareModeSpecificCommandLineArguments(Commandline cl, List args)
{
    if (targetDirectory != null && targetDirectory.trim().length() > 0)
    {
        // Output the enhanced classes to a different location
        if (fork)
        {
            cl.createArg().setValue("-d");
            cl.createArg().setValue(targetDirectory);
        }
        else
        {
            args.add("-d");
            args.add(targetDirectory);
        }
    }
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
private Commandline createJDepsCommand(Path jDepsExecutable) {
	Commandline jDepsCommand = new Commandline();
	jDepsCommand.setExecutable(jDepsExecutable.toAbsolutePath().toString());
	jDepsCommand.createArg().setValue("-jdkinternals");
	jDepsCommand.createArg().setFile(artifactToAnalyze.toFile());
	return jDepsCommand;
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
private void execute(Commandline jDepsCommand) throws CommandLineException {
	StringStreamConsumer errorConsoleConsumer = new StringStreamConsumer();
	int exitCode = CommandLineUtils.executeCommandLine(
			jDepsCommand, jDepsOutputConsumer::accept, errorConsoleConsumer);
	if (exitCode != 0)
		throwCommandLineException(jDepsCommand, exitCode, errorConsoleConsumer.getOutput());
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
private static void throwCommandLineException(Commandline jDepsCommand, int exitCode, String errorOutput)
		throws CommandLineException {
	StringBuilder message = new StringBuilder("JDeps returned with exit code '" + exitCode + "'.\n");
	message.append("\t Executed command: "
			+ CommandLineUtils.toString(jDepsCommand.getCommandline()).replaceAll("'", ""));
	message.append("\t Error output:\n");
	streamLines(errorOutput).forEachOrdered(errorLine -> message.append("\t\t " + errorLine + "\n"));

	throw new CommandLineException(message.toString());
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
protected Commandline getCommandLine( File src, File dest, CompilerConfiguration config )
    throws NativeBuildException
{
    if ( config.getExecutable() == null || config.getExecutable().trim().length() == 0 )
    {
        config.setExecutable( "bcc32" );
    }

    Commandline cl = super.getCommandLine( src, dest, config );

    return cl;
}
 

import org.codehaus.plexus.util.cli.Commandline; //导入依赖的package包/类
protected Commandline createLinkerCommandLine( List objectFiles, LinkerConfiguration config )
    throws NativeBuildException
{
    Commandline cl = new Commandline();

    cl.setWorkingDirectory( config.getWorkingDirectory().getPath() );

    String executable = EXECUTABLE;

    if ( config.getExecutable() != null && config.getExecutable().trim().length() != 0 )
    {
        executable = config.getExecutable();
    }

    cl.createArg().setValue( executable );

    cl.createArg().setValue( "\"" + config.getOutputFile() + "\"" );

    for ( int i = 0; i < config.getStartOptions().length; ++i )
    {
        cl.createArg().setValue( config.getStartOptions()[i] );
    }

    for ( int i = 0; i < objectFiles.size(); ++i )
    {
        File objFile = (File) objectFiles.get( i );

        cl.createArg().setValue( "+\"" + objFile.getPath() + "\"" );
    }

    return cl;

}