java调用python文件的几种方式【超细讲解！】

迈不过友情╰ 2024-04-07 10:14 64阅读 0赞

java调用python的契机来自于一个项目需要用到算法，但是算法工程师们写的python，于是就有了java后端调用python脚本的需求，中间遇到了许多问题，特此记录整理了一次。

## 1、java调用python的方式有哪几种 ##

### 1.1 方法一：jpython ###

专门为java调用python2开发出来的类库，但由于不支持python3版本，python2和3之间的语法又不兼容导致jpython库并非特别通用。github有人问到过什么时候出python3版本的库，官方答复说是可行的但很困难（截止2022年8月份 jpython官方目前没有开发出支持python3的类库）

jpython的语法特别简单，使用PythonIntercepter即可简单的操作python文件。

#### 1.1.1 导入jar包 ####

<dependency>
      <groupId>org.python</groupId>
      <artifactId>jython-standalone</artifactId>
      <version>2.7.0</version>
    </dependency>

#### 1.1.2 调用python脚本中的method1()方法 ####

PythonInterpreter interpreter = new PythonInterpreter();
    interpreter.execfile("C:\\Users\\Dick\\Desktop\\demo.py");
    // 调用demo.py中的method1方法
    PyFunction func = interpreter.get("method1",PyFunction.class);
    Integer a = 10;
    Integer b = 10;
    PyObject pyobj = func.__call__(new PyInteger(a), new PyInteger(b));
    System.out.println("获得方法的返回值 = " + pyobj.toString());

注：如无返回值 仅执行interpreter.execfile()方法即可

### 1.2 方法二：ProcessBuilder ###

ProcessBuilder是jdk提供的脚本执行工具类，无论是python文件还是shell脚本还是其他的指令，都可以通过此类来执行，我们来看看它是如何调用python脚本的

#### 1.2.1 首先我们把python文件放入resource下 ####

![4ee79bc83fe749db89500f92d3456ce6.png][]

#### 1.2.2 接下来就是执行脚本了 ####

/**
     * 执行python脚本
     * @param fileName 脚本文件名称
     * @param params 脚本参数
     * @throws IOException
     */
    public static void execPythonFile(String fileName, String params) throws IOException {
    
      // 获取python文件所在目录地址
      String windowsPath = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/"; 
    
      // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
      Process process = new ProcessBuilder("cmd.exe", "/c", "python", windowsPath + fileName, params).start();
    
      logger.info("读取python文件 开始 fileName={}", fileName);
      BufferedReader errorReader = null;
      // 脚本执行异常时的输出信息
      errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
      List<String> errorString = read(fileName, errorReader);
      logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
    
      // 脚本执行正常时的输出信息
      BufferedReader inputReader = null;
      inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
      List<String> returnString = read(fileName, inputReader);
      logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
    
      try {
          logger.info("读取python文件 wait fileName={}", fileName);
          process.waitFor();
      } catch (InterruptedException e) {
          logger.error("读取python文件 fileName="+fileName+" 等待结果返回异常", e);
      }
      logger.info("读取python文件 fileName={} == 结束 ==", fileName);
    }
    private static List<String> read(String fileName, BufferedReader reader) {
            List<String> resultList =  Lists.newArrayList();
            String res = "";
            while (true) {
                try {
                    if (!((res = reader.readLine()) != null)) break;
                } catch (IOException e) {
                    logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
                }
                resultList.add(res);
            }
            return resultList;
    }

上述代码仅考虑了windows，而在Linux中情况会比较复杂一点。

#### 1.2.3 Linux中执行python存在的问题 ####

我们知道常规的项目部署是将项目打成jar包，然后直接放入Linux 或者通过docker等容器进行部署，这个时候resources下的py文件就在jar包里了,但我们执行python脚本时使用的是：

python3 脚本文件所在地

此时python脚本在jar包里面，不能通过 jar路径/BOOT-INF/classes/py/xxx.py进行访问【我测试过一段时间 发现python3 (python指令也不行) 指令无法调用在jar里面的脚本】，所以我能想到的方案是将python脚本文件直接放入服务器的某个文件夹中，方便后续访问。如果是docker部署，只需要在dockerfile中加入一个COPY指令 将py文件放到指定目录下：

![f0e7174c8b3c412faffce1674fdca761.png][]

#### 1.2.4 Linux中执行python文件 ####

下面代码将兼容windows和linux调用py文件【Linux执行py文件是使用python还是python3根据实际py环境变量配置来选择就好】

