Логирование в Java

Логирование является неотъемлемой частью разработки приложений на Java. Оно позволяет отслеживать работу программы, диагностировать ошибки и анализировать поведение системы в реальном времени. В этой статье описаны основные компоненты системы логирования в Java, особенности конфигурации и процесса логирования.

Введение в логирование

Логирование в Java предоставляет механизм для записи и управления сообщениями об ошибках, событиях и других важных действиях приложения. Это достигается путем создания специальных объектов LogRecord, которые содержат всю необходимую информацию о событии.

LogRecord и его компоненты

LogRecord — это объект, который инкапсулирует информацию о лог-сообщении и используется для передачи запросов на логирование между логирующей инфраструктурой и индивидуальными обработчиками (Handlers). Он содержит следующие ключевые элементы:

• Источник: класс и метод, откуда было вызвано логирование. Если приложение не указало явно имена класса и метода источника, LogRecord попытается определить их автоматически при первом обращении к методам getSourceClassName или getSourceMethodName путем анализа стека вызовов.
• Уровень логирования: степень важности сообщения (INFO, WARNING, SEVERE и т.д.).
• Сообщение: текстовое описание события или ошибки.
• Исключение (опционально): информация об исключении, если оно произошло.
• Время события: отметка времени, когда произошло событие.
• Массив параметров (опционально): дополнительные параметры, связанные с сообщением.

Заметки о сериализации LogRecord

Передача по сети: В больших распределенных системах логи часто отправляются по сети на удаленные серверы для централизованного сбора, анализа и хранения. Это может быть реализовано через различные протоколы и технологии, такие как RMI (Remote Method Invocation), TCP/UDP-сокеты, HTTP-запросы и т.д.

Сериализация объектов: Чтобы передать объект LogRecord по сети, его необходимо сериализовать — преобразовать в последовательность байтов, которую можно передать и затем восстановить на другой стороне. Поскольку LogRecord реализует интерфейс Serializable, он может быть сериализован стандартными средствами Java.

Особенности сериализации LogRecord

• Массив параметров: В LogRecord может быть массив параметров (Object[] parameters), которые используются для форматирования сообщения. Поскольку эти объекты могут быть не сериализуемыми, при сериализации они преобразуются в строки с помощью метода toString(). Это означает, что оригинальные объекты параметров на принимающей стороне будут недоступны, только их строковые представления.
• ResourceBundle: LogRecord содержит ссылку на ResourceBundle для поддержки локализации сообщений. Однако сам ResourceBundle не сериализуется. Вместо этого сериализуется только его имя. При десериализации на принимающей стороне система попытается загрузить соответствующий ResourceBundle по этому имени. Если он доступен, локализация будет сохранена; если нет, могут возникнуть проблемы с отображением локализованных сообщений.

Практические соображения

• Оптимизация JVM: Из-за оптимизаций, таких как JIT-компиляция, стек вызовов может быть изменен, и автоматическое определение источника может дать неверные результаты. Это особенно актуально в многопоточных и распределенных средах.
• Безопасность и производительность: Сериализация объектов может иметь последствия для производительности и безопасности. Важно убедиться, что сериализуемые объекты не содержат чувствительной информации, которая не должна передаваться по сети. Также стоит учитывать объем данных при сериализации большого количества логов.

Альтернативы и решения

• Использование легковесных форматов: Вместо передачи целых объектов LogRecord, можно сериализовать логи в текстовые или бинарные форматы, такие как JSON или Protocol Buffers, что может быть более эффективно и безопасно.
• Логирование через внешние библиотеки: Существуют библиотеки и фреймворки (например, Log4j, SLF4J), которые предоставляют расширенные возможности для удаленного логирования и могут упростить процесс передачи логов по сети.

Информация о сериализации LogRecord важна для правильного и эффективного управления логированием в больших приложениях.

Уровни логирования

Уровень логирования служит не только фильтром для сообщений, но и показателем их важности. Под капотом уровни представляют собой целочисленные значения. В Java обычно используется семь уровней:

Пример сопоставления уровней

Фильтры

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

