16.2 Java Logging API Basics: Logger, Levels, Handlers, and Configuration

16.2 Java Logging API Basics: Logger, Levels, Handlers, and Configuration

Oracle also expects candidates to "understand the basics of Java Logging API." The standard API is java.util.logging in the java.logging module, so a modular application needs requires java.logging;. The exam-level skills are obtaining a logger, choosing levels, predicting which messages print, and reading a basic configuration.

---

Obtaining and Using a Logger

import java.util.logging.Level;
import java.util.logging.Logger;

public class OrderService {
    private static final Logger LOG = Logger.getLogger(OrderService.class.getName());

    void place(int id, int tries) {
        LOG.info("Placing order " + id);
        LOG.log(Level.WARNING, "Order {0} failed after {1} tries", new Object[] {id, tries});
        LOG.fine(() -> "Expensive debug text " + id);   // Supplier: built only if FINE is enabled
        try {
            throw new IllegalStateException("payment declined");
        } catch (IllegalStateException e) {
            LOG.log(Level.SEVERE, "Order failed", e);    // prints the message plus the stack trace
        }
    }
}

• Logger.getLogger(name) returns the logger for a dot-separated name, usually the class name. Calling it again with the same name returns the same instance (log == Logger.getLogger("com.shop.Orders") is true while the logger is in use).
• Loggers form a hierarchy by name: com.shop.Orders is a child of com.shop, and the root logger has the empty name "".
• Convenience methods exist for each level (severe, warning, info, config, fine, finer, finest), plus log(Level, String), log(Level, String, Object[]) with {0}-style parameters, and log(Level, String, Throwable).
• isLoggable(Level) tells you whether a message at that level would pass the logger's level check.

---

The Seven Standard Levels

Level.OFF (Integer.MAX_VALUE) disables logging, and Level.ALL (Integer.MIN_VALUE) enables everything. A message is published when its level value is greater than or equal to the threshold.

---

Why fine() Prints Nothing by Default

With the JDK's default configuration, the root logger's level is INFO and it has one ConsoleHandler, also at level INFO, that writes to System.err. A new named logger has a null level, so it inherits the effective level INFO from its parent. As a result, info, warning, and severe messages appear, while config, fine, finer, and finest messages do not.

Every message must pass two filters:

1. The logger's level (its own or the inherited one).
2. The handler's level for each handler that receives the record.

Logger log = Logger.getLogger("com.shop.Orders");
log.setLevel(Level.FINE);
log.fine("A");                          // still NOT shown: the root ConsoleHandler is INFO

ConsoleHandler handler = new ConsoleHandler();
handler.setLevel(Level.FINE);
log.addHandler(handler);
log.info("B");                          // printed TWICE: by this handler and by the root handler

log.setUseParentHandlers(false);
log.fine("C");                          // printed once, by this handler only

Records travel up the hierarchy to the parent's handlers unless setUseParentHandlers(false) is called. Forgetting that step is the usual cause of duplicate log lines.

---

Configuring Logging Without Code

The default settings come from the JDK's logging.properties file. You can point the JVM at your own file with a system property:

java -Djava.util.logging.config.file=logging.properties -cp app.jar com.shop.Main

handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler
.level=INFO
com.shop.level=FINE
java.util.logging.ConsoleHandler.level=FINE
java.util.logging.FileHandler.pattern=%h/shop%u.log

• .level sets the root logger level; com.shop.level sets the level for the com.shop logger and its children.
• Each handler has its own level property, which is the second filter described above.
• FileHandler writes to files (its pattern can use %h for the user's home directory and %u for a unique number), and ConsoleHandler writes to System.err.

---

System.Logger: The Platform Logging Facade

Java 9 added System.getLogger(name), which returns a System.Logger with its own levels (ALL, TRACE, DEBUG, INFO, WARNING, ERROR, OFF). By default it is backed by java.util.logging, so System.getLogger("sys").log(System.Logger.Level.INFO, "started") prints through the same console handler. Libraries use it to log without choosing a framework for the application.

---

How a Log Record Flows

The default SimpleFormatter prints two lines per record: a timestamp with the source class and method, then LEVEL: message. Its layout comes from the java.util.logging.SimpleFormatter.format property; for example, the pattern %4$s: %5$s%n prints only the level and the message, such as INFO: formatted.

Logging Best Practices the Exam Rewards

• Avoid building text that is never logged. LOG.fine("Order " + id) builds the string even when FINE is disabled; prefer LOG.fine(() -> "Order " + id), a {0} parameter, or an if (LOG.isLoggable(Level.FINE)) guard.
• Log the exception object, not just its message. LOG.log(Level.SEVERE, "Order failed", e) keeps the stack trace; logging e.getMessage() loses it.
• Do not log and rethrow at every layer. Logging the same exception in each method as it propagates produces duplicate noise; log it once where it is handled.
• Never log secrets. Passwords read with Console.readPassword() (see 14.1) or tokens must not reach log files.
• Use named loggers. Logger.getLogger(MyClass.class.getName()) lets configuration target a package. Logger.getGlobal() returns the logger named global, and Logger.getAnonymousLogger() returns an unregistered logger whose name is null.