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

      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包

    1. <dependency>
    2.   <groupId>org.pythongroupId>
    3.   <artifactId>jython-standaloneartifactId>
    4.   <version>2.7.0version>
    5. dependency>

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

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

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

       1.2   方法二：ProcessBuilder

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

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

        1.2.2 接下来就是执行脚本了 

    1. /**
    2.  * 执行python脚本
    3.  * @param fileName 脚本文件名称
    4.  * @param params 脚本参数
    5.  * @throws IOException
    6.  */
    7. public static void execPythonFile(String fileName, String params) throws IOException {
    8.  
    9.   // 获取python文件所在目录地址
    10.   String windowsPath = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/"; 
    11.  
    12.   // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
    13.   Process process = new ProcessBuilder("cmd.exe", "/c", "python", windowsPath + fileName, params).start();
    14.  
    15.   logger.info("读取python文件 开始 fileName={}", fileName);
    16.   BufferedReader errorReader = null;
    17.   // 脚本执行异常时的输出信息
    18.   errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    19.   List errorString = read(fileName, errorReader);
    20.   logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
    21.  
    22.   // 脚本执行正常时的输出信息
    23.   BufferedReader inputReader = null;
    24.   inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    25.   List returnString = read(fileName, inputReader);
    26.   logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
    27.  
    28.   try {
    29.       logger.info("读取python文件 wait fileName={}", fileName);
    30.       process.waitFor();
    31.   } catch (InterruptedException e) {
    32.       logger.error("读取python文件 fileName="+fileName+" 等待结果返回异常", e);
    33.   }
    34.   logger.info("读取python文件 fileName={} == 结束 ==", fileName);
    35. }
    36. private static List read(String fileName, BufferedReader reader) {
    37.         List resultList =  Lists.newArrayList();
    38.         String res = "";
    39.         while (true) {
    40.             try {
    41.                 if (!((res = reader.readLine()) != null)) break;
    42.             } catch (IOException e) {
    43.                 logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
    44.             }
    45.             resultList.add(res);
    46.         }
    47.         return resultList;
    48. }

        上述代码仅考虑了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文件放到指定目录下：

     1.2.4 Linux中执行python文件

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

    1. /**
    2. * 执行python文件
    3. * @param fileName python文件地址
    4. * @param params 参数 其实可以改成传入多个参数 一个个放入ProcessBuilder中的
    5. * @throws IOException
    6. */
    7. public static void execPythonFile(String fileName, String params) throws IOException {
    8.   // ① 当前系统类型
    9.   String os = System.getProperty("os.name");
    10.  
    11.   // ② 获取python文件所在目录地址
    12.   String windowsPath = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/";  
    13.   String linuxPath = "/ai/egcc/";
    14.  
    15.   logger.info("读取python文件 init fileName={}&path={}", fileName);
    16.   Process process;
    17.   if (os.startsWith("Windows")){
    18.       // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
    19.       process = new ProcessBuilder("cmd.exe", "/c", "python", windowsPath + fileName, params).start();
    20.   }else {
    21.       // linux执行脚本一般是使用python3 + 文件所在路径
    22.       process = new ProcessBuilder("python3", linuxPath + fileName, params).start();
    23.   }
    24.  
    25.   logger.info("读取python文件 开始 fileName={}", fileName);
    26.   BufferedReader errorReader = null;
    27.   // 脚本执行异常时的输出信息
    28.   errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    29.   List errorString = read(fileName, errorReader);
    30.   logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
    31.  
    32.   // 脚本执行正常时的输出信息
    33.   BufferedReader inputReader = null;
    34.   inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    35.   List returnString = read(fileName, inputReader);
    36.   logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
    37.  
    38.   try {
    39.       logger.info("读取python文件 wait fileName={}", fileName);
    40.       process.waitFor();
    41.   } catch (InterruptedException e) {
    42.       logger.error("读取python文件 fileName="+fileName+" 等待结果返回异常", e);
    43.   }
    44.   logger.info("读取python文件 fileName={} == 结束 ==", fileName);
    45. }
    46. private static List read(String fileName, BufferedReader reader) {
    47.     List resultList =  Lists.newArrayList();
    48.     String res = "";
    49.     while (true) {
    50.         try {
    51.             if (!((res = reader.readLine()) != null)) break;
    52.         } catch (IOException e) {
    53.             logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
    54.         }
    55.         resultList.add(res);
    56.     }
    57.     return resultList;
    58. }

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

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

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

    以下为终极版代码：

    1. private static ExecutorService taskPool = new ThreadPoolExecutor(8, 32
    2.         ,200L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue(600)
    3.         ,new ThreadFactoryBuilder()
    4.         .setNameFormat("thread-自定义线程名-runner-%d").build());
    5. /**
    6. * 执行python文件
    7. * @param fileName python文件地址
    8. * @param params 参数 多个直接逗号隔开
    9. * @throws IOException
    10. */
    11. public static void execPythonFile(String fileName, String params) throws IOException {
    12.     // ① 当前系统类型
    13.     String os = System.getProperty("os.name");
    14.   
    15.     // ② 获取python文件所在目录地址
    16.     String windowsPath = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/";  
    17.     String linuxPath = "/ai/egcc/";
    18.   
    19.     logger.info("读取python文件 init fileName={}&path={}", fileName);
    20.     Process process;
    21.     if (os.startsWith("Windows")){
    22.         // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
    23.         process = new ProcessBuilder("cmd.exe", "/c", "python", windowsPath + fileName, params).start();
    24.     }else {
    25.         // linux执行脚本一般是使用python3 + 文件所在路径
    26.         process = new ProcessBuilder("python3", linuxPath + fileName, params).start();
    27.     }
    28.  
    29.     taskPool.submit(() -> {
    30.         logger.info("读取python文件 开始 fileName={}", fileName);
    31.         BufferedReader errorReader = null;
    32.         // 脚本执行异常时的输出信息
    33.         errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    34.         List errorString = read(fileName, errorReader);
    35.         logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
    36.     });
    37.  
    38.     taskPool.submit(() -> {
    39.         // 脚本执行正常时的输出信息
    40.         BufferedReader inputReader = null;
    41.         inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    42.         List returnString = read(fileName, inputReader);
    43.         logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
    44.     });
    45.     
    46.     try {
    47.         logger.info("读取python文件 wait fileName={}", fileName);
    48.         process.waitFor();
    49.     } catch (InterruptedException e) {
    50.         logger.error("读取python文件 fileName="+fileName+" 等待结果返回异常", e);
    51.     }
    52.     logger.info("读取python文件 fileName={} == 结束 ==", fileName);
    53. }
    54. private static List read(String fileName, BufferedReader reader) {
    55.     List resultList =  Lists.newArrayList();
    56.     String res = "";
    57.     while (true) {
    58.         try {
    59.             if (!((res = reader.readLine()) != null)) break;
    60.         } catch (IOException e) {
    61.             logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
    62.         }
    63.         resultList.add(res);
    64.     }
    65.     return resultList;
    66. }

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

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

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

    1. import com.google.common.collect.Lists;
    2. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    3. import org.slf4j.Logger;
    4. import org.slf4j.LoggerFactory;
    5. import org.springframework.stereotype.Component;
    6. import org.springframework.util.ClassUtils;
    7. import java.io.BufferedReader;
    8. import java.io.IOException;
    9. import java.io.InputStreamReader;
    10. import java.util.List;
    11. import java.util.concurrent.ExecutorService;
    12. import java.util.concurrent.LinkedBlockingQueue;
    13. import java.util.concurrent.ThreadPoolExecutor;
    14. import java.util.concurrent.TimeUnit;
    15.  
    16. /**
    17.  * java调用python的执行器
    18.  */
    19. @Component
    20. public class PythonExecutor {
    21.     private static final Logger logger = LoggerFactory.getLogger(PythonExecutor.class);
    22.     private static final String OS = System.getProperty("os.name");
    23.  
    24.     private static final String WINDOWS_PATH = ClassUtils.getDefaultClassLoader().getResource("").getPath().substring(1) + "py/automl/";  // windows为获取项目根路径即可
    25.     private static final String LINUX_PATH = "/ai/xx";// linux为python文件所在目录
    26.  
    27.     private static ExecutorService taskPool = new ThreadPoolExecutor(8, 16
    28.             , 200L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(600)
    29.             , new ThreadFactoryBuilder()
    30.             .setNameFormat("thread-自定义线程名-runner-%d").build());
    31.  
    32.     /**
    33.      * 执行python文件【异步 无需等待py文件执行完毕】
    34.      *
    35.      * @param fileName python文件地址
    36.      * @param params   参数
    37.      * @throws IOException
    38.      */
    39.     public static void execPythonFile(String fileName, String params) {
    40.         taskPool.submit(() -> {
    41.             try {
    42.                 exec(fileName, params);
    43.             } catch (IOException e) {
    44.                 logger.error("读取python文件 fileName=" + fileName + " 异常", e);
    45.             }
    46.         });
    47.  
    48.     }
    49.  
    50.     /**
    51.      * 执行python文件 【同步 会等待py执行完毕】
    52.      *
    53.      * @param fileName python文件地址
    54.      * @param params   参数
    55.      * @throws IOException
    56.      */
    57.     public static void execPythonFileSync(String fileName, String params) {
    58.         try {
    59.             execSync(fileName, params);
    60.         } catch (IOException e) {
    61.             logger.error("读取python文件 fileName=" + fileName + " 异常", e);
    62.         }
    63.     }
    64.  
    65.     private static void exec(String fileName, String params) throws IOException {
    66.         logger.info("读取python文件 init fileName={}&path={}", fileName, WINDOWS_PATH);
    67.         Process process;
    68.         if (OS.startsWith("Windows")) {
    69.             // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
    70.             process = new ProcessBuilder("cmd.exe", "/c", "python", WINDOWS_PATH + fileName, params).start();
    71.         } else {
    72.             // linux执行脚本一般是使用python3 + 文件所在路径
    73.             process = new ProcessBuilder("python3", LINUX_PATH + fileName, params).start();
    74.         }
    75.  
    76.         new Thread(() -> {
    77.             logger.info("读取python文件 开始 fileName={}", fileName);
    78.             BufferedReader errorReader = null;
    79.             // 脚本执行异常时的输出信息
    80.             errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    81.             List errorString = read(fileName, errorReader);
    82.             logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
    83.         }).start();
    84.  
    85.         new Thread(() -> {
    86.             // 脚本执行正常时的输出信息
    87.             BufferedReader inputReader = null;
    88.             inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    89.             List returnString = read(fileName, inputReader);
    90.             logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
    91.         }).start();
    92.  
    93.         try {
    94.             logger.info("读取python文件 wait fileName={}", fileName);
    95.             process.waitFor();
    96.         } catch (InterruptedException e) {
    97.             logger.error("读取python文件 fileName=" + fileName + " 等待结果返回异常", e);
    98.         }
    99.         logger.info("读取python文件 fileName={} == 结束 ==", fileName);
    100.     }
    101.  
    102.     private static void execSync(String fileName, String params) throws IOException {
    103.         logger.info("同步读取python文件 init fileName={}&path={}", fileName, WINDOWS_PATH);
    104.         Process process;
    105.         if (OS.startsWith("Windows")) {
    106.             // windows执行脚本需要使用 cmd.exe /c 才能正确执行脚本
    107.             process = new ProcessBuilder("cmd.exe", "/c", "python", WINDOWS_PATH + fileName, params).start();
    108.         } else {
    109.             // linux执行脚本一般是使用python3 + 文件所在路径
    110.             process = new ProcessBuilder("python3", LINUX_PATH + fileName, params).start();
    111.         }
    112.  
    113.         taskPool.submit(() -> {
    114.             logger.info("读取python文件 开始 fileName={}", fileName);
    115.             BufferedReader errorReader = null;
    116.             // 脚本执行异常时的输出信息
    117.             errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    118.             List errorString = read(fileName, errorReader);
    119.             logger.info("读取python文件 异常 fileName={}&errorString={}", fileName, errorString);
    120.         });
    121.  
    122.         taskPool.submit(() -> {
    123.             // 脚本执行正常时的输出信息
    124.             BufferedReader inputReader = null;
    125.             inputReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    126.             List returnString = read(fileName, inputReader);
    127.             logger.info("读取python文件 fileName={}&returnString={}", fileName, returnString);
    128.         });
    129.  
    130.         try {
    131.             logger.info("同步读取python文件 wait fileName={}", fileName);
    132.             process.waitFor();
    133.         } catch (InterruptedException e) {
    134.             logger.error("同步读取python文件 fileName=" + fileName + " 等待结果返回异常", e);
    135.         }
    136.         logger.info("同步读取python文件 fileName={} == 结束 ==", fileName);
    137.     }
    138.  
    139.     private static List read(String fileName, BufferedReader reader) {
    140.         List resultList = Lists.newArrayList();
    141.         String res = "";
    142.         while (true) {
    143.             try {
    144.                 if (!((res = reader.readLine()) != null)) break;
    145.             } catch (IOException e) {
    146.                 logger.error("读取python文件 fileName=" + fileName + " 读取结果异常", e);
    147.             }
    148.             resultList.add(res);
    149.         }
    150.         return resultList;
    151.     }
    152.  
    153. }

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

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

    Runtime.getRuntime().exec()

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

      

  • 相关阅读:
    serve error code=5011(RtcRtpMuxer)(Failed to mux RTP packet for RTC)
    PriorityQueue 源码解析（JDK1.8）
    Oauth2系列7：授权码和访问令牌的颁发流程是怎样的？
    2023秋冬系列丨追求本真的自然纯粹之美
    LeetCode 每日一题 2022/9/26-2022/10/2
    【第六章-函数】1.函数的灵活性
    [R] ggplot2 - exercise (“fill =“)
    微信小程序：页面配置/控制/跳转摘要
    常用数据库的最大并发和实际并发
    在IDEA中使用.env文件配置信息
  • 原文地址：https://blog.csdn.net/zjq852533445/article/details/126598270