Каждый Logger и каждый Handler могут иметь ассоциированный с ними фильтр, реализующий интерфейс Filter. Этот интерфейс требует реализацию метода isLoggable(LogRecord record). При обработке сообщения логгер или обработчик вызывает метод isLoggable для проверки, должен ли данный LogRecord быть опубликован. Если isLoggable возвращает false, то LogRecord будет отброшен и не будет обработан дальше.

Как работают фильтры

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

Используя фильтры, вы можете задавать сложные условия для логирования, такие как фильтрация по содержимому сообщения, источнику, времени или любым другим критериям, которые вы определите в реализации isLoggable.

Логгеры и иерархия имен

Каждый логгер имеет уникальное имя, обычно соответствующее структуре пакетов Java, используя точечную нотацию (например, com.myapp.service.UserService). Такая именованная иерархия позволяет эффективно управлять логированием на разных уровнях приложения, от отдельных классов до целых модулей (пакетов).

Иерархическая структура логгеров

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

• Родительский логгер: Для логгера com.myapp.service родителем является логгер com.myapp.
• Дочерние логгеры: Логгер com.myapp является родителем для всех логгеров, чьи имена начинаются с com.myapp..

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

Корневой логгер

В основании иерархии находится корневой логгер. Он является родителем для всех логгеров и обеспечивает базовую конфигурацию по умолчанию. Если ни один из родительских логгеров не определяет уровень логирования или обработчики, логгер наследует их от корневого логгера.

Пример:

• Корневой логгер (“”)
  • com
    • com.myapp
      • com.myapp.service
      • com.myapp.controller

Наследование свойств логгеров

• Уровень логирования: Если для логгера уровень не задан (установлен в null), он наследует уровень от ближайшего родительского логгера с определенным уровнем.
• Обработчики (Handlers): Логгеры по умолчанию отправляют сообщения обработчикам своих родительских логгеров, если у них нет собственных обработчиков.
• Фильтры и форматеры: Также могут наследоваться или быть настроены индивидуально для каждого логгера.

Это наследование позволяет централизованно управлять логированием и уменьшает необходимость настраивать каждый логгер отдельно.

Пример настройки иерархии логгеров

Рассмотрим пример, чтобы понять, как иерархия имен логгеров помогает управлять логированием на уровне пакетов.

Структура проекта

myapp
│
├── service
│   ├── UserService.java
│   └── PaymentService.java
│
└── controller
    └── UserController.java

Конфигурация логирования

Можно настроить уровни логирования для этих пакетов в конфигурационном файле:

# Устанавливаем уровень INFO для корневого логгера
.level = INFO

# Устанавливаем уровень WARNING для логгера com.myapp
com.myapp.level = WARNING

# Устанавливаем уровень FINE для пакета service
com.myapp.service.level = FINE

# Логгер com.myapp.controller наследует уровень WARNING от com.myapp

Объяснение:

• Корневой логгер: Уровень INFO применяется ко всему приложению по умолчанию.
• Логгер com.myapp: Уровень WARNING переопределяет уровень для этого пакета и его дочерних логгеров.
• Логгер com.myapp.service: Уровень FINE переопределяет уровень WARNING для пакета service, позволяя более подробно логировать события в сервисах.
• Логгер com.myapp.controller: Наследует уровень WARNING от com.myapp, логируя только предупреждения и ошибки.

Анонимные логгеры

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

Пример создания анонимного логгера:

anonymousLogger = Logger.getAnonymousLogger();

Преимущества использования иерархии логгеров

• Централизованное управление: Позволяет устанавливать общие настройки на уровне приложения или модулей.
• Гибкость: Легко переопределять настройки для отдельных пакетов или классов.
• Масштабируемость: Упрощает управление логированием в больших проектах с множеством модулей.

Методы логирования

Методы логирования в Java предоставляют разработчикам гибкие возможности для записи сообщений в журнал. Существует два основных подхода к вызову этих методов, каждый из которых предназначен для определенных сценариев использования:

1. С явным указанием источника:

   logger.logз(Level level, String sourceClass, String sourceMethod, String msg);

