将数据（字符串列表）从 Java 程序传递到 Python 脚本的首选方式是什么。python 脚本对数据执行一些处理，然后我需要将结果返回到我的 Java 程序中。
是否有一个框架可以让您轻松做到这一点？
编辑：更具体的要求。
我的 Java 程序是一个调度程序（每 X 分钟和 Y 秒运行一次），它连接到外部服务并获取 RAW 数据并将其发送到 python。
我可以用 Python 重写所有东西，但这会花费我很多时间。我一直在寻找是否有办法重用我已有的东西。
我想使用现有的 Python 脚本并进行最少的更改。我的python脚本使用了一堆外部库（例如numpy）从Java传给Python的数据是Json格式，Python返回的数据也是Json。
使用套接字是一个选项，但我必须运行服务器进程。
几个月前，当我遇到类似问题时，我一起破解了这个问题。我避免使用 Jython，因为我想要单独的进程。Java 代码是服务器，因为它侦听请求，但在失败时不会重新连接。这个概念是类是具有套接字成员的扩展线程，因此发送和接收命令可以阻塞对象线程并使主机线程不受影响。
蟒蛇代码：
import StringIO
import re
import select
import socket
import sys
import threading
class IPC(threading.Thread):
def __init__(self, line_filter = None):
threading.Thread.__init__(self)
self.daemon = True
self.lock = threading.Lock()
self.event = threading.Event()
self.event.clear()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.recv_buffer_size = 8192
self.buffer = StringIO.StringIO()
if(line_filter == None):
self.line_filter = lambda x: x
else:
self.line_filter = line_filter
def run(self):
self.sock.connect(("localhost", 32000))
data = True
while data:
try:
data = self.sock.recv(self.recv_buffer_size)
except socket.error, e:
print e
self.sock.close()
break
self.lock.acquire()
self.buffer.write(data)
self.lock.release()
self.event.set()
def readlines(self):
self.lock.acquire()
self.buffer.seek(0)
raw_lines = self.buffer.readlines()
self.buffer.truncate(0)
self.lock.release()
lines = map(self.line_filter, raw_lines)
return lines
proc_control = IPC()
while True:
proc_control.event.wait()
data = proc_control.readlines()
if(data):
# Do Stuff
proc_control.event.clear()
Java 代码：
SocketIPC.java：
package project;
import java.net.Socket;
import java.net.ServerSocket;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.io.OutputStreamWriter;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class SocketIPC {
public PrintWriter out;
public BufferedReader in;
Socket socket = null;
ServerSocket serverSocket = null;
ConnectionListener connlisten = null;
DataListener datalisten = null;
Thread connlisten_thread = null;
Thread datalisten_thread = null;
CommandObject ipc_event_cmd = null;
// Server thread accepts incoming client connections
class ConnectionListener extends Thread {
private int port;
ConnectionListener(int port) {
this.port = port;
}
@Override
public void run() {
try {
serverSocket = new ServerSocket(port);
socket = serverSocket.accept();
out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
datalisten = new DataListener();
datalisten_thread = new Thread(datalisten);
datalisten_thread.start();
} catch (Exception e) {
System.err.println("SocketIPC creation error: " + e.getMessage());
}
}
}
// Server thread accepts incoming client connections
class DataListener extends Thread {
String data_str = null;
DataListener() {
}
@Override
public void run() {
try {
while(true) {
data_str = recv();
ipc_event_cmd.buffer.add(data_str);
ipc_event_cmd.execute();
}
} catch (Exception e) {
System.err.println("SocketIPC reading error: " + e.getMessage());
}
}
public String read() {
String ret_string = null;
if(!ipc_event_cmd.buffer.isEmpty()) {
ret_string = ipc_event_cmd.buffer.remove(0);
}
return ret_string;
}
}
public SocketIPC(int port) {
ipc_event_cmd = new CommandObject();
connlisten = new ConnectionListener(port);
connlisten_thread = new Thread(connlisten);
connlisten_thread.start();
}
public void send(String msg) {
if (out != null) {
out.println(msg);
}
}
public void flush() {
if (out != null) {
out.flush();
}
}
public void close() {
if (out != null) {
out.flush();
out.close();
try {
in.close();
socket.close();
serverSocket.close();
} catch (Exception e) {
System.err.println("SocketIPC closing error: " + e.getMessage());
}
}
}
public String recv() throws Exception {
if (in != null) {
return in.readLine();
} else {
return "";
}
}
public void set_cmd(CommandObject event_cmd) {
if (event_cmd != null) {
this.ipc_event_cmd = event_cmd;
}
}
}
命令对象.java：
package project;
import java.util.List;
import java.util.ArrayList;
public class CommandObject {
List<String> buffer;
public CommandObject() {
this.buffer = new ArrayList<String>();
}
public void execute() {
}
}
DoStuff.java：
package project;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Random;
public class DoStuff extends CommandObject {
public DoStuff () {
}
@Override
public void execute() {
String tmp_string = null;
while (!buffer.isEmpty()) {
tmp_string = buffer.remove(0);
// Do Stuff
}
}
}
听起来像是Jython的工作！Jython 是一个用 Java 编写的可嵌入 Python 运行时。只要您不需要在另一个进程中运行您的 Python 脚本（例如，希望能够杀死它，可能会使用大量内存等），这是迄今为止最好的方法。
如果您尝试将 Java 和 python 一起使用，那么使用Jython让您的生活变得简单。
Jython 是 JPython 的继承者，是用 Java 编写的 Python 编程语言的实现。Jython 程序可以导入和使用任何 Java 类。除了一些标准模块，Jython 程序使用 Java 类而不是 Python 模块。Jython 包含标准 Python 编程语言发行版中的几乎所有模块，仅缺少最初用 C 实现的一些模块。
假设您的 python 路径中有 java lib。这是一个代码片段，让您了解使用 java 类是多么简单：
'''
Import JavaUtilities class from a java package
'''
from com.test.javalib import JavaUtilities
'''
Call a java method
'''
response = JavaUtilities.doSomething();
请看一下Jython，它最适合 java 和 Python 之间的通信。