Drukowanie InputStream Java z procesu

Question

UPDATE: I found a crucial part to why this probably isn't working! I used System.setOut(out); where out is a special PrintStream to a JTextArea

Jest to kod, ale problem mam jest to, że informacje są drukowane tylko raz zakończyć proces.

public Constructor() { 
    main(); 
} 

private void main() { 
    btnStart.addActionListener(new ActionListener() { 
     public void actionPerformed(ActionEvent e) { 
      try { 
       ProcessBuilder builder = new ProcessBuilder("java", textFieldMemory.getText(), "-jar", myJar); 
       Process process = builder.start(); 
       InputStream inputStream = process.getInputStream(); 
       BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream), 1); 
       String line; 
       while ((line = bufferedReader.readLine()) != null) { 
        System.out.println(line); 
       } 
       inputStream.close(); 
       bufferedReader.close(); 
      } catch (IOException ioe) { 
       ioe.printStackTrace(); 
      } 
     } 
    }); 
} 

Prąd wyjściowy:

Line 1 
Line 2 
Line 3 
Line 4 
Line 5 

Jest to poprawne wyjście, ale to jest tylko drukowane jako jeden duży blok kiedy zakończyć proces.

Czy ktoś wie, co to jest problem? Jeśli tak, możesz pomóc mi wyjaśnić, dlaczego tak się dzieje, z góry dziękuję.

Answer 1

Przetwarzanie strumienia wyjściowego procesu w oddzielnym wątku może pomóc tutaj. Chcemy także wyraźnie czekać na proces zakończyć przed kontynuowaniem swojej logiki:

ProcessBuilder builder = new ProcessBuilder("java", 
     textFieldMemory.getText(), "-jar", myJar); 
final Process process = builder.start(); 
final Thread ioThread = new Thread() { 
    @Override 
    public void run() { 
     try { 
      final BufferedReader reader = new BufferedReader(
        new InputStreamReader(process.getInputStream())); 
      String line = null; 
      while ((line = reader.readLine()) != null) { 
       System.out.println(line); 
      } 
      reader.close(); 
     } catch (final Exception e) { 
      e.printStackTrace(); 
     } 
    } 
}; 
ioThread.start(); 

process.waitFor(); 

Answer 2

Zasadniczo, z czego niewiele informacji nie ma, to brzmi jak twój uruchomieniem procesu i czytanie InputStream z poziomu zdarzenia rozdzielający wątek .

Wszystko, co blokuje EDT, uniemożliwi przetwarzanie żądań zamiany, zamiast tego należy użyć czegoś takiego, jak SwingWorker, które ma funkcjonalność umożliwiającą aktualizację interfejsu użytkownika za pomocą EDT.

Spójrz na Concurrency in Swing więcej szczegółów

import java.awt.BorderLayout; 
import java.awt.Dimension; 
import java.awt.EventQueue; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.io.File; 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.List; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.JScrollPane; 
import javax.swing.JTextArea; 
import javax.swing.SwingWorker; 
import javax.swing.UIManager; 
import javax.swing.UnsupportedLookAndFeelException; 

public class PBDemo { 

    public static void main(String[] args) throws Exception { 
     new PBDemo(); 
    } 

    public PBDemo() { 
     EventQueue.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       try { 
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
       } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) { 
       } 

       JFrame frame = new JFrame("Testing"); 
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
       frame.setLayout(new BorderLayout()); 
       frame.add(new TestPane()); 
       frame.pack(); 
       frame.setLocationRelativeTo(null); 
       frame.setVisible(true); 
      } 
     }); 
    } 

    public class TestPane extends JPanel { 

     public TestPane() { 
      setLayout(new BorderLayout()); 
      JTextArea ta = new JTextArea(); 
      add(new JScrollPane(ta)); 

      new ProcessWorker(ta).execute(); 
     } 

     @Override 
     public Dimension getPreferredSize() { 
      return new Dimension(200, 200); 
     } 
    } 

    public interface Consumer { 
     public void consume(String value);    
    } 

    public class ProcessWorker extends SwingWorker<Integer, String> implements Consumer { 

     private JTextArea textArea; 

     public ProcessWorker(JTextArea textArea) { 
      this.textArea = textArea; 
     } 

     @Override 
     protected void process(List<String> chunks) { 
      for (String value : chunks) { 
       textArea.append(value); 
      } 
     } 

     @Override 
     protected Integer doInBackground() throws Exception { 
      // Forced delay to allow the screen to update 
      Thread.sleep(5000); 
      publish("Starting...\n"); 
      int exitCode = 0; 
      ProcessBuilder pb = new ProcessBuilder("java.exe", "-jar", "HelloWorld.jar"); 
      pb.directory(new File("C:\\DevWork\\personal\\java\\projects\\wip\\StackOverflow\\HelloWorld\\dist")); 
      pb.redirectError(); 
      try { 
       Process pro = pb.start(); 
       InputConsumer ic = new InputConsumer(pro.getInputStream(), this); 
       System.out.println("...Waiting"); 
       exitCode = pro.waitFor(); 

       ic.join(); 

       System.out.println("Process exited with " + exitCode + "\n"); 

      } catch (Exception e) { 
       System.out.println("sorry" + e); 
      } 
      publish("Process exited with " + exitCode); 
      return exitCode; 
     } 

     @Override 
     public void consume(String value) { 
      publish(value); 
     } 
    } 

    public static class InputConsumer extends Thread { 

     private InputStream is; 
     private Consumer consumer; 

     public InputConsumer(InputStream is, Consumer consumer) { 
      this.is = is; 
      this.consumer = consumer; 
      start(); 
     } 

     @Override 
     public void run() { 
      try { 
       int in = -1; 
       while ((in = is.read()) != -1) { 
//     System.out.print((char) in); 
        consumer.consume(Character.toString((char)in)); 
       } 
      } catch (IOException exp) { 
       exp.printStackTrace(); 
      } 
     } 
    } 
}