В этом методе вы явно указываете имя класса (sourceClass) и метода (sourceMethod), откуда происходит вызов логирования. Этот подход полезен, когда необходимо точно определить источник сообщения, особенно в следующих случаях:

• Удаленное или асинхронное логирование: Когда сообщения передаются между разными компонентами или системами, явное указание источника обеспечивает точность информации.

• Оптимизации JVM: Из-за таких оптимизаций, как JIT-компиляция или инлайнинг методов, стек вызовов может быть изменен, что затрудняет автоматическое определение источника.

• Многопоточные приложения: В сложных многопоточных системах точное определение источника помогает в диагностике и отладке.

2. Без явного указания источника:

   logger.log(Level level, String msg);

Этот метод более удобен и требует меньше кода, так как система логирования самостоятельно пытается определить источник вызова путем анализа стека вызовов. Он подходит для большинства повседневных задач и упрощает процесс логирования.

Однако следует учитывать:

• Производительность: Анализ стека вызовов может незначительно влиять на производительность, особенно если логирование происходит очень часто.

• Точность определения источника: Из-за оптимизаций JVM (например, JIT-компиляции) или инлайнинга методов автоматическое определение источника может быть неточным или отсутствовать.

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

Обработчики (Handlers)

Обработчики являются важными компонентами системы логирования в Java. Они отвечают за получение LogRecord от логгера и передачу его к месту назначения, будь то консоль, файл, сеть или другое хранилище. Обработчики позволяют гибко управлять тем, куда и как будут отправляться лог-сообщения, и обеспечивают возможность расширения функциональности системы логирования.

Java предоставляет несколько стандартных обработчиков, которые покрывают основные потребности в логировании:

• ConsoleHandler: выводит сообщения в System.err.
• FileHandler: записывает логи в файл.
• SocketHandler: отправляет логи на удаленный TCP-порт.
• StreamHandler: записывает логи в поток OutputStream.
• MemoryHandler: хранит логи в буфере памяти (обычно в виде кольцевого буфера).

Настройка обработчиков

Обработчики могут быть индивидуально настроены:

• Уровень логирования: каждый обработчик может иметь свой собственный уровень логирования, что позволяет контролировать, какие сообщения он будет обрабатывать. Например, можно настроить FileHandler на запись только сообщений уровня WARNING и выше.
• Фильтры: обработчики могут использовать фильтры для более точного определения, какие сообщения следует обрабатывать, основываясь на пользовательских критериях.
• Форматеры (Formatters): определяют формат вывода лог-сообщений. Обработчики могут использовать различные форматеры, такие как SimpleFormatter или XMLFormatter, или вы можете создать собственный форматер для специфических требований.

Создание собственных обработчиков

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

close(): закрывает обработчик и освобождает все связанные с ним ресурсы, такие как открытые файлы или сетевые соединения.

publish(LogRecord record): основной метод, который определяет, как обработчик будет обрабатывать и передавать лог-сообщения.

flush(): обеспечивает сброс буферов, гарантируя, что все накопленные данные будут записаны.

Пример создания собственного обработчика:

public class DatabaseHandler extends Handler {
    private Connection connection;

    public DatabaseHandler() throws SQLException {
        // Инициализация подключения к базе данных
        connection = DriverManager.getConnection("jdbc:your_database_url");
    }

    @Override
    public void publish(LogRecord record) {
        if (!isLoggable(record)) {
            return;
        }
        // Логика записи сообщения в базу данных
        String message = getFormatter().format(record);
        // Выполнение SQL-запроса для сохранения сообщения
    }

    @Override
    public void flush() {
        // Реализация при необходимости
    }

    @Override
    public void close() throws SecurityException {
        try {
            connection.close();
        } catch (SQLException e) {
            // Обработка исключения
        }
    }
}

Подключение обработчиков к логгерам

Обработчики могут быть добавлены к логгерам как программно, так и через конфигурационный файл.

Программное подключение:

Logger logger = Logger.getLogger("com.myapp");
Handler fileHandler = new FileHandler("app.log");
fileHandler.setLevel(Level.INFO);
fileHandler.setFormatter(new SimpleFormatter());
logger.addHandler(fileHandler);