/**
    * 执行python文件
    * @param fileName python文件地址
    * @param params 参数 其实可以改成传入多个参数 一个个放入ProcessBuilder中的
    * @throws IOException
    */
    public static void execPythonFile(String fileName, String params) throws IOException {
      // ① 当前系统类型
      String os = System.getProperty("os.name");
    
      // ② 获取python文件所在目录地址
      String windowsPath = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/";  
      String linuxPath = "/ai/egcc/";
    
      logger.info("读取python文件 init fileName={}&path={}", fileName);
      Process process;
      if (os.startsWith("Windows")){
          // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
          process = new ProcessBuilder("cmd.exe", "/c", "python", windowsPath + fileName, params).start();
      }else {
          // linux执行脚本一般是使用python3 + 文件所在路径
          process = new ProcessBuilder("python3", linuxPath + fileName, params).start();
      }
    
      logger.info("读取python文件 开始 fileName={}", fileName);
      BufferedReader errorReader = null;
      // 脚本执行异常时的输出信息
      errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
      List<String> errorString = read(fileName, errorReader);
      logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
    
      // 脚本执行正常时的输出信息
      BufferedReader inputReader = null;
      inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
      List<String> returnString = read(fileName, inputReader);
      logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
    
      try {
          logger.info("读取python文件 wait fileName={}", fileName);
          process.waitFor();
      } catch (InterruptedException e) {
          logger.error("读取python文件 fileName="+fileName+" 等待结果返回异常", e);
      }
      logger.info("读取python文件 fileName={} == 结束 ==", fileName);
    }
    private static List<String> read(String fileName, BufferedReader reader) {
        List<String> resultList =  Lists.newArrayList();
        String res = "";
        while (true) {
            try {
                if (!((res = reader.readLine()) != null)) break;
            } catch (IOException e) {
                logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
            }
            resultList.add(res);
        }
        return resultList;
    }

以为这就完了吗，其实还没有呢，process.waitFor()方法其实存在一些问题，如果上线后可能会造成事故，具体参考：j[ava调用exe程序 使用process.waitFor()死锁][ava_exe_ _process.waitFor]

那我们就尝试用线程池来解决死锁的问题吧

#### 1.2.5 解决java调用脚本文件存在的隐式问题解决 ####

以下为终极版代码：

private static ExecutorService taskPool = new ThreadPoolExecutor(8, 32
            ,200L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(600)
            ,new ThreadFactoryBuilder()
            .setNameFormat("thread-自定义线程名-runner-%d").build());
    /**
    * 执行python文件
    * @param fileName python文件地址
    * @param params 参数 多个直接逗号隔开
    * @throws IOException
    */
    public static void execPythonFile(String fileName, String params) throws IOException {
        // ① 当前系统类型
        String os = System.getProperty("os.name");
      
        // ② 获取python文件所在目录地址
        String windowsPath = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/";  
        String linuxPath = "/ai/egcc/";
      
        logger.info("读取python文件 init fileName={}&path={}", fileName);
        Process process;
        if (os.startsWith("Windows")){
            // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
            process = new ProcessBuilder("cmd.exe", "/c", "python", windowsPath + fileName, params).start();
        }else {
            // linux执行脚本一般是使用python3 + 文件所在路径
            process = new ProcessBuilder("python3", linuxPath + fileName, params).start();
        }
    
        taskPool.submit(() -> {
            logger.info("读取python文件 开始 fileName={}", fileName);
            BufferedReader errorReader = null;
            // 脚本执行异常时的输出信息
            errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
            List<String> errorString = read(fileName, errorReader);
            logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
        });
    
        taskPool.submit(() -> {
            // 脚本执行正常时的输出信息
            BufferedReader inputReader = null;
            inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            List<String> returnString = read(fileName, inputReader);
            logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
        });
        
        try {
            logger.info("读取python文件 wait fileName={}", fileName);
            process.waitFor();
        } catch (InterruptedException e) {
            logger.error("读取python文件 fileName="+fileName+" 等待结果返回异常", e);
        }
        logger.info("读取python文件 fileName={} == 结束 ==", fileName);
    }
    private static List<String> read(String fileName, BufferedReader reader) {
        List<String> resultList =  Lists.newArrayList();
        String res = "";
        while (true) {
            try {
                if (!((res = reader.readLine()) != null)) break;
            } catch (IOException e) {
                logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
            }
            resultList.add(res);
        }
        return resultList;
    }

好了 上述代码已经可以正确的调用python脚本了，但博主目前仍然有些问题还没解决：比如如何调用java的jar包内部的py文件？在windows上的jar包内的py文件是可以调用成功的【我在windows本地启动jar包做过测试】，但是docker容器里面的jar却无法调用成功的原因是什么？

如果有朋友遇到问题欢迎在评论区留言和讨论

#### 1.2.6 终极版python执行工具类【建议使用】 ####

