Java&Eclipse：我可以同时打印到不同的输出控制台吗？

Question

我正在使用Windows上的Eclipse IDE（氧气）学习Java(SE8)。我以前做过一些“业余”编程，但这是我第一次正式上这门课。我希望能够在普通控制台（System.out.println）中打印分配所需的输出，并同时在不同的控制台中打印正在发生的信息文本。

printToConsole1（“普通程序输出”）；printToConsole2（“幕后信息”）；

我可以在Java中做类似的事情吗？

Answer 1

您可以打印到标准err(system.err.println())，我的IDE（不是Eclipse）将以不同的方式格式化这些行--它们以红色显示，使它们更容易定位。

关于Swing控制台，不，我想的是不同的东西。也就是说，只使用Makoto建议的日志框架，然后只使用将日志行显示到窗口的日志处理程序。下面是我创建的一个简短示例。

/**
 * A log handler which creates a visible window for logging output.
 * 
 * <p>A WindowHandler is a standard log handler which may be utilized
 * in just the same was as any other log handler.</p>
 *
 * <p>In addition, a convenience static method is provided, WindowHandler.show(),
 * which will programmatically install a root handler and display a window,
 * allowing debugging output to be easily captured and viewed on screen.</p>
 * 
 * @author Brenden
 */
public class WindowHandler extends java.util.logging.Handler {

   // These static globals must be accessed on the EDT only!
   private static WindowHandler globalHandler;
   private static final ArrayList<WeakReference<WindowHandler>> windowList =
           new ArrayList<>();

   private JTextArea text;
   private JFrame logWindow;

   /**
    * Returns the window component (usually a JFrame) associated with this
    * WindowHandler.
    * 
    * @return The top-level window for this handler.
    */
   public Component getWindow() {
      return logWindow;
   }

   /**
    * Returns the JTextArea associated with the logging output captured by
    * this handler.
    * 
    * @return A JTextArea where logging is displayed. 
    */
   public JTextArea getTextArea() {
      return text;
   }

   /**
    * A list of ALL WindowHandler created so far in the system.
    * 
    * <p>This list is useful for getting a list of windows on screen, for
    * example, and then performing some operation on these windows.  For
    * example, hiding all windows, or closing them, or tiling them on screen
    * for easier viewing.</p>
    * 
    * @return An array list of all current window handlers. 
    */
   public static ArrayList<WindowHandler> getHandlers() {
      ArrayList<WindowHandler> retVal = new ArrayList<>();
      for( WeakReference<WindowHandler> wr : windowList ) {
         WindowHandler h = wr.get();
         if( h != null ) retVal.add( h );
      }
      return retVal;
   }

   /**
    * A convenience method for starting an instance of a WindowHandler.
    * 
    * <p>Call this method at the beginning of your program.  After calling
    * this method, all debugging output will be captured by the 
    * WindowHandler.  Note that individual loggers still have their respective
    * log levels.  WindowHandler is set to Level.ALL by default, but won't
    * receive output from loggers that have their own levels set too high
    * to capture output.</p>
    */
   public static synchronized void show() {
      utilEDTWait( () -> {
         if( globalHandler == null ) {
            Logger root = Logger.getLogger( "" );
            root.addHandler( globalHandler = new WindowHandler() );
         } else {
            globalHandler.getWindow().setVisible( true );
         }
      } );
   }

   /**
    * Creates a new WindowHandler.
    * 
    * <p>This method creates a new handler, sets its level to ALL, and creates
    * the necessary Swing components on the EDT, and displays those components
    * as well.  After creation, this handler may still be configured as normal
    * for any other logging handler.</p>
    */
   public WindowHandler() {
      utilEDTWait( () -> {
         setLevel( Level.ALL );
         JFrame frame = new JFrame( "DEBUG" );
         text = new JTextArea();
         text.setEditable( false );
         text.setPreferredSize( new Dimension( 300, 300 ) );
         JScrollPane scroll = new JScrollPane( text );
         frame.add( scroll );
         frame.setDefaultCloseOperation( JFrame.HIDE_ON_CLOSE );
         frame.pack();
         frame.setLocation( windowList.size()*20, windowList.size()*20 );
         frame.setVisible( true );
         logWindow = frame;
         windowList.add( new WeakReference<>( this ) );
      } );
   }

   @Override
   public void publish( LogRecord record ) {
      SwingUtilities.invokeLater( () -> {
         StringBuilder log = new StringBuilder( text.getText() );
         log.append( record.getMessage() );
         log.append( " -- " );
         log.append( record.getLoggerName() );
         log.append( " : " );
         log.append( record.getLevel() );
         log.append( "  //  " );
         log.append( new Date( record.getMillis() ) );
         log.append( "\n" );
         text.setText( log.toString() );
      } );
   }

   @Override
   public void flush() {
   }

   @Override
   public void close() throws SecurityException {
   }

   private static void utilEDTWait( Runnable r ) {
      if( SwingUtilities.isEventDispatchThread() ) {
         r.run();
      } else {
         try {
            SwingUtilities.invokeAndWait( r );
         } catch( InterruptedException ex ) {
            Thread.currentThread().interrupt();
            throw new RuntimeException( ex );
         } catch( InvocationTargetException ex ) {
            Logger.getLogger( WindowHandler.class.getName() ).log( Level.SEVERE, null, ex );
         }
      }
   }

}