Подключение через конфигурационный файл (logging.properties):

handlers = java.util.logging.ConsoleHandler

# Настройка ConsoleHandler
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# Подключение FileHandler к логгеру com.myapp
com.myapp.handlers = java.util.logging.FileHandler
com.myapp.level = FINE
com.myapp.java.util.logging.FileHandler.level = FINE
com.myapp.java.util.logging.FileHandler.pattern = logs/app.log
com.myapp.java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter

Преимущества использования обработчиков

• Гибкость: позволяет направлять разные уровни и типы лог-сообщений в разные места назначения.
• Масштабируемость: облегчает управление логированием в больших приложениях, позволяя распределять логи по файлам, консолям и сетевым сервисам.
• Расширяемость: возможность создания кастомных обработчиков для интеграции с системами мониторинга, базами данных или другими сервисами.

Заключение

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

Форматеры (Formatters)

Форматеры являются неотъемлемой частью системы логирования в Java. Они используются обработчиками (Handlers) для преобразования LogRecord в человеко-читаемый или машино-читаемый формат перед отправкой сообщения на внешний приемник (например, в файл, консоль или сетевое соединение). Форматеры определяют, как будет выглядеть конечный вывод лог-сообщений, включая структуру, содержимое и стиль представления данных.

Стандартные форматеры в Java

Java предоставляет два стандартных форматера, которые покрывают основные потребности в форматировании логов:

• SimpleFormatter: выводит сообщения в простом текстовом формате. Он включает такие элементы, как дата и время события, уровень логирования, имя логгера, сообщение и информацию об исключениях (если они присутствуют). Этот форматер удобен для чтения человеком и подходит для большинства сценариев отладки и мониторинга.
• XMLFormatter: форматирует сообщения в виде структурированных XML-документов. Каждое лог-сообщение представлено как XML-элемент с детализированной информацией обо всех полях LogRecord. Этот форматер полезен для автоматизированной обработки логов, их парсинга или интеграции с системами, поддерживающими XML.

июл 30, 2023 10:15:30 PM SimpleFormatterExample main
ИНФОРМАЦИЯ: Это информационное сообщение.

<?xml version="1.0" encoding="UTF-8"?>
<log>
<record>
  <date>2023-07-30T22:20:45.123</date>
  <millis>1690740045123</millis>
  <sequence>0</sequence>
  <logger>XMLFormatterExample</logger>
  <level>INFO</level>
  <class>XMLFormatterExample</class>
  <method>main</method>
  <thread>1</thread>
  <message>Это информационное сообщение.</message>
</record>
</log>

Настройка форматеров для обработчиков

Обработчики могут быть настроены использовать определенный форматер в зависимости от ваших потребностей. Например, можно настроить ConsoleHandler для использования SimpleFormatter, а FileHandler — для использования XMLFormatter.

Пример программной настройки форматера для обработчика:

import java.util.logging.*;

public class LoggingExample {
    public static void main(String[] args) throws Exception {
        Logger logger = Logger.getLogger("com.myapp");

        // Настраиваем ConsoleHandler с SimpleFormatter
        ConsoleHandler consoleHandler = new ConsoleHandler();
        consoleHandler.setFormatter(new SimpleFormatter());
        logger.addHandler(consoleHandler);

        // Настраиваем FileHandler с XMLFormatter
        FileHandler fileHandler = new FileHandler("app_logs.xml");
        fileHandler.setFormatter(new XMLFormatter());
        logger.addHandler(fileHandler);

        logger.setUseParentHandlers(false); // Отключаем обработчики родителя

        logger.info("Это информационное сообщение.");
    }
}

Создание собственного форматера

Если стандартные форматеры не удовлетворяют вашим требованиям, вы можете создать собственный форматер, наследуя абстрактный класс Formatter и реализуя метод format(LogRecord record). Это позволяет полностью контролировать формат и содержимое лог-сообщений.

Пример создания собственного форматера:

import java.util.logging.*;

