1.使用Runtime.getRuntime()执行脚本文件

该方法可以运行含有python第三方库的程序

先建立python脚本文件 demo.py

import numpy as np

a = np.arange(12).reshape(3,4)
print(a)

java调用python程序并输出该结果

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Demo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Process proc;
        try {
            proc = Runtime.getRuntime().exec("python D:\\demo.py");// 执行py文件
            //用输入输出流来截取结果
            BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
            in.close();
            proc.waitFor();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } 
    }
}

如若向python程序中函数传递参数并执行出结果,下面就举一例来说明一下。
同样建立python脚本文件demo2.py

import sys

def func(a,b):
    return (a+b)

if __name__ == '__main__':
    a = []
    for i in range(1, len(sys.argv)):
        a.append((int(sys.argv[i])))

    print(func(a[0],a[1]))

其中sys.argv用于获取参数url1,url2等。而sys.argv[0]代表python程序名,所以列表从1开始读取参数。
以上代码实现一个两个数做加法的程序,下面看看在java中怎么传递函数参数,代码如下:

int a = 18;
int b = 23;
try {
    String[] args = new String[] { "python", "D:\\demo2.py", String.valueOf(a), String.valueOf(b) };
    Process proc = Runtime.getRuntime().exec(args);// 执行py文件

    BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
    String line = null;
    while ((line = in.readLine()) != null) {
        System.out.println(line);
    }
    in.close();
    proc.waitFor();
} catch (IOException e) {
    e.printStackTrace();
} catch (InterruptedException e) {
    e.printStackTrace();
}

其中args是String[] { “python”,path,url1,url2 }; ,path是python程序所在的路径,url1是参数1,url2是参数2,以此类推。

2. 将python脚本写成进程为java提供服务

在java应用程序中调用python进程提供的服务。这种方法我认为是最好的!强推!!!python语言写得程序毕竟还是在python环境中执行最有效率。而且python应用和java应用可以运行在不同的服务器上,通过进程的远程访问调用。更赞的是python运行环境还可以是虚拟环境,运行tensorflow模型神马的完全没问题!

python脚本文件如下:

import socket
import sys
import threading
import numpy as np
from PIL import Image

def main():
    # 创建服务器套接字
    serversocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    # 获取本地主机名称
    host = socket.gethostname()
    # 设置一个端口
    port = 12345
    # 将套接字与本地主机和端口绑定
    serversocket.bind((host,port))
    # 设置监听最大连接数
    serversocket.listen(5)
    # 获取本地服务器的连接信息
    myaddr = serversocket.getsockname()
    print("服务器地址:%s"%str(myaddr))
    # 循环等待接受客户端信息
    while True:
        # 获取一个客户端连接
        clientsocket,addr = serversocket.accept()
        print("连接地址:%s" % str(addr))
        try:
            t = ServerThreading(clientsocket)#为每一个请求开启一个处理线程
            t.start()
            pass
        except Exception as identifier:
            print(identifier)
            pass
        pass
    serversocket.close()
    pass



class ServerThreading(threading.Thread):
    # words = text2vec.load_lexicon()
    def __init__(self,clientsocket,recvsize=1024*1024,encoding="utf-8"):
        threading.Thread.__init__(self)
        self._socket = clientsocket
        self._recvsize = recvsize
        self._encoding = encoding
        pass

    def run(self):
        print("开启线程.....")
        try:
            #接受数据
            msg = ''
            while True:
                # 读取recvsize个字节
                rec = self._socket.recv(self._recvsize)
                # 解码
                msg += rec.decode(self._encoding)
                # 文本接受是否完毕,因为python socket不能自己判断接收数据是否完毕,
                # 所以需要自定义协议标志数据接受完毕
                if msg.strip().endswith('over'):
                    msg=msg[:-4]
                    break
           
            sendmsg = Image.open(msg)
            # 发送数据
            self._socket.send(("%s"%sendmsg).encode(self._encoding))
            pass
        except Exception as identifier:
            self._socket.send("500".encode(self._encoding))
            print(identifier)
            pass
        finally:
            self._socket.close() 
        print("任务结束.....")
        
        pass

    def __del__(self):
        pass

if __name__ == "__main__":
    main()

在java代码中访问python进程的代码:

package hello;
import java.lang.System;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.InputStream;

public class hello {
    public static void main(String[] args){
        //System.out.println("Hello World!");
        // TODO Auto-generated method stub

        try {
            InetAddress addr = InetAddress.getLocalHost();
            String host=addr.getHostName();
            //String ip=addr.getHostAddress().toString(); //获取本机ip
            //log.info("调用远程接口:host=>"+ip+",port=>"+12345);

            // 初始化套接字,设置访问服务的主机和进程端口号,HOST是访问python进程的主机名称,可以是IP地址或者域名,PORT是python进程绑定的端口号
            Socket socket = new Socket(host,12345);

            // 获取输出流对象
            OutputStream os = socket.getOutputStream();
            PrintStream out = new PrintStream(os);
            // 发送内容
            out.print( "F:\\xxx\\0000.jpg");
            // 告诉服务进程,内容发送完毕,可以开始处理
            out.print("over");

            // 获取服务进程的输入流
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is,"utf-8"));
            String tmp = null;
            StringBuilder sb = new StringBuilder();
            // 读取内容
            while((tmp=br.readLine())!=null)
                sb.append(tmp).append('\n');
            System.out.print(sb);
            // 解析结果
            //JSONArray res = JSON.parseArray(sb.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {if(socket!=null) socket.close();} catch (IOException e) {}
            System.out.print("远程接口调用结束.");
        }
      }
}


