How to run Unix shell script from Java code?

Setting up the script environment

Before you can elegantly run your script like a symphony conductor, a proper environment has to be set up first. Use ProcessBuilder to configuring environment variables, creating a perfect atmosphere for your script to play out:

ProcessBuilder processBuilder = new ProcessBuilder("/path/to/script.sh");
Map<String, String> env = processBuilder.environment();
env.put("VAR1", "Value1"); // Setting the stage, similar to setting the lights before a concert ;)
processBuilder.start().waitFor();


By doing so, your script performs in the ideal environment, giving a fantastic execution.

Capturing the output melody

Capturing and listening to the melody of your script's output is as critical as running it. Use a BufferedReader to process the script's output seamlessly:

ProcessBuilder processBuilder = new ProcessBuilder("/path/to/script.sh");
Process process = processBuilder.start();
InputStream inputStream = process.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
reader.lines().forEach(System.out::println); // Same as setting up speakers on stage to hear the music ;)
process.waitFor();


This approach not only puts you in control and but also helps you debug or log the output.

Conducting with Runtime.exec()

ProcessBuilder is a great conductor, but you can also use Runtime.getRuntime().exec() as an alternative way of conducting:

String command = "/path/to/script.sh";
Runtime.getRuntime().exec(command);


While less flexible compared to ProcessBuilder, it's like the accordion of language conductors - simple yet effective when used right.

Handling common execution errors

Whenever scripts fail to execute, it's like your violinist is late for the concert. Validate the path to the script similar to checking if all musicians are present:

String pathToScript = "/path/to/script.sh";
File script = new File(pathToScript);
if(script.exists() && !script.isDirectory()) { 
    new ProcessBuilder(pathToScript).start().waitFor();
} else {
    throw new FileNotFoundException("Violinist not found at: " + pathToScript);
}


By confirming the existence of the script, you prevent abrupt recessions mid-concert.

Utilizing Apache Commons Exec

Just like a music sheet guides a conductor, Apache Commons Exec provides a detailed layout to handle external processes:

CommandLine commandLine = CommandLine.parse("/path/to/script.sh");
DefaultExecutor executor = new DefaultExecutor();
executor.setExitValue(0);
try {
    executor.execute(commandLine);
} catch (ExecuteException e) {
    // It's like a string snapping mid-concert!!
} catch (IOException e) {
    // Or the lights going out!!
}


The Apache Commons Exec’s CommandLine class deciphers complex commands like musical notes, offering a more structured approach to running scripts.

Streamlining for portability

To avoid conducting a jazz band at a classical concert, limit the use of Unix shell scripts. Contemplate Java-based alternatives as they are more portable and maintainable.

Rehearsing on the intended system

Just like testing acoustics before a concert, make sure to verify your solution by testing within your intended system. This checks your code's harmony with the system and reduces unwelcome surprises.