Как изменить вывод консоли ведения журналов Java с std err на std out?

я прибыл в

 SimpleFormatter fmt = new SimpleFormatter();
 StreamHandler sh = new StreamHandler(System.out, fmt);
 logger.addHandler(sh);

Хм, я несколько раз укусил за ногу, пытаясь совершить этот подвиг. Прежде чем погуглить сюда, мне удалось наколдовать следующий лайфхак. Некрасиво, но, кажется, выполняет свою работу.

public class StdoutConsoleHandler extends ConsoleHandler {
  protected void setOutputStream(OutputStream out) throws SecurityException {
    super.setOutputStream(System.out); // kitten killed here :-(
  }
}

Осторожно: вызов setOutputStream() из конструктора заманчив, но он (как уже указал Джон Скит) закрывает System.err. Безумные навыки!

Я придумал один способ. Сначала удалите обработчик консоли по умолчанию:

setUseParentHandlers (ложь);

Затем подкласс ConsoleHandler и в конструкторе:

setOutputStream(System.out);

У меня была аналогичная проблема. Я хотел записать INFO и ниже в System.out, а WARNING и выше в System.err. Вот решение, которое я реализовал:

public class DualConsoleHandler extends StreamHandler {

    private final ConsoleHandler stderrHandler = new ConsoleHandler();

    public DualConsoleHandler() {
        super(System.out, new SimpleFormatter());
    }

    @Override
    public void publish(LogRecord record) {
        if (record.getLevel().intValue() <= Level.INFO.intValue()) {
            super.publish(record);
            super.flush();
        } else {
            stderrHandler.publish(record);
            stderrHandler.flush();
        }
    }
}

Конечно, вы можете сделать его более гибким, например, исключив жестко закодированную ссылку на Level.INFO. Но это хорошо сработало для меня, чтобы получить базовое двухпотоковое ведение журнала. (Кстати, советы о том, чтобы не создавать подклассы ConsoleHandler, чтобы избежать закрытия System.err, были очень полезными.)

Ознакомьтесь с документацией и исходным кодом ConsoleHandler. — я уверен, что вы могли бы легко написать версию, которая просто использует System.err вместо System.out. (Жаль, что ConsoleHandler не позволяет это настроить, если честно.)

Тогда это просто случай настройки системы ведения журнала для использования вашего нового StdoutHandler (или как вы его называете) обычным способом.

Шаг 1. Установите для родительских обработчиков значение false.

log.setUseParentHandlers(false);

Шаг 2. Добавьте обработчик, который записывает в System.out

log.addHandler(new StreamHandler(System.out, new SimpleFormatter()));

Вот и все..

import java.io.IOException;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.logging.StreamHandler;

public class App {

     static final Logger log = Logger.getLogger("com.sample.app.App");

     static void processData() {
          log.info("Started Processing Data");
          log.info("Finished processing data");
     }

     public static void main(String args[]) throws IOException {
          log.setUseParentHandlers(false);

          log.addHandler(new StreamHandler(System.out, new SimpleFormatter()));

          processData();
     }
}

Если есть еще кто ищет решение этой проблемы. Вот что у меня получилось в итоге: я просто создал подкласс StreamHandler и добавил дополнительный параметр MaxLevel, который проверяется в начале publish(). Если уровень события регистрации больше, чем MaxLevel, дальнейшая публикация выполняться не будет. Вот подробности:

Основной класс MaxlevelStreamHandler.java ниже.

package helper;

/**
 * The only difference to the standard StreamHandler is 
 * that a MAXLEVEL can be defined (which then is not published)
 * 
 * @author Kai Goergen
 */

import java.io.PrintStream;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;

public class MaxlevelStreamHandler extends StreamHandler {

    private Level maxlevel = Level.SEVERE;  // by default, put out everything