public class CustomFormatter extends Formatter {
    @Override
    public String format(LogRecord record) {
        StringBuilder builder = new StringBuilder();

        builder.append("[")
               .append(record.getLevel()).append("] ")
               .append(formatMessage(record)).append(" - ")
               .append(record.getSourceClassName()).append(".")
               .append(record.getSourceMethodName()).append("()")
               .append(System.lineSeparator());

        if (record.getThrown() != null) {
            try {
                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter(sw);
                record.getThrown().printStackTrace(pw);
                builder.append(sw.toString());
            } catch (Exception ex) {
                // Игнорируем исключение
            }
        }

        return builder.toString();
    }
}

Применение собственного форматера к обработчику:

// Создаем и настраиваем обработчик с собственным форматером
FileHandler customFileHandler = new FileHandler("custom_logs.log");
customFileHandler.setFormatter(new CustomFormatter());
logger.addHandler(customFileHandler);

Преимущества использования собственных форматеров

• Кастомизация формата: Полный контроль над тем, какая информация и в каком виде будет включена в лог-сообщение.
• Соответствие стандартам: Возможность привести формат логов в соответствие с корпоративными стандартами или требованиями внешних систем.
• Локализация: Реализация поддержки различных языков для сообщений логирования, используя ресурсные бандлы.
• Интеграция с внешними системами: Форматирование логов в специфические форматы (например, JSON, CSV), необходимые для интеграции с системами мониторинга, анализа или сбора логов.

Советы по разработке форматеров

• Оптимизация производительности: Избегайте тяжелых операций внутри метода format, так как логирование может происходить очень часто.
• Потокобезопасность: Убедитесь, что ваш форматер работает корректно в многопоточной среде.
• Используйте formatMessage: Метод formatMessage(LogRecord) следует использовать для получения локализованного сообщения, учитывая параметры и ресурсные бандлы.

Заключение

Форматеры предоставляют мощный механизм для управления внешним видом и структурой ваших лог-сообщений. Используя стандартные форматеры или создавая собственные, вы можете настроить систему логирования так, чтобы она максимально соответствовала потребностям вашего приложения и облегчала процесс мониторинга, отладки и анализа данных.

LogManager

LogManager — это центральный компонент системы логирования в Java, отвечающий за инициализацию и управление всей инфраструктурой логирования. Он играет ключевую роль в настройке и поддержании иерархии логгеров, обработчиков и других связанных с логированием компонентов.

Основные функции LogManager

• Загрузка конфигурации: LogManager загружает конфигурацию системы логирования из внешних источников, таких как файлы конфигурации (например, logging.properties), или из пользовательских источников (LDAP, базы данных и т.д.). Эта конфигурация определяет уровни логирования, обработчики, форматеры и другие настройки, необходимые для корректной работы системы логирования.
• Создание иерархии логгеров: Он отвечает за создание и поддержание иерархической структуры логгеров на основе их имен. LogManager отслеживает все зарегистрированные логгеры и их взаимосвязи, что позволяет эффективно управлять логированием на разных уровнях приложения.
• Применение настроек: LogManager применяет загруженные настройки к соответствующим логгерам и обработчикам. Это включает установку уровней логирования, добавление обработчиков к логгерам, настройку форматеров и фильтров. Благодаря этому все компоненты системы логирования работают согласованно и в соответствии с заданной конфигурацией.

Инициализация LogManager

LogManager инициализируется при запуске приложения. По умолчанию, он загружает конфигурацию из файла logging.properties, расположенного в директории конфигурации Java (обычно $JAVA_HOME/conf/logging.properties или $JAVA_HOME/lib/logging.properties). Однако вы можете указать собственный файл конфигурации или класс для загрузки настроек, используя системные свойства или программно.

Управление иерархией логгеров

LogManager отслеживает все зарегистрированные логгеры и их взаимосвязи. При создании нового логгера с помощью метода Logger.getLogger(String name) он автоматически регистрируется в LogManager и добавляется в иерархию на основании его имени.

Пример создания логгеров и их иерархии:

Logger loggerA = Logger.getLogger("com.myapp");
Logger loggerB = Logger.getLogger("com.myapp.service");
Logger loggerC = Logger.getLogger("com.myapp.service.user");

// loggerA является родителем для loggerB, а loggerB — для loggerC

