Reputation: 590

Execute a Java program from our Java program

I used

Runtime.getRuntime().exec("_____")

but it throws a IOException as below:

java.io.IOException: CreateProcess: c:/ error=5
  at java.lang.Win32Process.create(Native Method)
  at java.lang.Win32Process.<init>(Win32Process.java:63)
  at java.lang.Runtime.execInternal(Native Method

I don't know whether I have the problem with specifying the path or something else. Can anyone please help me with the code.

Upvotes: 10

Answers (14)

Edgard Leal

Reputation: 2720

Put ant lib in you classpath ( project lib ) and run this code :

import org.apache.tools.ant.taskdefs.Execute;

Execute exe = new Execute();
exe.setCommandline(new String[]{"java", "-version"});
exe.execute();

Upvotes: 1

jay

Reputation: 1

I agree with Ushsa Varghese, if you just want to run your jar file instead of compiling the .java file that is in the same directory you are executing your application from try the code below. This is the same as executing your java application from the command line so you have to invoke the jvm in order to run your application. Also make sure you have the complete path to your jar file the example below assumes that the jar file is in the same directory as the application that is executing the code below. keep in mind this is system dependent code.

try {
  Runtime runTime = Runtime.getRuntime();
  Process process = runTime.exec("java -jar deleteDriveC.jar");
} catch (IOException ex) {
  //jar file doesnt exist
  //Logger.getLogger(this.class.getName()).log(Level.SEVERE, null, ex);
}

Upvotes: 0

Reegan Miranda

Reputation: 2949

First you compile the prog-A code and convert to jar file(ie:In NetBeans Shift-F11)and the path is of netbeans(NetBeansProjects/prog-A/dist/prog-A.jar)

 public class ProgA {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    System.out.println("Helllo print thr ProgA");

}
}
}

Second open the new project in prog-B and add the libraries, and select the jar and give to the prog-A.jar file and write the two line in your program

public class ProgB {


public static void main(String[] args) {
    ProgA progA = new  ProgA();
    String arg[] = null;
    progA.main(arg);
}
}

Upvotes: 0

Ushsa Varghese

Reputation: 57

The answer is simple all you have to do is put the code -

$ process p = Runtime.getRuntime().exec("javac factorial.java"); in the try catch block

The code would look like this -

try
{
process p = Runtime.getRuntime().exec("javac factorial.java");
}
catch(IOException e)
{
e.printStackTrace();
}

Hey I think this should work. Atleast for me it did work

Upvotes: -1

jex

Reputation:

public class Test {    
  public static void main(String[] args) throws Exception {    
    Process p = Runtime.getRuntime().exec("\"c:/program files/windows/notepad.exe\"");
    p.waitFor();
  }

}

The above works quite well, instead of passing \"c:/program files/windows/notepad.exe\" as the arguments for the executable, use the path to your program, I'm not sure if this solution is JVM version dependent, or if it can use relative paths.

Upvotes: 2

Michael Rutherfurd

Reputation: 14045

I had a similiar problem. I needed to run a section of Java code in a seperate VM as it invoked native code via JNI that occasionally blew up taking out the entire VM.

I cheated a little though. I initially used Runtime to invoke a simple batch command file and put the work-in-progress java command in there. This enabled me to tweak it as needed and to run the command in a DOS prompt for easy testing. Once it was finished I simply copied the result into the Runtime invocation.

Upvotes: 0

Stroboskop

Reputation: 4356

You can either launch another JVM (as described in detail in other answers). But that is not a solution i would prefer.

Reasons are:

