Java已弃用类LogStream无官方替代，寻求可行替代思路

Hey there! I’ve run into similar deprecation headaches before, so I feel your pain when there’s no official drop-in replacement. Let’s break down some practical, battle-tested approaches to refactor your code away from LogStream:

1. Switch to Java's Standard Logging API (java.util.logging) #

If you’re looking for a built-in, no-dependency solution, Java’s core logging framework is a solid starting point. You can replicate most LogStream behavior with Logger and Handler implementations:

import java.util.logging.Logger;
import java.util.logging.ConsoleHandler;
import java.util.logging.SimpleFormatter;

// Initialize logger
private static final Logger logger = Logger.getLogger(YourClass.class.getName());

static {
    // Configure handler (replace with FileHandler for file logging)
    ConsoleHandler handler = new ConsoleHandler();
    handler.setFormatter(new SimpleFormatter());
    logger.addHandler(handler);
    logger.setUseParentHandlers(false); // Avoid duplicate logs
}

// Usage example instead of LogStream
logger.info("This replaces LogStream.info()");
logger.warning("Warning message equivalent");
logger.severe("Critical error log");

This approach gives you full control over log levels, formatting, and output destinations (console, files, etc.) without relying on deprecated APIs.

2. Wrap a Custom Output Stream for Legacy Compatibility #

If you need to maintain a similar interface to LogStream for existing code, you can create a wrapper class that delegates to a modern logging backend. This minimizes code changes:

import java.io.PrintStream;
import java.util.logging.Logger;

public class CustomLogStream {
    private final Logger logger;
    private final PrintStream originalOut;

    public CustomLogStream(Logger logger) {
        this.logger = logger;
        this.originalOut = System.out;
    }

    // Mimic LogStream's write methods
    public void write(String message) {
        logger.info(message.trim());
    }

    public void writeError(String errorMessage) {
        logger.severe(errorMessage.trim());
    }

    // Optional: Redirect System.out to this stream if needed
    public void redirectSystemOut() {
        System.setOut(new PrintStream(new java.io.OutputStream() {
            @Override
            public void write(int b) {}
        }) {
            @Override
            public void println(String x) {
                write(x);
            }
        });
    }
}

// Usage
CustomLogStream logStream = new CustomLogStream(Logger.getLogger(YourClass.class.getName()));
logStream.write("Legacy-style log message");
logStream.writeError("Legacy error log");

This lets you keep your existing method calls while under the hood using a supported logging system.

3. Adopt a Third-Party Logging Framework (SLF4J + Logback/Log4j2) #

For more advanced features (structured logging, flexible configuration, performance), third-party frameworks are the industry standard. SLF4J acts as a facade, so you can switch between implementations easily:
First, add dependencies (if using Maven):

<!-- SLF4J API -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.9</version>
</dependency>
<!-- Logback implementation -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.11</version>
</dependency>

Then refactor your code:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

private static final Logger logger = LoggerFactory.getLogger(YourClass.class);

// Usage
logger.debug("Debug-level log");
logger.info("Info message");
logger.warn("Warning notification");
logger.error("Error with exception", new RuntimeException("Oops!"));

This gives you powerful features like parameterized logging (logger.info("User {} logged in", username)), which is safer and more efficient than string concatenation, plus easy configuration via XML/YAML files.

4. Roll Your Own Minimal Logging Utility (For Simple Use Cases) #

If you don’t want external dependencies and the standard API feels overkill, a lightweight custom logger works for basic needs:

import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDateTime;

public class SimpleLogger {
    private final String logFilePath;

    public SimpleLogger(String logFilePath) {
        this.logFilePath = logFilePath;
    }

    public void log(String level, String message) {
        String logEntry = String.format("[%s] [%s] %s%n", 
            LocalDateTime.now(), level, message);
        try (FileWriter writer = new FileWriter(logFilePath, true)) {
            writer.write(logEntry);
        } catch (IOException e) {
            e.printStackTrace(); // Fallback to console if file write fails
        }
    }

    public void info(String message) {
        log("INFO", message);
    }

    public void error(String message) {
        log("ERROR", message);
    }
}

// Usage
SimpleLogger logger = new SimpleLogger("app.log");
logger.info("Application started");
logger.error("Failed to load configuration");

This is bare-bones but sufficient for small applications where you just need basic file/console logging.

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