Logging is an essential tool in software development for tracking and troubleshooting issues. In Java, you can use the built-in logging framework provided by the Java Util Logging (JUL) API. Logging levels allow you to categorize messages based on their importance or severity. In this article, we will explore how to log different levels of messages in Java.

Setting Up Logging Configuration

Before we start logging messages, we need to set up the logging configuration. Create a logging.properties file in your project’s resource directory with the following content:

handlers=java.util.logging.ConsoleHandler
java.util.logging.ConsoleHandler.level=ALL

You can modify this configuration based on your needs. For example, you can change the handler to a file handler to log messages to a file.

Logging Levels

Java provides several logging levels, each representing a different level of severity. Here are the common logging levels in decreasing order of severity:

1. SEVERE: Highest level, indicates a severe error or critical failure.
2. WARNING: Represents potential issues that may cause problems.
3. INFO: Provides information about the application’s state or progress.
4. CONFIG: Logs configuration-related information.
5. FINE: Provides detailed debugging information.
6. FINER: More detailed than FINE, often used for deeper debugging.
7. FINEST: Most detailed level, mostly used for troubleshooting.

Logging Messages

To log messages at different levels, you can use the Logger class from the java.util.logging package. Here’s an example:

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

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

    public void performTask() {
        logger.severe("Severe error occurred."); // SEVERE level
        logger.warning("Potential issue detected."); // WARNING level
        logger.info("Application started."); // INFO level
        logger.config("Configuration loaded."); // CONFIG level
        logger.fine("Debugging information."); // FINE level
        logger.finer("Deeper debugging information."); // FINER level
        logger.finest("Detailed troubleshooting information."); // FINEST level
    }
}

In the above example, we initialize a Logger instance using the fully qualified name of the class that owns the logger. We then call the corresponding log method provided by the Logger class to log messages at different severity levels.

Reading the Log Messages

To view the logged messages, you can assign different handlers to the logger. The java.util.logging.ConsoleHandler handler is used in the default configuration we set up earlier, which will log messages to the console.

There are other handlers available, such as FileHandler for writing logs to a file. You can also create your custom handlers if needed.

Conclusion

Logging levels in Java allow you to manage the verbosity of log messages. By setting appropriate log levels and logging messages accordingly, you can effectively debug and trace issues in your application. Remember to configure the logging framework and choose the appropriate log level based on the severity of your messages.