किसी अन्य जावा प्रोग्राम से एक जावा प्रोग्राम चला रहा है

Question

मैं एक साधारण जावा प्रोग्राम पर काम कर रहा हूं। यह बस एक और जावा कार्यक्रम संकलित और निष्पादित करता है। मैं संकलन और चलाने के लिए Runtime.exec() फ़ंक्शन का उपयोग कर रहा हूं। संकलन के साथ कोई समस्या नहीं है। लेकिन जब यह चलता है, यदि दूसरे प्रोग्राम को कीबोर्ड से पढ़ने के लिए इनपुट की आवश्यकता होती है, तो मैं इसे मास्टर प्रक्रिया से नहीं दे सकता। मैंने GetOutputStream() फ़ंक्शन का उपयोग किया। लेकिन यह मदद नहीं कर सका। मैं अपना कोड प्रदान करूंगा।

public class sam { 
    public static void main(String[] args) throws Exception { 
     try { 
      Process p = Runtime.getRuntime().exec("javac sam2.java"); 
      Process p2 = Runtime.getRuntime().exec("java sam2"); 
      BufferedReader in = new BufferedReader( 
           new InputStreamReader(p2.getInputStream())); 

      OutputStream out = p.getOutputStream(); 
      String line = null; 
      line = in.readLine(); 
      System.out.println(line); 
      input=input+"\n"; 
      out.write(input.getBytes()); 
      p.wait(10000); 
      out.flush(); 
     }catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

यह मेरा मास्टर प्रोग्राम (sam.java) है।

निम्नलिखित कोई समस्या नहीं है, अगर मेरी दूसरी कार्यक्रम केवल मुद्रण बयान है sam2.java

public class sam2 { 
public static void main(String[] args) throws Exception { 

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
    String str; 
    System.out.println("Enter the number..\n"); 
    str = br.readLine(); 
    System.out.println(Integer.parseInt(str)); 

    } 
} 

का कोड है। लेकिन समस्या तब उत्पन्न होती है जब मुझे दूसरे से कुछ पढ़ना पड़ता है।

Answer 1

यह थोड़ा अजीब है लेकिन आप इसे बिना किसी प्रयास के दूसरे प्रोग्राम को चला सकते हैं। बस इसमें मुख्य विधि बुलाओ। तो क्रम अनुभाग भूल जाते हैं और ऐसा करते हैं:

sam2.main(new String[0]); 

बेशक

इस तरह से आप संकलन समय

Answer 2

में sam2 संकलन चाहिए तुम सिर्फ द्वितीय श्रेणी के मुख्य विधि कॉल कर सकते हैं। मुख्य विधि किसी भी अन्य स्थिर विधि की तरह है।

Answer 3

प्रत्येक प्रक्रिया को चलाने और समाप्त करने की अनुमति दी जानी चाहिए। इस उद्देश्य के लिए आप Process#waitFor का उपयोग कर सकते हैं। समान रूप से, आपको एक ही समय में प्रक्रिया से किसी भी आउटपुट का उपभोग करने की आवश्यकता है। waitFor को अवरुद्ध कर देगा ताकि आप एक Thread का उपयोग इनपुट को पढ़ने के लिए (और यदि आप, इस प्रक्रिया को करने के लिए उत्पादन लिखने की ज़रूरत)

जावा/वर्ग फ़ाइल के स्थान पर निर्भर करता है, तो आप भी एक प्रारंभिक निर्दिष्ट करने के लिए आवश्यकता हो सकती है की आवश्यकता होगी फ़ोल्डर जिसमें से प्रक्रिया का निष्पादन शुरू हो सकता है।

इसमें से अधिकांश काफी अब स्पष्ट रूप से ProcessBuilder

import java.io.File; 
import java.io.IOException; 
import java.io.InputStream; 

public class CompileAndRun { 

    public static void main(String[] args) { 
     new CompileAndRun(); 
    } 

    public CompileAndRun() { 
     try { 
      int result = compile("compileandrun/HelloWorld.java"); 
      System.out.println("javac returned " + result); 
      result = run("compileandrun.HelloWorld"); 
     } catch (IOException | InterruptedException ex) { 
      ex.printStackTrace(); 
     } 
    } 

    public int run(String clazz) throws IOException, InterruptedException {   
     ProcessBuilder pb = new ProcessBuilder("java", clazz); 
     pb.redirectError(); 
     pb.directory(new File("src")); 
     Process p = pb.start(); 
     InputStreamConsumer consumer = new InputStreamConsumer(p.getInputStream()); 
     consumer.start(); 

     int result = p.waitFor(); 

     consumer.join(); 

     System.out.println(consumer.getOutput()); 

     return result; 
    } 

    public int compile(String file) throws IOException, InterruptedException {   
     ProcessBuilder pb = new ProcessBuilder("javac", file); 
     pb.redirectError(); 
     pb.directory(new File("src")); 
     Process p = pb.start(); 
     InputStreamConsumer consumer = new InputStreamConsumer(p.getInputStream()); 
     consumer.start(); 

     int result = p.waitFor(); 

     consumer.join(); 

     System.out.println(consumer.getOutput()); 

     return result;   
    } 

    public class InputStreamConsumer extends Thread { 

     private InputStream is; 
     private IOException exp; 
     private StringBuilder output; 

     public InputStreamConsumer(InputStream is) { 
      this.is = is; 
     } 

     @Override 
     public void run() { 
      int in = -1; 
      output = new StringBuilder(64); 
      try { 
       while ((in = is.read()) != -1) { 
        output.append((char) in); 
       } 
      } catch (IOException ex) { 
       ex.printStackTrace(); 
       exp = ex; 
      } 
     } 

     public StringBuilder getOutput() { 
      return output; 
     } 

     public IOException getException() { 
      return exp; 
     } 
    } 
} 

का उपयोग कर आसान, आप प्रक्रियाओं की वापसी के परिणाम की जाँच करनी चाहिए, और प्रक्रियाओं के साथ बातचीत के लिए एक बेहतर तंत्र का उत्पादन हो सकता है, लेकिन यह है कि मूल विचार है। ..