將Java程序中的數據（字符串列表）傳遞給Python腳本的首選方式是什麼？ python腳本對數據執行一些處理，然後我需要將結果返回到我的Java程序中。將數據從Java程序傳遞到Python程序並獲得結果
是否有一個框架可以讓你輕鬆地做到這一點？
編輯：更具體的要求。
我的Java程序是一個調度程序（運行每X分鐘和Y秒），連接到外部服務並獲取RAW數據並將其發送給python。
我可以在Python中重寫所有內容，但這會花費我很多時間。我正在查看是否有重用我已有的東西的方法。
我想用最小的改變來使用現有的Python腳本。我的python腳本使用了一堆外部庫（例如numpy） 從Java傳遞到Python的數據是Json格式，Python返回的數據也是Json。
使用套接字是一個選項，但然後我必須運行服務器進程。
幾個月前，當我遇到類似問題時，我一起入侵了它。我避免了Jython，因爲我想要單獨的進程。 Java代碼是偵聽請求的服務器，但在失敗時不會重新連接。其概念是，類是具有套接字成員的擴展線程，因此發送和接收命令可以阻止對象線程並使主機線程不受影響。
Python代碼：
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;
}
}
}
CommandObject.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之間的通信。
是有幫助？ http://stackoverflow.com/questions/4068052/passing-data-between-java-and-python?rq=1 –
這實際上取決於你想要溝通多少和結果的類型。你能指定那個嗎？也許stdin/out與子進程和可選的json就足夠了。在我經歷的大多數情況下，框架並不是必需的。 – User
考慮使用Jython，因爲人們一直在說。否則套接字將工作得很好。 –