externe Programme pipen

[Tante Käthe]

Da ich nun seit einigen Stunden erfolglos versuche im Internet Lösungen, oder zumindest Ansätze zu entdecken wie ich mein Problem lösen kann, probier ich es auf diese Weise.

Problem, ich "muss" 2 externe Programme aus Java heraus starten, die anschließend miteinander kommunizieren müssen. in UNIX wäre es also ganz einfach:

prog1 ..... | prog 2 ....

Dabei interessiert mich der Exit-Code von Prog 2, oder wenn das nicht möglich ist, dessen Ausgabe.

Unter Java 7 wird eine Möglichkeit eingebaut dieses Problem einfach mit ProcessBuilder.redirect zu lösen, doch leider fehlen die dafür notwendigen Elemente in der aktuellen Version.

Ich hab schon nahezu alles probiert was PipeReader und alle anderen Reader/Writer etc. angeht. Leider wie gesagt bisher ohne Erfolg.

Zusätzlich existieren Versionen von prog1 und prog 2 sowohl für Windows als auch für Unix, daher sollte das ganze wenn möglich Plattformunabhängig sein.

Vielen Dank schonmal, wer immer sich diesem Problem annimmt

 

[faetzminator]

Du kannst von einem gestarteten Process (Java Platform SE 6) die In- und Outputstreams lesen bzw. schreiben. Zusätzlich kannst du [c]exitValue()[/c] verwenden.

 

[kay73]

Also die Standard-Ein-/Ausgabeströme verbinden ist nicht so das Thema. Vielleicht hakt es bei Dir nur bei den Threads oder den Eingabelängen, bzw bei der Eingabeterminierung.

Hier ein Demo:

[c]prog1.Prog1[/c] schreibt die Zeit in die Standardausgabe, [c]prog2.Prog2[/c] liest zeilenweise die Standardeingabe und schreibt seinen Senf in die Standardausgabe. [c]connect.connectProcess[/c] startet die beiden Programme extern, verbindet deren Standardströme und leitet den Output von [c]prog2.Prog2[/c] nach [c]System.out[/c]. Mit dem Beenden hapert's leider gehörig, aber das bekommt man bestimmt auch in den Griff.

package prog1;

public class Prog1 {

	public static void main(final String[] args) throws InterruptedException {
		final long start=System.currentTimeMillis();
		
		while(System.currentTimeMillis() - start < 10000L) {
			System.out.println("Prog1 writes: "+System.currentTimeMillis());
			Thread.sleep(1000L);
		}
	}
}

package prog2;

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

public class Prog2 {

	public static void main(String[] args) throws IOException {
		final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		while (true) {
			System.out.println(String.format("%3$s - received \"%2$s\"", 
				System.currentTimeMillis(), br.readLine(), Prog2.class.getSimpleName()));
		}
	}
}

package connect;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConnectProcess {
		
	private static void connectStream(final InputStream in, final OutputStream out) throws IOException {		
		final byte [] buffer = new byte [80];
		int n;
		while(-1 != (n = in.read(buffer))) {
			out.write(buffer,0 ,n);
			out.flush();
		}
	}

	public static void main(String[] args) throws IOException {
		
		final PipedOutputStream pipedOut = new PipedOutputStream();
		final PipedInputStream pipedIn = new PipedInputStream(pipedOut);
		
		final ExecutorService exs = Executors.newCachedThreadPool();
		
		final String CLASSPATH="./bin";
		
		exs.submit(new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				final Process p1 = Runtime.getRuntime().exec("java -cp "+CLASSPATH+" prog1.Prog1");
				connectStream(p1.getInputStream(), pipedOut);
				return p1.waitFor();
			}			
		});
		
		exs.submit(new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				final Process p2 = Runtime.getRuntime().exec("java -cp "+CLASSPATH+" prog2.Prog2");
				
				exs.submit(new Callable<Integer>() {

					@Override
					public Integer call() throws Exception {
						connectStream(pipedIn, p2.getOutputStream());
						return 0;
					}					
				});
				
				connectStream(p2.getInputStream(), System.out);
				return p2.waitFor();
			}			
		});
	}
}