1-1-10-3 请问有谁知道如何将System.out重定向输出到一个JT

文选流氓

1. 
   
2. 发信人: ttttt (如果), 信区: Java      
   
3. 标  题: Re: 请问有谁知道如何将System.out重定向输出到一个JT
   
4. 发信站: BBS 水木清华站 (Mon Oct 25 14:08:03 1999)
   
5. 
   
6. 【 在 oldcrab  (老蟹) 的大作中提到: 】
   
7. : 请问有谁知道如何将System.out重定向输出到一个JTextArea?
   
8. : 谢谢！
   
9. 
   
10. 希望这个能帮你忙，呵呵
    
11. 
    
12. CAPTURING STANDARD OUTPUT IN A LOG FILE
    
13. This tip demonstrates how you can record in a log file everything you
    
14. print to standard out and standard error. This is especially useful
    
15. if you deploy an application and your users encounter problems. You
    
16. can have the users send you the log file for analysis.
    
17. The following example code demonstrates how to capture standard
    
18. output. You can include the example code, as is, in your program.
    
19. The example implements a class called SaveOutput, with two static
    
20. methods - start() and stop().  Calling start() creates a new log
    
21. file or empties an existing log file. It copies into the log file
    
22. characters printed to standard output and standard error.  Calling
    
23. stop() closes the log file and restores the behavior of standard
    
24. output and standard error (that is, their behavior before start() was
    
25. called).
    
26. import java.io.*;
    
27. class Stdout {
    
28.     public static void main(String[] args) {
    
29.         try {
    
30.             // Start capturing characters into the log file.
    
31.             SaveOutput.start("log.txt");
    
32.             // Test it.
    
33.             System.out.println("Here's is some stuff to stdout.");
    
34.             System.err.println("Here's is some stuff to stderr.");
    
35.             System.out.println("Let's throw an exception...");
    
36.             new Exception().printStackTrace();
    
37.         } catch (Exception e) {
    
38.             e.printStackTrace();
    
39.         } finally {
    
40.             // Stop capturing characters into the log file
    
41.             // and restore old setup.
    
42.             SaveOutput.stop();
    
43.         }
    
44.     }
    
45. }
    
46. class SaveOutput extends PrintStream {
    
47.     static OutputStream logfile;
    
48.     static PrintStream oldStdout;
    
49.     static PrintStream oldStderr;
    
50.     SaveOutput(PrintStream ps) {
    
51.         super(ps);
    
52.     }
    
53.     // Starts copying stdout and stderr to the file f.
    
54.     public static void start(String f) throws IOException {
    
55.         // Save old settings.
    
56.         oldStdout = System.out;
    
57.         oldStderr = System.err;
    
58.         // Create/Open logfile.
    
59.         logfile = new PrintStream(
    
60.             new BufferedOutputStream(
    
61.             new FileOutputStream(f)));
    
62.         // Start redirecting the output.
    
63.         System.setOut(new SaveOutput(System.out));
    
64.         System.setErr(new SaveOutput(System.err));
    
65.     }
    
66.     // Restores the original settings.
    
67.     public static void stop() {
    
68.         System.setOut(oldStdout);
    
69.         System.setErr(oldStderr);
    
70.         try {
    
71.             logfile.close();
    
72.         } catch (Exception e) {
    
73.             e.printStackTrace();
    
74.         }
    
75.     }
    
76.     // PrintStream override.
    
77.     public void write(int b) {
    
78.         try {
    
79.             logfile.write(b);
    
80.         } catch (Exception e) {
    
81.             e.printStackTrace();
    
82.             setError();
    
83.         }
    
84.         super.write(b);
    
85.     }
    
86.     // PrintStream override.
    
87.     public void write(byte buf[], int off, int len) {
    
88.         try {
    
89.             logfile.write(buf, off, len);
    
90.         } catch (Exception e) {
    
91.             e.printStackTrace();
    
92.             setError();
    
93.         }
    
94.         super.write(buf, off, len);
    
95.     }
    
96. }
    
97. The start() method first saves the current standard output and
    
98. standard error print streams.  These print streams will be restored
    
99. when stop() is called. Next, the log file is opened.  If the log
    
100. file does not exist, it's created.  Otherwise, the log file is
     
101. emptied.  Finally, System.setOut() and System.setErr() are called
     
102. to replace the standard output and standard error print streams with
     
103. SaveOutput print streams.
     
104. The stop () method restores the original standard output and
     
105. standard error. It then closes the log file.
     
106. A SaveOutput object is a PrintStream object that acts like a tee.
     
107. Any characters it receives are forwarded to two places: the log file
     
108. and the underlying print streams. The underlying print streams in
     
109. the example are the original standard output and standard error
     
110. print streams; these are supplied to the SaveOutput constructor.
     
111. Although both standard output and standard error are written into the
     
112. same logfile, there is no need to synchronize this operation.  The
     
113. reason is that the logfile output stream is itself a print stream
     
114. and write operations are synchronized.
     
115. To implement this tee behavior, the program needs to override the
     
116. two forms of the write method. These overrides simply write the
     
117. characters into the logfile and then to the underlying print stream
     
118. (by calling super.write()). The write() methods do not throw
     
119. exceptions. Instead, they set a flag in the print stream if some
     
120. problem occurs. They set the flag by calling setError(). If the client
     
121. of the print stream wants to check if an error occurred, it can call
     
122. checkError().
     

复制代码