如何使用Java调用Python程序
本文为大家介绍如何java调用python方法,供大家参考。
实际工程项目中可能会用到Java和python两种语言结合进行,这样就会涉及到一个问题,就是怎么用Java程序来调用已经写好的python脚本呢,一共有三种方法可以实现,具体方法分别为大家介绍:
1. 在java类中直接执行python语句

此方法需要引用 org.python包,需要下载Jpython。在这里先介绍一下Jpython。下面引入百科的解释:

  • Jython是一种完整的语言,而不是一个Java翻译器或仅仅是一个Python编译器,它是一个Python语言在Java中的完全实现。Jython也有很多从CPython中继承的模块库。最有趣的事情是Jython不像CPython或其他任何高级语言,它提供了对其实现语言的一切存取。所以Jython不仅给你提供了Python的库,同时也提供了所有的Java类。这使其有一个巨大的资源库。
 
这里我建议下载最新版本的Jpython,因为可以使用的python函数库会比老版本的多些,目前最新版本为2.7。
下载jar包请点击Download Jython 2.7.0 – Standalone Jar
下载安装程序请点击Download Jython 2.7.0 – Installer
如果使用maven依赖添加的话,使用下面的语句
  1.  
    <dependency>
  2.  
    <groupId>org.python</groupId>
  3.  
    <artifactId>jython-standalone</artifactId>
  4.  
    <version>2.7.0</version>
  5.  
    </dependency>
以上准备好了,就可以直接在java类中写python语句了,具体代码如下:
  1.  
    PythonInterpreter interpreter = new PythonInterpreter();
  2.  
    interpreter.exec(“a=[5,2,3,9,4,0]; “);
  3.  
    interpreter.exec(“print(sorted(a));”); //此处python语句是3.x版本的语法
  4.  
    interpreter.exec(“print sorted(a);”); //此处是python语句是2.x版本的语法

 

输出结果如下:
这里会看到输出的结果都是一样的,也就是说Jpython兼容python2.x和3.x版本的语句,运行速度会比直接运行python程序稍慢一点。
但是每次运行结果都会提示console: Failed to install ”: java.nio.charset.UnsupportedCharsetException: cp0. 这样看起来很烦,因为每次运行结果都会出现红色的提示语句,以为是错误,程序员应该都不愿意看到这一幕,得想个办法解决。
解决方法如下:
在要执行的代码上右键, Run As>Run Configurations,选择第二个页签Arguments,在VM arguments中添加以下语句
-Dpython.console.encoding=UTF-8
然后Apply->Run就可以了。
如下图所示:

 

 

 

 

2. 在java中调用本地python脚本
首先在本地建立一个python脚本,命名为add.py,写了一个简单的两个数做加法的函数,代码如下:
  1.  
    def add(a,b):
  2.  
    return a + b

 python的功能函数已经写好,接下来我们写一个java的测试类(同样需要用到Jpython包),来测试一下是否可以运行成功。代码如下:

  1.  
    import org.python.core.PyFunction;
  2.  
    import org.python.core.PyInteger;
  3.  
    import org.python.core.PyObject;
  4.  
    import org.python.util.PythonInterpreter;
  5.  
     
  6.  
    public class Java_Python_test {
  7.  
     
  8.  
    public static void main(String[] args) {
  9.  
    // TODO Auto-generated method stub
  10.  
    PythonInterpreter interpreter = new PythonInterpreter();
  11.  
    interpreter.execfile(“D:\\add.py”);
  12.  
     
  13.  
    // 第一个参数为期望获得的函数(变量)的名字,第二个参数为期望返回的对象类型
  14.  
    PyFunction pyFunction = interpreter.get(“add”, PyFunction.class);
  15.  
    int a = 5, b = 10;
  16.  
    //调用函数,如果函数需要参数,在Java中必须先将参数转化为对应的“Python类型”
  17.  
    PyObject pyobj = pyFunction.__call__(new PyInteger(a), new PyInteger(b));
  18.  
    System.out.println(“the anwser is: ” + pyobj);
  19.  
    }
  20.  
    }

 

运行结果如图所示:

OK,测试成功了~

关于Jpython更多详细的信息可以参考官方的相关文档,官网地址点这里

 

 

注意:以上两个方法虽然都可以调用python程序,但是使用Jpython调用的python库不是很多,如果你用以上两个方法调用,而python的程序中使用到第三方库,这时就会报错java ImportError: No module named xxx。遇到这种情况推荐使用下面的方法,即可解决该问题。