import com.google.common.collect.Lists;
    import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    import org.springframework.util.ClassUtils;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.List;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * java调用python的执行器
     */
    @Component
    public class PythonExecutor {
        private static final Logger logger = LoggerFactory.getLogger(PythonExecutor.class);
        private static final String OS = System.getProperty("os.name");
    
        private static final String WINDOWS_PATH = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/automl/";  // windows为获取项目根路径即可
        private static final String LINUX_PATH = "/ai/xx";// linux为python文件所在目录
    
        private static ExecutorService taskPool = new ThreadPoolExecutor(8, 16
                , 200L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(600)
                , new ThreadFactoryBuilder()
                .setNameFormat("thread-自定义线程名-runner-%d").build());
    
        /**
         * 执行python文件【异步 无需等待py文件执行完毕】
         *
         * @param fileName python文件地址
         * @param params   参数
         * @throws IOException
         */
        public static void execPythonFile(String fileName, String params) {
            taskPool.submit(() -> {
                try {
                    exec(fileName, params);
                } catch (IOException e) {
                    logger.error("读取python文件 fileName=" + fileName + " 异常", e);
                }
            });
    
        }
    
        /**
         * 执行python文件 【同步 会等待py执行完毕】
         *
         * @param fileName python文件地址
         * @param params   参数
         * @throws IOException
         */
        public static void execPythonFileSync(String fileName, String params) {
            try {
                execSync(fileName, params);
            } catch (IOException e) {
                logger.error("读取python文件 fileName=" + fileName + " 异常", e);
            }
        }
    
        private static void exec(String fileName, String params) throws IOException {
            logger.info("读取python文件 init fileName={}&path={}", fileName, WINDOWS_PATH);
            Process process;
            if (OS.startsWith("Windows")) {
                // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
                process = new ProcessBuilder("cmd.exe", "/c", "python", WINDOWS_PATH + fileName, params).start();
            } else {
                // linux执行脚本一般是使用python3 + 文件所在路径
                process = new ProcessBuilder("python3", LINUX_PATH + fileName, params).start();
            }
    
            new Thread(() -> {
                logger.info("读取python文件 开始 fileName={}", fileName);
                BufferedReader errorReader = null;
                // 脚本执行异常时的输出信息
                errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
                List<String> errorString = read(fileName, errorReader);
                logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
            }).start();
    
            new Thread(() -> {
                // 脚本执行正常时的输出信息
                BufferedReader inputReader = null;
                inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                List<String> returnString = read(fileName, inputReader);
                logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
            }).start();
    
            try {
                logger.info("读取python文件 wait fileName={}", fileName);
                process.waitFor();
            } catch (InterruptedException e) {
                logger.error("读取python文件 fileName=" + fileName + " 等待结果返回异常", e);
            }
            logger.info("读取python文件 fileName={} == 结束 ==", fileName);
        }
    
        private static void execSync(String fileName, String params) throws IOException {
            logger.info("同步读取python文件 init fileName={}&path={}", fileName, WINDOWS_PATH);
            Process process;
            if (OS.startsWith("Windows")) {
                // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
                process = new ProcessBuilder("cmd.exe", "/c", "python", WINDOWS_PATH + fileName, params).start();
            } else {
                // linux执行脚本一般是使用python3 + 文件所在路径
                process = new ProcessBuilder("python3", LINUX_PATH + fileName, params).start();
            }
    
            taskPool.submit(() -> {
                logger.info("读取python文件 开始 fileName={}", fileName);
                BufferedReader errorReader = null;
                // 脚本执行异常时的输出信息
                errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
                List<String> errorString = read(fileName, errorReader);
                logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
            });
    
            taskPool.submit(() -> {
                // 脚本执行正常时的输出信息
                BufferedReader inputReader = null;
                inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                List<String> returnString = read(fileName, inputReader);
                logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
            });
    
            try {
                logger.info("同步读取python文件 wait fileName={}", fileName);
                process.waitFor();
            } catch (InterruptedException e) {
                logger.error("同步读取python文件 fileName=" + fileName + " 等待结果返回异常", e);
            }
            logger.info("同步读取python文件 fileName={} == 结束 ==", fileName);
        }
    
        private static List<String> read(String fileName, BufferedReader reader) {
            List<String> resultList = Lists.newArrayList();
            String res = "";
            while (true) {
                try {
                    if (!((res = reader.readLine()) != null)) break;
                } catch (IOException e) {
                    logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
                }
                resultList.add(res);
            }
            return resultList;
        }
    
    }

===== 补充 =====

有小伙伴可能在别的博文上找到下面的java调用脚本方式

Runtime.getRuntime().exec()

其实上面的脚本底层用的也是ProcessBuilder对象，所以是一样的。

[4ee79bc83fe749db89500f92d3456ce6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/6c6f5afeec3c4476b1adb86538059923.png
[f0e7174c8b3c412faffce1674fdca761.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/ae70e5400f3745d9971e055d20dcd8af.png
[ava_exe_ _process.waitFor]: https://blog.csdn.net/qq_27948659/article/details/80895860