我希望将我的程序异常发送给以下每个，最好是同时发送:

• 启动它的控制台(不一定)
• 一个贵
• 一个 txt 文件。

我怎样才能做到这一点？

我的尝试:

• System.setErr(PrintStream err)会将所有异常转发到新流。我无法说明更多 虽然是一个流。

• 调用 System.setErr(PrintStream err)在手写的 OutputStream 上:

  "You can write your own stream class that forwards to multiple streams and call System.setOut on an instance of that class" – Jeffrey Bosboom

  我找到了一种方法来做到这一点。虽然这很讨厌。它“收集”PrintStream的 write -bytes，将它们放入缓存中(500 毫秒超时)，最后将其显示给用户(Proceed):

  /* ErrorOutput.java */
  public static t_ErrBuffer t_activeErrBuffer = new t_ErrBuffer("");
  public static void setStdErrToFile(final File file) {
      ps = new PrintStream(fos) {
          @Override
          public void write(byte[] buf, int off, int len) {
              byte[] bn = new byte[len];
              for (int i = off, j = 0; i < (len + off); i++, j++) {
                  bn[j] = buf[i];
              }
              String msg = null;
              try {
                  msg = new String(bn, "UTF-8");
              } catch (UnsupportedEncodingException e1) {}
              if (msg.matches("[\\w\\W]*[\\w]+[\\w\\W]*")) { // ^= contains at least one word character
                  if( ! t_activeErrBuffer.isAlive() ) {
                      t_activeErrBuffer = new t_ErrBuffer(msg);
                      t_activeErrBuffer.start();
                  } else {
                      t_activeErrBuffer.interrupt();
                      t_activeErrBuffer = new t_ErrBuffer(t_activeErrBuffer.getErrBuffer() + "\n" + msg); // ^= append to buffer and restart.
                      t_activeErrBuffer.start();
                  }
              }
          }
      };
      System.setErr(ps);
  }
  
  /* t_ErrBuffer.java */
  public class t_ErrBuffer extends Thread {
      private String  errBuffer;
      public t_ErrBuffer(String buffer) {
          this.errBuffer = buffer;
      }
      protected class Proceed implements Runnable {
          public String msg = null;
          public Proceed(String msg) {
              this.msg = msg;
          }
          @Override
          public void run() {
              // todo PRINT ERROR MESSAGE: DO THINGS WITH msg: console, gui, JOptionPane
          }
      }
      @Override
      public void run() {
          try {
              Thread.sleep(500); // collect error lines before output. Needed because PrintStream's "write"-method writes ErrorMessages in multiple pieces (lines)
              // each time some new exception line comes in, the thread is stopped, buffer is being appended and thread new started
          } catch (InterruptedException e) {
              return; // stop
          }
          // after 500 ms of wait, no new error message line has come in. Print the message out:
          Thread t_tmp = new Thread(new Proceed("\n" + this.errBuffer));
          t_tmp.start();
          return;
      }
      public String getErrBuffer() {
          return this.errBuffer;
      }
  }
  

  这是我应该做的吗？

• 创建新的异常类来为我做这件事。可能会起作用，但除此之外的其他异常(IO、FileNotFound 等)仍将以旧方式处理

• 而不是声明 [method name] throws Exception我可以将我的所有代码包含在 try/catch-blocks 中，获取异常并将其转发给我的方法，如下所示:

  /* AnyMethod.java */
  // ...
  try {
      // ... do everything here
  } catch (IOException | FileNotFoundException e) {   // as many as you like
      ErrorOutput.crash(e);
  }
  // ...
  
  /* ErrorOutput.java */
  public static void crash(Exception e) {
      FileOutputStream fos_errOutput = new FileOutputStream(new File("ErrorOutput.txt"), true);
  
      // 1st
      if (!System.out.equals(fos_errOutput)) {
          System.out.println(e.getMessage() + " :");  // to console or the preferred StdOut
          e.printStackTrace();
      }       
  
      // 2nd
      JOptionPane.showMessageDialog(Gui.frame, "THE PROGRAM HAS CRASHED!" + "\n\n" + e.getMessage() + "\n\nFor a more detailed report, see ErrorLog.txt");    // gui output
  
      // 3rd
      PrintStream ps = new PrintStream(fos_errOutput);
      ps.print(new Date().toString() + ":");  // write to file
      e.printStackTrace(ps);
      ps.close();
  
      // 4th
      System.exit(0); // this could also be "throw new Exception" etc., but I don't know why one should do that.
  }
  

  这也可能有效，但我必须将所有内容 放入 try/catch block 中。这根本不是好的编程风格。

• 使用记录器:

  "use log4j and set up a method to write to GUI and also to log to stdout, and file" – Scary Wombat

  记录器只能帮助我打印我的异常到所需的流中，但它们不能帮助我捕获它们，对吗？

  But you really should use a logging package for this -- even java.util.logging can do what you need – Jeffrey Bosboom

  我必须告诉我的日志包在哪里记录什么。但这正是我要寻找的。

我现在可以按照 user3159253 的建议，使用 Thread.UncaughtExceptionHandler专门捕获未处理的异常。

按照我希望的方式处理所有抛出的异常的正确方法是什么？除了 Thread.UncaughtExceptionHandler 之外，我还需要考虑什么？和 System.setErr() (见上文)？

最佳答案

首先，您需要掌握线程中抛出的所有异常实例(可能是 try/catch 或 Thread.UncoughtExceptionHandler 或 ThreadPoolExecutor.afterExecute(Runnable r, Throwable t))。

然后，一旦您拥有异常实例，您就可以使用 log4j 简单地记录它，但配置 Log4j 附加程序以将您的异常消息发送到多个目的地。您可以根据需要使用文件、控制台、JDBC、JMS 等类型的附加程序。另外最好用 Async appender 包装它们。

引用 - https://logging.apache.org/log4j/2.x/manual/appenders.html

关于将异常消息推送到 GUI，它可以通过多种方式实现，具体取决于您在应用程序中使用的技术堆栈。在我们的应用程序中，我们将消息事件(仅关键事件)存储在数据库中，然后由服务器的事件监视线程选择这些事件，然后使用 http://cometd.org/documentation/cometd-java 将其推回 GUI(JQuery、JavaScript)。 .

关于java - 处理多个流中的所有异常，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27435094/