calling a native program from java is "dirty" (and sometimes crashes your own VM)
you need to know the path to the external JVM (modern JVMs don't set JAVA_HOME anymore)
you have no control on the other program

Main reason to do it anyway is, that the other application has no control over your part of the program either. And more importantly there's no trouble with unresponsive system threads like the AWT-Thread if the other application doesn't know its threading 101.

But! You can achieve more control and similar behaviour by using an elementary plugin technique. I.e. just call "a known interface method" the other application has to implement. (in this case the "main" method).

Only it's not quite as easy as it sounds to pull this off.

you have to dynamically include required jars at runtime (or include them in the classpath for your application)
you have to put the plugin in a sandbox that prevents compromising critical classes to the other application

And this calls for a customized classloader. But be warned - there are some well hidden pitfalls in implementing that. On the other hand it's a great exercise.

So, take your pick: either quick and dirty or hard but rewarding.

Upvotes: 8

McDowell

Reputation: 108859

java.io.IOException: CreateProcess: c:/ error=5
        at java.lang.Win32Process.create(Native Method)
        at java.lang.Win32Process.&lt;init&gt;(Win32Process.java:63)
        at java.lang.Runtime.execInternal(Native Method)

If I recall correctly, error code 5 means access denied. This could be because your path is incorrect (trying to execute "c:/") or you are bumping against your OS security (in which case, look at the permissions).

If you are having trouble locating the Java executable, you can usually find it using system properties:

public class LaunchJre {

    private static boolean isWindows() {
        String os = System.getProperty("os.name");
        if (os == null) {
            throw new IllegalStateException("os.name");
        }
        os = os.toLowerCase();
        return os.startsWith("windows");
    }

    public static File getJreExecutable() throws FileNotFoundException {
        String jreDirectory = System.getProperty("java.home");
        if (jreDirectory == null) {
            throw new IllegalStateException("java.home");
        }
        File exe;
        if (isWindows()) {
            exe = new File(jreDirectory, "bin/java.exe");
        } else {
            exe = new File(jreDirectory, "bin/java");
        }
        if (!exe.isFile()) {
            throw new FileNotFoundException(exe.toString());
        }
        return exe;
    }

    public static int launch(List<String> cmdarray) throws IOException,
            InterruptedException {
        byte[] buffer = new byte[1024];

        ProcessBuilder processBuilder = new ProcessBuilder(cmdarray);
        processBuilder.redirectErrorStream(true);
        Process process = processBuilder.start();
        InputStream in = process.getInputStream();
        while (true) {
            int r = in.read(buffer);
            if (r <= 0) {
                break;
            }
            System.out.write(buffer, 0, r);
        }
        return process.waitFor();
    }

    public static void main(String[] args) {
        try {
            Runtime.getRuntime().exec("c:/");

            List<String> cmdarray = new ArrayList<String>();
            cmdarray.add(getJreExecutable().toString());
            cmdarray.add("-version");
            int retValue = launch(cmdarray);
            if (retValue != 0) {
                System.err.println("Error code " + retValue);
            }
            System.out.println("OK");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

(Tested Windows XP, Sun JRE 1.6; Ubuntu 8.04, OpenJDK JRE 1.6)

This is the equivalent of running:

java -version

You may also want to look at the "java.library.path" system property (and "path.separator") when trying to locate the executable.

Upvotes: 7

PhiLho

Reputation: 41132

I had to do this recently.
Here is how I did it, picking up only the relevant parts:

private static final String[] straJavaArgs =
{
   "?i/j2re/bin/java",
   "-ms64m",
   "-mx64m",
   "-Djava.ext.dirs=?i/lib;?i/jar/lib;?i/jar"
};

// ...

  // AppDesc appToRun;
  List<String> params = new ArrayList<String>();
  // Java exe and parameters
  params.addAll(ExpandStrings(straJavaArgs));
  // Common VM arguments
  params.addAll(Arrays.asList(AppDesc.GetCommonVMArgs()));
  // Specific VM arguments
  params.addAll(ExpandStrings(appToRun.GetVMArgs()));
  // The program to run
  params.add(appToRun.GetClass());
  // Its arguments
  params.addAll(ExpandStrings(appToRun.GetProgramArgs()));
  // The common arguments
  params.addAll(ExpandStrings(AppDesc.GetCommonProgramArgs()));

  ProcessBuilder processBuilder = new ProcessBuilder(params);
  process = processBuilder.start();
  return CaptureProcessOutput(); // Uses a StreamGobbler class

protected ArrayList<String> ExpandStrings(String[] stra)
{
  ArrayList<String> alResult = new ArrayList<String>();
  for (int i = 0; i < stra.length; i++)
  {
     // Super flexible, eh? Ad hoc for the current task, at least...
     alResult.add(stra[i]
           .replaceAll("\\?i", strInstallDir)
           .replaceAll("\\?c", strConfigDir)
     );
  }
  return alResult;
}

public enum AppDesc
{
// Enumerate the applications to run, with their parameters
}

Incomplete, if you need more details, just ask.

Upvotes: 2

Mark

Reputation: 6301

You're trying to execute "C:/". You'll want to execute something like:

"javaw.exe d:\\somejavaprogram\\program.jar"

Notice the path separators.

I'm assuming this is for an ad-hoc project, rather than something large. However, for best practice running external programs from code:

Don't hardcode the executable location, unless you're certain it will never change
Look up directories like %windir% using System.getenv
Don't assume programs like javaw.exe are in the search path: check them first, or allow the user to specify a location
Make sure you're taking spaces into account: "cmd /c start " + myProg will not work if myProg is "my program.jar".

Upvotes: 10

Ray Hidayat

Reputation: 16249

I can't remember the exact code that I used to get this to work, but you have to pass "java.exe" (or the equivalent) as the executable, and then the class or jar to run as the parameter, with the correct working directory. So it's not as simple as just calling one method.

Upvotes: 0