3. 使用Runtime.getRuntime()执行脚本文件(推荐)

 

 

为了验证该方法可以运行含有python第三方库的程序,我们先写一个简单的python脚本,代码如下:
  1.  
    import numpy as np
  2.  
     
  3.  
    a = np.arange(12).reshape(3,4)
  4.  
    print(a)

 

 

可以看到程序中用到了numpy第三方库,并初始化了一个3×4的一个矩阵。
下面来看看怎么用Runtime.getRuntime()方法来调用python程序并输出该结果,java代码如下:
  1.  
    import java.io.BufferedReader;
  2.  
    import java.io.IOException;
  3.  
    import java.io.InputStreamReader;
  4.  
     
  5.  
    public class Demo1 {
  6.  
     
  7.  
    public static void main(String[] args) {
  8.  
    // TODO Auto-generated method stub
  9.  
    Process proc;
  10.  
    try {
  11.  
    proc = Runtime.getRuntime().exec(“python D:\\demo1.py”);// 执行py文件
  12.  
    //用输入输出流来截取结果
  13.  
    BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
  14.  
    String line = null;
  15.  
    while ((line = in.readLine()) != null) {
  16.  
    System.out.println(line);
  17.  
    }
  18.  
    in.close();
  19.  
    proc.waitFor();
  20.  
    } catch (IOException e) {
  21.  
    e.printStackTrace();
  22.  
    } catch (InterruptedException e) {
  23.  
    e.printStackTrace();
  24.  
    }
  25.  
    }
  26.  
    }

 

 

输出的结果如下图所示:

 

 

可以看到运行成功了,但有的朋友可能会问了,怎么在python程序中函数传递参数并执行出结果,下面我就举一例来说明一下。
先写一个python的程序,代码如下:
  1.  
    import sys
  2.  
     
  3.  
    def func(a,b):
  4.  
    return (a+b)
  5.  
     
  6.  
    if __name__ == ‘__main__’:
  7.  
    a = []
  8.  
    for i in range(1, len(sys.argv)):
  9.  
    a.append((int(sys.argv[i])))
  10.  
     
  11.  
    print(func(a[0],a[1]))

 

 

其中sys.argv用于获取参数url1,url2等。而sys.argv[0]代表python程序名,所以列表从1开始读取参数。
以上代码实现一个两个数做加法的程序,下面看看在java中怎么传递函数参数,代码如下:
  1.  
    int a = 18;
  2.  
    int b = 23;
  3.  
    try {
  4.  
    String[] args = new String[] { “python”, “D:\\demo2.py”, String.valueOf(a), String.valueOf(b) };
  5.  
    Process proc = Runtime.getRuntime().exec(args1);// 执行py文件
  6.  
     
  7.  
    BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
  8.  
    String line = null;
  9.  
    while ((line = in.readLine()) != null) {
  10.  
    System.out.println(line);
  11.  
    }
  12.  
    in.close();
  13.  
    proc.waitFor();
  14.  
    } catch (IOException e) {
  15.  
    e.printStackTrace();
  16.  
    } catch (InterruptedException e) {
  17.  
    e.printStackTrace();
  18.  
    }

 

 

其中args是String[] { “python”,path,url1,url2 }; ,path是python程序所在的路径,url1是参数1,url2是参数2,以此类推。
最后结果如图所示:

 

 


OK,成功了。

 

 

 
最后补充一点:

本人电脑上由于同时存在两个python,而我不想用默认的那个,也不想修改默认的python解释器,这种情况下,可以写一个bat文件,在bat文件中通过dos命令切换到该python所在目录,然后运行py文件(py文件要放在该目录下)

下面附上程序:

bat文件:

  1.  
    @echo off
  2.  
    C:
  3.  
    cd C:\Anaconda2\envs\py3
  4.  
    start python test.py
  5.  
    exit

java程序:

  1.  
    import java.io.BufferedReader;
  2.  
    import java.io.IOException;
  3.  
    import java.io.InputStreamReader;
  4.  
     
  5.  
    public class Demo1 {
  6.  
     
  7.  
    public static void main(String[] args) {
  8.  
    // TODO Auto-generated method stub
  9.  
    Process proc;
  10.  
    try {
  11.  
    proc = Runtime.getRuntime().exec(“cmd /c E:\\Faultdetection\\fault1\\run.bat”);// 执行py文件
  12.  
    //用输入输出流来截取结果
  13.  
    BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
  14.  
    String line = null;
  15.  
    while ((line = in.readLine()) != null) {
  16.  
    System.out.println(line);
  17.  
    }
  18.  
    in.close();
  19.  
    proc.waitFor();
  20.  
    } catch (IOException e) {
  21.  
    e.printStackTrace();
  22.  
    } catch (InterruptedException e) {
  23.  
    e.printStackTrace();
  24.  
    }
  25.  
    }
  26.  
    }

 

版权声明:本文为hanease原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/hanease/p/16041925.html