Logger类的单例模式替代方案：共享库日志类设计需求

针对你的Logger类设计需求，这里有几个比传统单例更灵活且能满足路径仅可设置一次和线程安全核心目标的方案，每个都适配不同的应用场景：

1. 不可变对象 + 依赖注入（Immutable Object + Dependency Injection） #

这是最贴合“无预设使用方式”需求的方案：Logger实例在构造时就确定文件路径，之后完全不可修改；应用通过依赖注入把同一个Logger实例传递到所有需要日志的组件中，线程安全则通过写入时的锁来保证。

#include <QString>
#include <QMutex>
#include <QMutexLocker>
#include <QFile>
#include <QDateTime>

class Logger {
private:
    const QString m_fullFilePath; // 构造后不可修改，保证路径唯一
    QMutex m_writeMutex;          // 保护文件写入操作的线程安全

    // 内部生成固定格式的文件名，应用只指定路径
    QString generateFileName() {
        return "app_log_" + QString::number(QDateTime::currentMSecsSinceEpoch()) + ".txt";
    }

public:
    // 唯一构造函数：必须传入应用指定的文件路径
    explicit Logger(const QString& baseFilePath) 
        : m_fullFilePath(baseFilePath + "/" + generateFileName()) {}

    bool log(const QString& datas) {
        QMutexLocker locker(&m_writeMutex); // RAII自动加解锁，避免死锁
        QFile logFile(m_fullFilePath);
        
        if (!logFile.open(QIODevice::Append | QIODevice::Text)) {
            return false;
        }

        QTextStream output(&logFile);
        // 执行你需要的头部/尾部封装逻辑
        output << "[LOG_START] " << datas << " [LOG_END]\n";
        return true;
    }

    // 禁止拷贝/移动，避免意外创建多个实例
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
    Logger(Logger&&) = delete;
    Logger& operator=(Logger&&) = delete;
};

优点 #

• 完全满足“路径仅设置一次”的要求，构造后路径不可变更
• 无全局状态，应用可灵活控制Logger的生命周期（比如按需销毁、测试时替换实例）
• 依赖注入让组件间耦合度更低，更易测试和维护

缺点 #

• 应用需要负责管理Logger实例的传递，若没有依赖注入框架，需要手动确保所有组件拿到同一个实例

2. 受控初始化的全局实例（Controlled Global Instance） #

这是传统单例的改进版：保留全局唯一实例，但把初始化和实例获取分离，确保路径只能设置一次，且只有初始化完成后才能使用日志功能。

#include <QString>
#include <QMutex>
#include <QFile>
#include <QDateTime>

class Logger {
private:
    QString m_fullFilePath;
    QMutex m_initMutex;
    QMutex m_writeMutex;
    bool m_isInitialized = false;

    // 私有构造，禁止外部直接创建
    Logger() = default;

    QString generateFileName() {
        return "app_log_" + QString::number(QDateTime::currentMSecsSinceEpoch()) + ".txt";
    }

public:
    // 初始化方法：只能成功调用一次，后续调用返回失败
    bool initialize(const QString& baseFilePath) {
        QMutexLocker locker(&m_initMutex);
        if (m_isInitialized) {
            return false; // 已初始化，拒绝重复设置路径
        }
        m_fullFilePath = baseFilePath + "/" + generateFileName();
        m_isInitialized = true;
        return true;
    }

    // 获取全局唯一实例（C++11+静态局部变量初始化线程安全）
    static Logger& instance() {
        static Logger globalLogger;
        return globalLogger;
    }

    bool log(const QString& datas) {
        if (!m_isInitialized) {
            return false; // 未初始化，拒绝写入
        }

        QMutexLocker locker(&m_writeMutex);
        QFile logFile(m_fullFilePath);
        if (!logFile.open(QIODevice::Append | QIODevice::Text)) {
            return false;
        }

        QTextStream output(&logFile);
        output << "[LOG_START] " << datas << " [LOG_END]\n";
        return true;
    }

    // 禁止拷贝/移动
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
};

优点 #

• 无需应用管理实例，全局唯一且线程安全
• 初始化时机可控，应用可在启动阶段完成路径设置，之后无法修改

缺点 #

• 仍存在全局状态，可能增加测试难度（需要模拟或重置实例）

3. 工厂模式 + 单实例约束（Factory Pattern + Single Instance Constraint） #

把Logger的创建逻辑抽离到工厂类中，由工厂控制只创建一个Logger实例，Logger本身保持不可变，线程安全由工厂和Logger共同保证。

#include <QString>
#include <QMutex>
#include <QSharedPointer>
#include <QFile>
#include <QDateTime>

class Logger {
private:
    const QString m_fullFilePath;
    QMutex m_writeMutex;

    QString generateFileName() {
        return "app_log_" + QString::number(QDateTime::currentMSecsSinceEpoch()) + ".txt";
    }

    // 私有构造，仅允许工厂创建
    explicit Logger(const QString& baseFilePath) 
        : m_fullFilePath(baseFilePath + "/" + generateFileName()) {}

public:
    bool log(const QString& datas) {
        QMutexLocker locker(&m_writeMutex);
        QFile logFile(m_fullFilePath);
        if (!logFile.open(QIODevice::Append | QIODevice::Text)) {
            return false;
        }

        QTextStream output(&logFile);
        output << "[LOG_START] " << datas << " [LOG_END]\n";
        return true;
    }

    // 让工厂类能访问私有构造
    friend class LoggerFactory;

    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
};

class LoggerFactory {
private:
    static QSharedPointer<Logger> m_loggerInstance;
    static QMutex m_factoryMutex;

public:
    // 创建Logger实例：仅第一次调用有效，后续返回已有实例
    static QSharedPointer<Logger> createLogger(const QString& baseFilePath) {
        QMutexLocker locker(&m_factoryMutex);
        if (!m_loggerInstance) {
            m_loggerInstance = QSharedPointer<Logger>(new Logger(baseFilePath));
        }
        return m_loggerInstance;
    }

    // 获取已有实例（若未创建则返回空指针）
    static QSharedPointer<Logger> getLogger() {
        QMutexLocker locker(&m_factoryMutex);
        return m_loggerInstance;
    }
};

// 静态成员初始化
QSharedPointer<Logger> LoggerFactory::m_loggerInstance = nullptr;
QMutex LoggerFactory::m_factoryMutex;

优点 #

• 实例创建逻辑与Logger业务逻辑分离，符合单一职责原则
• 可轻松扩展为支持多实例（只需修改工厂的单实例约束）
• 使用QSharedPointer自动管理实例生命周期

缺点 #

• 工厂类本身是全局状态，和单例类似，但耦合度更低

方案选择建议 #

• 如果你的应用已经使用依赖注入框架（比如Qt的QQmlEngine依赖注入、或第三方DI框架），优先选择不可变对象+依赖注入方案，它最灵活且无全局状态
• 如果需要简单的全局唯一实例，且希望初始化时机可控，选择受控初始化的全局实例
• 如果想把创建逻辑和业务逻辑彻底分离，或者未来可能需要多实例支持，选择工厂模式+单实例约束

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