    /**
     * The only method we really change to check whether the message
     * is smaller than maxlevel.
     * We also flush here to make sure that the message is shown immediately.
     */
    @Override
    public synchronized void publish(LogRecord record) {
        if (record.getLevel().intValue() > this.maxlevel.intValue()) {
            // do nothing if the level is above maxlevel
        } else {
            // if we arrived here, do what we always do
            super.publish(record);
            super.flush();
        }
    }

    /**
     * getter for maxlevel
     * @return
     */
    public Level getMaxlevel() {
        return maxlevel;
    }

    /**
     * Setter for maxlevel. 
     * If a logging event is larger than this level, it won't be displayed
     * @param maxlevel
     */
    public void setMaxlevel(Level maxlevel) {
        this.maxlevel = maxlevel;
    }

    /** Constructor forwarding */
    public MaxlevelStreamHandler(PrintStream out, Formatter formatter) {
        super(out, formatter);
    }

    /** Constructor forwarding */
    public MaxlevelStreamHandler() {
        super();
    }
}

Основной класс

Чтобы теперь отображать некоторые события в stdout, а некоторые в stderr, просто настройте два StreamLogger, один для критических событий и один для всех остальных, и отключите стандартный консольный логгер:

// setup all logs that are smaller than WARNINGS to stdout
MaxlevelStreamHandler outSh = new MaxlevelStreamHandler(System.out, formatter);
outSh.setLevel(Level.ALL);
outSh.setMaxlevel(Level.INFO);
logger.addHandler(outSh);

// setup all warnings to stdout & warnings and higher to stderr
StreamHandler errSh = new StreamHandler(System.err, formatter);
errSh.setLevel(Level.WARNING);
logger.addHandler(errSh);

// remove default console logger
logger.setUseParentHandlers(false);

logger.info("info");
logger.warning("warning");
logger.severe("severe");

Надеюсь это поможет!

Обновление: я добавил super.flush() сразу после super.publish(), чтобы убедиться, что сообщение отображается немедленно. Раньше у меня были проблемы с тем, что лог-сообщения всегда показывались в конце. Теперь это часть кода выше.

Если вы используете ведение журнала Java, вы можете изменить обработчик по умолчанию:

Например, для файлов: Handler fh = new FileHandler(FILENAME); Logger.getLogger(LOGGER_NAME).addHandler(fh);

Если вы хотите выводить в поток, вы можете использовать StreamHandler, я думаю, вы можете настроить его с любым потоком вывода, который вам нравится, включая системный поток.

Когда мы создаем новый объект ConsoleHandler, выходным потоком по умолчанию является «system.err». К сожалению, Java не предоставляет открытого метода для класса ConsoleHandler для установки выходного потока. Поэтому его можно задать только во время создания объекта. Поскольку класс ConsoleHandler расширяет StreamHandler, у которого есть защищенный метод setOutputStream для явного задания выходного потока. Чтобы установить выходной поток для ConsoleHandler, просто переопределите этот метод во время нового вызова для создания объекта.

ConsoleHandler consoleHandler = new ConsoleHandler (){
            @Override
            protected synchronized void setOutputStream(OutputStream out) throws SecurityException {
                super.setOutputStream(System.out);
            }
        };

ConsoleHandler сделает снимок System.err во время построения. Один из вариантов — поменять местами глобальный поток ошибок с глобальным исходящим потоком, а затем создать ConsoleHandler.

ConsoleHandler h = null;
final PrintStream err = System.err;
System.setErr(System.out);
try {
    h = new ConsoleHandler(); //Snapshot of System.err
} finally {
    System.setErr(err);
}

Это предполагает, что код имеет разрешение на изменение потока ошибок и что никакой другой работающий код не обращается к потоку ошибок. Короче говоря, это вариант, но есть более безопасные альтернативы.

Если вы установите setUseParentHandlers(false); он установлен только в ЭТОМ классе. Другие классы в приложении все равно будут передавать его в stderr.

Просто расширьте StreamHandler и в конструкторе вызовите Super(System.out,). Это позволит избежать закрытия System.err - спасибо