如何在Python中调用Linux系统中已安装的.jar程序并实现循环执行

Great question! Let's break this down step by step—calling a .jar file from Python just boils down to executing the java -jar command through Python's built-in tools, and adding loops is straightforward once you have the basic call working.

1. The Core Tool: subprocess Module #

On Linux, running a .jar file uses the command java -jar /path/to/your/program.jar. In Python, the subprocess module is the official, most flexible way to run external commands (way better than the old os.system()). It lets you capture output, handle errors, and control execution flow.

Basic Single Execution #

First, let's make sure we can run the .jar once successfully:

import subprocess

# Replace with your actual .jar file path (absolute path is safest!)
jar_file = "/home/your_username/your_program.jar"

# Build the command as a list (avoids shell injection risks)
command = ["java", "-jar", jar_file]

try:
    # Run the command and wait for it to finish
    result = subprocess.run(
        command,
        check=True,  # Throws an error if the .jar exits with a non-zero code
        stdout=subprocess.PIPE,  # Capture the program's output
        stderr=subprocess.PIPE,  # Capture any error messages
        text=True  # Return output as strings instead of bytes
    )
    
    # Print the output if everything worked
    print("Program Output:")
    print(result.stdout)
except subprocess.CalledProcessError as e:
    # Handle cases where the .jar failed to run
    print(f"Program failed with exit code {e.returncode}")
    print("Error Details:")
    print(e.stderr)

2. Adding Loop Logic to Repeat Execution #

Once the basic call works, wrapping it in a loop is trivial. Here are two common scenarios:

Scenario 1: Fixed Number of Executions #

If you need to run the .jar a set number of times (e.g., 5 times), use a for loop:

import subprocess
import time  # Optional: add delays between runs

jar_file = "/home/your_username/your_program.jar"
command = ["java", "-jar", jar_file]
total_runs = 5

for run_num in range(total_runs):
    print(f"\n=== Starting Run {run_num + 1}/{total_runs} ===")
    try:
        result = subprocess.run(
            command,
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        print(f"Run {run_num + 1} succeeded! Output:")
        print(result.stdout)
    except subprocess.CalledProcessError as e:
        print(f"Run {run_num + 1} failed:")
        print(f"Exit Code: {e.returncode}")
        print(f"Error: {e.stderr}")
    
    # Optional: wait 1 second between runs to avoid overwhelming resources
    time.sleep(1)

Scenario 2: Conditional Loop (Run Until a Condition is Met) #

If you need to keep running the .jar until a specific condition is met (e.g., the program outputs "success", or a file is created), use a while loop:

import subprocess
import time

jar_file = "/home/your_username/your_program.jar"
command = ["java", "-jar", jar_file]
max_attempts = 10  # Prevent infinite loops with a max attempt limit
attempt = 0

while attempt < max_attempts:
    attempt += 1
    print(f"\n=== Attempt {attempt}/{max_attempts} ===")
    try:
        result = subprocess.run(
            command,
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        
        # Example condition: check if the output contains "success"
        if "success" in result.stdout.lower():
            print("Condition met! Stopping loop.")
            break
        else:
            print("Run completed but condition not met. Retrying...")
    except subprocess.CalledProcessError as e:
        print(f"Attempt {attempt} failed:")
        print(f"Exit Code: {e.returncode}")
        print(f"Error: {e.stderr}")
    
    # Wait 2 seconds before retrying
    time.sleep(2)

if attempt == max_attempts:
    print(f"Max attempts ({max_attempts}) reached. Stopping.")

3. Key Tips to Avoid Headaches #

• Use Absolute Paths: Always use the full path to your .jar file (e.g., /home/you/app.jar instead of app.jar). This avoids issues if your Python script runs from a different working directory. You can get the absolute path programmatically with os.path.abspath("app.jar") if needed.
• Pass Arguments to the .jar: If your .jar accepts command-line arguments, just add them to the command list. For example:

  command = ["java", "-jar", jar_file, "--input", "data.csv", "--output", "results.txt"]
  

• Background Execution (Optional): If you don't need to wait for the .jar to finish before continuing your Python script, use subprocess.Popen() instead of subprocess.run(). Just remember to manage the subprocess to avoid zombie processes.
• Check Permissions: Make sure your user account has permission to execute the java command and read the .jar file.

内容的提问来源于stack exchange，提问作者Vivek Sharma