Java Logging API

Master the Java Logging API including Logger, LogManager, logging levels, handlers, formatters, and logging configuration for the OCP 21 exam.

Table of Contents

• 1. Logging Overview
• 2. Logger Class
• 3. Logging Levels
• 4. Handlers and Formatters
• 5. Logging Configuration
• 6. Exam Key Points

1. Logging Overview

The Java Logging API (java.util.logging) provides a framework for logging application messages.

1.1 Key Components

• Logger: Used to log messages
• LogManager: Manages loggers and configuration
• Handler: Processes log records (console, file, etc.)
• Formatter: Formats log records for output
• Level: Severity level of log messages

2. Logger Class

2.1 Creating and Using Logger

Example:

import java.util.logging.Logger;

// Get logger (usually use class name)
Logger logger = Logger.getLogger(MyClass.class.getName());

// Logging messages
logger.severe("Severe message");
logger.warning("Warning message");
logger.info("Info message");
logger.config("Config message");
logger.fine("Fine message");
logger.finer("Finer message");
logger.finest("Finest message");

// Generic log method
logger.log(Level.INFO, "Message with level");

// Log with exception
logger.log(Level.SEVERE, "Error occurred", exception);

3. Logging Levels

Logging levels define the severity of log messages, ordered from highest to lowest:

3.1 Level Hierarchy

1. SEVERE - Highest level, serious failures
2. WARNING - Warning messages
3. INFO - Informational messages
4. CONFIG - Configuration messages
5. FINE - Detailed tracing
6. FINER - More detailed tracing
7. FINEST - Most detailed tracing

Example:

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

Logger logger = Logger.getLogger(MyClass.class.getName());

// Set level
logger.setLevel(Level.INFO);

// Check if level is loggable
if (logger.isLoggable(Level.FINE)) {
    logger.fine("Expensive operation");
}

// Get level
Level currentLevel = logger.getLevel();

4. Handlers and Formatters

4.1 Common Handlers

Example:

import java.util.logging.*;
import java.io.IOException;

Logger logger = Logger.getLogger(MyClass.class.getName());

// Console handler (default)
ConsoleHandler consoleHandler = new ConsoleHandler();
logger.addHandler(consoleHandler);

// File handler
try {
    FileHandler fileHandler = new FileHandler("app.log");
    logger.addHandler(fileHandler);
} catch (IOException e) {
    e.printStackTrace();
}

// Set handler level
consoleHandler.setLevel(Level.WARNING);

// Set formatter
consoleHandler.setFormatter(new SimpleFormatter());

4.2 Formatters

Example:

import java.util.logging.*;

// SimpleFormatter - human-readable format
SimpleFormatter simpleFormatter = new SimpleFormatter();
handler.setFormatter(simpleFormatter);

// XMLFormatter - XML format
XMLFormatter xmlFormatter = new XMLFormatter();
handler.setFormatter(xmlFormatter);

// Custom formatter
class CustomFormatter extends Formatter {
    public String format(LogRecord record) {
        return record.getLevel() + ": " + record.getMessage() + "\n";
    }
}

5. Logging Configuration

5.1 Configuration File

Example:

# logging.properties
# Global logging level
.level=INFO

# Logger-specific levels
com.example.mymodule.level=FINE

# Handler configuration
java.util.logging.ConsoleHandler.level=INFO
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter

# File handler
java.util.logging.FileHandler.pattern=app.log
java.util.logging.FileHandler.level=WARNING

6. Exam Key Points

Critical Concepts for OCP 21 Exam:

• Logger: Used to log messages
• getLogger(): Get or create logger instance
• Logging Levels: SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST
• setLevel(): Set logger or handler level
• isLoggable(): Check if level is loggable
• Handler: Processes log records
• ConsoleHandler: Outputs to console
• FileHandler: Outputs to file
• Formatter: Formats log records
• SimpleFormatter: Human-readable format
• XMLFormatter: XML format
• LogManager: Manages logging configuration