java调用脚本语言或其他进程(以Python为例)

很多时候,我们往往需要在java中调用其他脚本语言,或者是其他进程,来弥补java的一些不便之处.
万能的方式就是使用Process类了,当然针对Python还可以使用jython,但jython还是有诸多不便

String command = "python test.py";
Process pythonProcess = Runtime.getRuntime().exec(command);

Process的强大功能,就在于调用其他进程时,可以相互实现信息传递,基于java IO实现,调用者只需要熟悉java IO操作,即可调用.
我写了一个辅助类,以便于对进程之间的信息传递,实现策略为,将InputStream操作改为线程操作.具体代码如下:

package runtime;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
 * 将InputStream操作改为线程操作
 */
public class StreamThreadRead extends Thread{
    //存储读取的字符串
    private final StringBuffer sBuffer;
    //对应的输入流
    private final InputStream iStream;
    public StreamThreadRead(InputStream iStream){
        super();
        sBuffer = new StringBuffer();
        this.iStream = iStream;
    }
    @Override
    public void run() {
        BufferedReader bReader = new BufferedReader(new InputStreamReader(iStream));
        String str;
        try {
            while ((str = bReader.readLine()) != null) {
                sBuffer.append(str).append("\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public StringBuffer getsBuffer() {
        return sBuffer;
    }
    public InputStream getiStream() {
        return iStream;
    }   
}

这个便是辅助类啦,类如其名”进程IO传输”,不过准确来讲,已经实现进程简单管理了.
可以随心所欲的在java和脚本之间传递数据,贼爽啊!

package runtime;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 进程数据传输对象
 */
public class ProcessIOTransport {
    private final BufferedWriter stout;
    private final StreamThreadRead stin;
    private final StreamThreadRead errin;
    private final Process process;

    /**
     * 构造一个ProcessIOTransport
     * @param process
     * @throws IOException 
     */
    public ProcessIOTransport(String command) throws IOException{
        process = Runtime.getRuntime().exec(command);
        stout = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
        stin = new StreamThreadRead(process.getInputStream());
        errin = new StreamThreadRead(process.getErrorStream());
        //设为后台线程
        stin.setDaemon(true);
        errin.setDaemon(true);
        //启动线程
        stin.start();
        errin.start();
        //监控进程
        new Thread(new Runnable(){
            @Override
            public void run() {
                while(stin.isAlive()||errin.isAlive()){
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                process.destroy();
            }
        });
    }
    /**
     * 构造一个ProcessIOTransport,其中向进程中输入参数args
     * @param process
     * @param args
     * @throws IOException
     */
    public ProcessIOTransport(String command,String...args) throws IOException{
        this(command);
        write(args);
    }
    /**
     * 构造一个ProcessIOTransport,当前java线程等待进程运行结束
     * @param process
     * @param timeOut 最迟等待时间(ms)
     * @throws IOException
     */
    public ProcessIOTransport(String command,long timeOut) throws IOException{
        this(command,timeOut,new String[]{null});
    }
    /**
     * 构造一个ProcessIOTransport,当前java线程等待进程运行结束
     * @param process
     * @param timeOut 最迟等待时间(ms)
     * @param args 向进程中传入的参数
     * @throws IOException
     */
    public ProcessIOTransport(String command,long timeOut,String...args) throws IOException{
        this(command,args);
        long start = System.currentTimeMillis();
        long now = System.currentTimeMillis();
        while(now-start<timeOut&&(stin.isAlive()||errin.isAlive())){
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            now = System.currentTimeMillis();
        }
    }

    /**
     * 向process写数据
     * @param args
     * @throws IOException
     */
    public void write(String...args) throws IOException {
        for(int i = 0;i<args.length;i++){
            if(args[i]!=null){
                stout.write(args[i]);
                stout.flush();
            }
        }
    }
    /**
     * 读取process的标准输出
     * @return
     */
    public String readStandard(){
        if(stin.isAlive()){
            return null;
        }else{
            return stin.getsBuffer().toString();
        }
    }
    /**
     * 读取process的错误输出
     * @return
     */
    public String readError(){
        if(stin.isAlive()){
            return null;
        }else{
            return stin.getsBuffer().toString();
        }
    }
}

最后我们测试一下吧:

package runtime;

import java.io.IOException;

public class Test {

    public static void main(String[] args) {
        String command = "python test.py";
        try {           
            ProcessIOTransport piot1 = new ProcessIOTransport(command,200,"write1\n","write2\n");
            ProcessIOTransport piot2 = new ProcessIOTransport(command,200,"write3\n");
            System.out.println(piot1.readStandard());
            System.out.println("---------------------");
            System.out.println(piot2.readStandard());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

测试的Python代码如下

#unicode=UTF-8  
print ('hello')
v = input()
print (v)
print ('xx')
print (3+6)
z = input()
print (z)
print (3+3+3+3+3+3+3+3+3+3/6+3+3+3+3)

测试结果:

hello
write1
xx
9
write2
39.5

---------------------
null

当然,由于进程或者脚本等待着输入,而java迟迟不给输出,那么java的子线程stin,sterr也不会结束,我们将得不到脚本或进程的输出,而是得到null.此处,我没有设置抛出异常,而是把stin,sterr设置为了后台线程,当主线程结束,stin,sterr也随之终止,process也随之destroy掉,避免进程或脚本一直等待输入而持续运行.