Логгеры наследуют настройки (например, уровень логирования и обработчики) от своих родительских логгеров, если они не переопределены явно. Это позволяет централизованно управлять логированием и упрощает конфигурацию.

Настройка через конфигурационный файл

Конфигурационный файл для логирования имеет формат java.util.Properties и содержит настройки для LogManager, логгеров, обработчиков и форматеров.

Пример содержимого logging.properties:

# Указываем обработчики для корневого логгера
handlers = java.util.logging.ConsoleHandler

# Устанавливаем уровень логирования для корневого логгера
.level = INFO

# Настройки ConsoleHandler
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# Настройка уровней для конкретных логгеров
com.myapp.level = FINE
com.myapp.service.level = WARNING
com.myapp.service.user.level = FINEST

Объяснение:

• handlers: определяет обработчики, которые будут использоваться корневым логгером.
• .level: устанавливает уровень логирования для корневого логгера.
• com.myapp.level: устанавливает уровень FINE для логгера com.myapp и всех его дочерних логгеров, если не указано иное.
• com.myapp.service.level: переопределяет уровень на WARNING для логгера com.myapp.service.
• com.myapp.service.user.level: устанавливает уровень FINEST для логгера com.myapp.service.user.

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

Динамическое обновление настроек: Некоторые реализации позволяют динамически обновлять настройки логирования без перезапуска приложения, что облегчает управление в производственной среде.

Локализация

Лог-сообщения могут требовать локализации для поддержки различных языков и региональных настроек. Каждому логгеру может быть ассоциировано имя ResourceBundle (набор ресурсов), которое используется для сопоставления исходных строк сообщений с локализованными строками сообщений.

При создании лог-сообщений вы можете использовать ключи из ResourceBundle вместо непосредственных строк. Соответствующий ResourceBundle будет использоваться для преобразования этих ключей в локализованные сообщения на нужном языке.

Как это работает:

• Логгер с ResourceBundle: Логгер может иметь связанное с ним имя ResourceBundle, которое содержит локализованные сообщения. Это позволяет использовать один и тот же код для разных языков, обеспечивая поддержку интернационализации.
• Форматеры выполняют локализацию: Обычно локализацией занимаются форматеры. Класс Formatter предоставляет метод formatMessage, который обеспечивает базовую поддержку локализации и форматирования сообщений. Этот метод использует ResourceBundle логгера для получения локализованной строки сообщения и форматирует ее с использованием переданных параметров.

Пример использования локализации:

import java.util.logging.*;
import java.util.ResourceBundle;

public class LocalizationExample {

    private static final Logger logger = Logger.getLogger("com.myapp");

    static {
        // Устанавливаем ResourceBundle для логгера
        logger.setResourceBundle(ResourceBundle.getBundle("messages"));
    }

    public static void main(String[] args) {
        // Логируем сообщение по ключу из ResourceBundle
        logger.info("app.start");

        // Логируем сообщение с параметрами
        logger.log(Level.WARNING, "app.warning", new Object[]{"параметр1"});
    }
}

Содержимое файла messages.properties (для английской локали):

app.start=Application has started.
app.warning=Warning: {0}

Содержимое файла messages_ru.properties (для русской локали):

app.start=Приложение запущено.
app.warning=Предупреждение: {0}

Объяснение:

• Настройка ResourceBundle: В блоке static мы устанавливаем ResourceBundle для логгера, используя метод ResourceBundle.getBundle("messages"). Java автоматически выберет правильный файл ресурсов в зависимости от текущей локали.
• Логирование сообщений по ключам: Вместо прямого использования строк, мы передаем ключи ("app.start", "app.warning") в методы логирования. Логгер использует ResourceBundle для получения соответствующих локализованных сообщений.
• Форматирование сообщений с параметрами: При логировании сообщений с параметрами мы передаем массив объектов new Object[]{"параметр1"}. Метод formatMessage в Formatter автоматически подставит эти параметры в локализованное сообщение.
• Локализация вывода: Если приложение запускается с русской локалью, будут использованы строки из messages_ru.properties, и вывод будет на русском языке.