Java 1.6环境下实现高效日志：避免重复判断与字符串预构建

Great question—this is a classic pain point when bringing C++-style efficient logging to Java, especially stuck on Java 1.6 without lambdas or the Supplier interface. Let’s walk through a few practical approaches that mirror your C++ macro’s efficiency, without cluttering your code with repetitive if checks.

Approach 1: Use a Message Builder Interface with Anonymous Classes #

The core idea is to wrap your message-building logic in a simple interface, and only execute that logic if the log level is enabled. This mimics the lazy evaluation of your C++ macro.

First, define a lightweight interface to represent message producers:

public interface MessageProducer {
    String produce();
}

Then, update your logger class to accept this interface, and only trigger message building when the level is allowed:

public class AppLogger {
    private static final Level ACTIVE_LEVEL = Level.INFO; // Your app's current log level

    public static void log(Level level, MessageProducer producer) {
        // Check level first—no message building happens if this fails
        if (level.compareTo(ACTIVE_LEVEL) >= 0) {
            String message = producer.produce();
            // Execute your actual logging logic here (write to file, console, etc.)
            System.out.printf("[%s] %s%n", level.name(), message);
        }
    }
}

When calling the logger, pass your message-building logic via an anonymous inner class. This code only runs if the log level is enabled:

// Example 1: String.format message
AppLogger.log(Level.DEBUG, new MessageProducer() {
    public String produce() {
        return String.format("User %d logged in from IP %s", userId, ipAddress);
    }
});

// Example 2: Complex object toString()
AppLogger.log(Level.WARN, new MessageProducer() {
    public String produce() {
        return "Invalid request: " + complexRequestObject.toString();
    }
});

Approach 2: Overload Methods for Common Formatting Scenarios #

If most of your logging uses String.format, you can add a dedicated overload to reduce boilerplate. This still maintains lazy evaluation by checking the level before formatting:

public class AppLogger {
    private static final Level ACTIVE_LEVEL = Level.INFO;

    // For String.format-style messages
    public static void log(Level level, String format, Object... args) {
        if (level.compareTo(ACTIVE_LEVEL) >= 0) {
            String message = String.format(format, args);
            System.out.printf("[%s] %s%n", level.name(), message);
        }
    }

    // Keep the generic MessageProducer method for complex cases
    public static void log(Level level, MessageProducer producer) {
        if (level.compareTo(ACTIVE_LEVEL) >= 0) {
            System.out.printf("[%s] %s%n", level.name(), producer.produce());
        }
    }
}

Now simple formatted logs become cleaner:

AppLogger.log(Level.DEBUG, "User %d logged in from IP %s", userId, ipAddress);

Approach 3: Static Factory Methods to Reduce Anonymous Class Boilerplate #

If you find the anonymous class syntax tedious, create static helper methods to generate MessageProducer instances for common cases:

public class MessageProducers {
    // For String.format messages
    public static MessageProducer formatted(final String format, final Object... args) {
        return new MessageProducer() {
            public String produce() {
                return String.format(format, args);
            }
        };
    }

    // For object toString() calls
    public static MessageProducer fromObject(final Object obj) {
        return new MessageProducer() {
            public String produce() {
                return obj.toString();
            }
        };
    }
}

Then your logger calls get even more concise:

AppLogger.log(Level.DEBUG, MessageProducers.formatted("User %d logged in from IP %s", userId, ipAddress));
AppLogger.log(Level.WARN, MessageProducers.fromObject(complexRequestObject));

All these approaches achieve your goal: message building only occurs when the log level is enabled, and you avoid repeating if checks everywhere. They’re fully compatible with Java 1.6 and keep your logging code clean.

内容的提问来源于stack exchange，提问作者user2218825