Java

Built‑in logging API

By ningnong

Here’s a concise summary of Java’s built‑in logging API (java.util.logging), which is part of the standard JDK and requires no external libraries.

java.util.logging Overview

The java.util.logging package provides a lightweight, built‑in logging framework for Java applications.
Its main purpose is to record messages for debugging, monitoring, and auditing.


Core Classes & Interfaces

Class / Interface
Purpose
Logger
Main entry point for logging messages. Supports different log levels and hierarchical naming.
Level
Defines standard logging levels (SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST, OFF, ALL).
Handler
Abstract base for output destinations (e.g., console, file, socket).
ConsoleHandler
Sends log output to the console (System.err by default).
FileHandler
Writes log messages to files (supports rotation).
Formatter
Formats log records into text.
SimpleFormatter
Default human‑readable text format.
XMLFormatter
Outputs logs in XML format.
LogRecord
Encapsulates a single log event (message, level, timestamp, etc.).
LogManager
Manages global logging configuration and logger instances.
Filter
Allows filtering of log records before they are published.

Basic Usage Example

import java.util.logging.*;

public class LoggingExample { 
 
    private static final Logger logger = Logger.getLogger(LoggingExample.class.getName());    

    public static void main(String[] args) {        
        // Set log level 
        logger.setLevel(Level.INFO);        
        // Log messages at different levels 
        logger.severe("Severe message");        
        logger.warning("Warning message");        
        logger.info("Info message");        
        logger.fine("Fine message (won't show unless level is set lower)");    
    }
}

Key Features

  • Built‑in: No external dependencies.
  • Configurable via code or logging.properties file.
  • Multiple outputs: Console, file, network.
  • Hierarchical loggers: Loggers inherit settings from parent loggers.
  • Custom handlers & formatters supported.



here’s a complete, runnable Java example that logs to both console and file with a custom formatter.
It uses only the standard java.util.logging package, so no extra libraries are needed.

Java Logging Example (Console + File with Custom Format)

import         java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;import java.util.logging.*;

// Custom formatter for log messages
class MyCustomFormatter extends Formatter {    
    private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";    
    @Override public String format(LogRecord record) {        
        String timestamp = new SimpleDateFormat(DATE_FORMAT).format(new Date(record.getMillis()));
        return String.format("[%s] [%s] %s - %s%n",                
                                timestamp,                
                                record.getLevel().getName(),                
                                record.getLoggerName(),                
                                record.getMessage()        
                            );    
        }
}

public class LoggingDemo {    
    private static final Logger logger = Logger.getLogger(LoggingDemo.class.getName());    
    public static void main(String[] args) {        
        try {            
            setupLogger();            
            // Example log messages 
            logger.severe("This is a SEVERE message");            
            logger.warning("This is a WARNING message");            
            logger.info("This is an INFO message");            
            logger.fine("This is a FINE message (won't show unless level is set lower)");        
            } catch (IOException e) {            
                System.err.println("Failed to set up logger: " + e.getMessage());
            }    
    }    
    
    private static void setupLogger() throws IOException {        
        // Remove default console handler from root logger 
        LogManager.getLogManager().reset();        
        // Set logger level 
        logger.setLevel(Level.ALL);        
        // Create custom formatter 
        Formatter formatter = new MyCustomFormatter();        
        // Console handler 
        ConsoleHandler consoleHandler = new ConsoleHandler();     
        consoleHandler.setLevel(Level.INFO); 
        // Show INFO and above in console 
        consoleHandler.setFormatter(formatter);        
        // File handler (append mode, limit 1MB, 3 rotating files) 
        FileHandler fileHandler = new FileHandler("app.log", 1024 * 1024, 3, true);
        fileHandler.setLevel(Level.ALL); 
        // Log everything to file 
        fileHandler.setFormatter(formatter);        
        // Add handlers to logger 
        logger.addHandler(consoleHandler);        
        logger.addHandler(fileHandler);    
    }
}

How It Works

  1. Custom Formatter (MyCustomFormatter)
    • Formats logs as:
      [2025-12-17 14:35:12] [INFO] LoggingDemo - This is an INFO message
  2. ConsoleHandler
    • Outputs logs to the console (System.err by default).
    • Configured to show only INFO and above.
  3. FileHandler
    • Writes logs to app.log with rotation (max 1MB per file, keep 3 files).
    • Logs all levels.
  4. LogManager Reset
    • Removes default handlers so we can fully control output.

Example Output

Console:

[2025-12-17 14:35:12] [SEVERE] LoggingDemo - This is a SEVERE message
[2025-12-17 14:35:12] [WARNING] LoggingDemo - This is a WARNING message
[2025-12-17 14:35:12] [INFO] LoggingDemo - This is an INFO message

File (app.log):

[2025-12-17 14:35:12] [SEVERE] LoggingDemo - This is a SEVERE message
[2025-12-17 14:35:12] [WARNING] LoggingDemo - This is a WARNING message
[2025-12-17 14:35:12] [INFO] LoggingDemo - This is an INFO message
[2025-12-17 14:35:12] [FINE] LoggingDemo - This is a FINE message (won't show unless level is set lower)



← Back to Learning Journey