askvity

How to Write Log Messages in Java

Published in Java Logging 5 mins read

To write log messages in Java, you typically use a logging framework or the built-in Java Logging API (java.util.logging). This involves obtaining a Logger instance and calling its methods at different log levels.

Writing log messages in Java is a fundamental practice for debugging, monitoring, and understanding the execution flow of an application. Instead of using simple System.out.println(), logging frameworks provide structured ways to categorize, filter, format, and output messages to various destinations like console, files, databases, or network services.

The most common approach involves:

  1. Obtaining a Logger instance: This is usually done per class or module.
  2. Calling logging methods: Using methods associated with specific log levels (e.g., info, warning, severe) or a general log method with a specified level.

While several powerful logging frameworks exist in the Java ecosystem (like Logback, Apache Log4j 2), Java also comes with a built-in API: java.util.logging (often referred to as JUL).

Using java.util.logging (JUL)

JUL is part of the standard Java library and provides basic logging capabilities.

1. Getting a Logger

You obtain a Logger instance using its static getLogger method, typically passing the name of the class where logging is being performed:

import java.util.logging.Logger;

public class MyClass {
    private static final Logger LOGGER = Logger.getLogger(MyClass.class.getName());

    // ... rest of your class
}

2. Understanding Log Levels

Log levels indicate the severity or importance of a log message. JUL defines standard levels, ordered from highest to lowest severity:

Level Description
SEVERE Indicates a serious failure.
WARNING Indicates a potential problem.
INFO Informational messages highlighting progress.
CONFIG Static configuration messages.
FINE Fairly detailed tracing messages.
FINER Quite detailed tracing messages.
FINEST Highly detailed tracing messages.
ALL Used to enable logging for all levels.
OFF Used to turn off logging.

You can control which messages are logged by setting the level on a Logger or its Handlers.

3. Writing Basic Log Messages

You can use specific methods corresponding to the log levels:

LOGGER.info("Application started successfully.");
LOGGER.warning("Configuration file not found, using defaults.");
LOGGER.severe("Database connection failed!");

Or, you can use the general log method, specifying the level explicitly:

import java.util.logging.Level;

// ... inside your class

LOGGER.log(Level.INFO, "Using general log method for info.");
LOGGER.log(Level.WARNING, "Using general log method for warning.");

4. Logging with Parameters

To include variable data in your log messages without the overhead of string concatenation (especially if the log level is disabled), you can use methods that accept parameters. These methods often work in conjunction with message strings containing placeholders like {0}, {1}, etc., which are processed by the logging handlers/formatters.

Based on the reference provided, java.util.logging.Logger includes methods like:

  • log(Level level, String msg, Object param1): This method logs a message at the specified level. The msg string can contain a placeholder {0} which will be substituted by the value of param1 when the message is formatted.

    • Example:
      String user = "Alice";
LOGGER.log(Level.INFO, "Processing data for user {0}", user);

      Output (depending on formatter): INFO: Processing data for user Alice

  • log(Level level, String msg, Object[] params): This method logs a message at the specified level. The msg string can contain multiple placeholders ({0}, {1}, {2}, etc.) which will be substituted by the elements in the params array in order when the message is formatted.

    • Example:
      int itemQuantity = 10;
double itemPrice = 9.99;
LOGGER.log(Level.INFO, "Item {0} added to cart. Quantity: {1}, Price: {2}", new Object[]{"Widget", itemQuantity, itemPrice});

      Output (depending on formatter): INFO: Item Widget added to cart. Quantity: 10, Price: 9.99

Using these methods with placeholders is more efficient than pre-formatting the string ("Processing data for user " + user) because the string formatting only occurs if the log message is actually going to be published (i.e., the log level is enabled).

5. Logging Exceptions

You can also log exceptions or throwables:

try {
    // some risky operation
} catch (IOException e) {
    LOGGER.log(Level.SEVERE, "Error reading file", e);
}

This method logs the message and includes the stack trace of the exception in the log output.

Other Logging Frameworks

While JUL is built-in, many developers prefer third-party frameworks like:

  • Logback: Successor to Log4j 1.x, known for good performance and flexibility.
  • Apache Log4j 2: A highly performant and extensible logging framework.
  • SLF4j (Simple Logging Facade for Java): Not a logging framework itself, but an API that allows you to use any underlying logging framework (JUL, Logback, Log4j2, etc.) without changing your code. This is often recommended for library developers.

These frameworks generally follow similar patterns: get a logger, call level-specific methods, and offer advanced configuration for appenders, formatters, and filters. They also widely support parameterized logging using {} style placeholders in the message string directly within the level-specific methods (e.g., logger.info("Processing user {}", userId);).

In summary, writing log messages in Java involves obtaining a Logger and calling appropriate methods like info(), warning(), severe(), or the more general log(Level, String, Object...) methods, often utilizing parameters and placeholders for efficiency and clarity.

Related Articles