[2026-04-16 21:33:18] [DEBUG] [1030871] [Main.cc] [10] - hello world hello Cx330
         日期          日志等級(jí)    pid     源文件   行號(hào) -         內(nèi)容       root   

#ifndef __MUTEX_HPP
#define __MUTEX_HPP
#include <iostream>
#include <pthread.h>
class Mutex
{
public:
    Mutex()
    {
        pthread_mutex_init(&_lock,nullptr);
    }    
    void Lock()
    {
        pthread_mutex_lock(&_lock);
    }
    pthread_mutex_t *Orgin()
    {
        return &_lock;
    }
    void Unlock()
    {
        pthread_mutex_unlock(&_lock);
    }
    ~Mutex()
    {
        pthread_mutex_destroy(&_lock);
    }
private:
    pthread_mutex_t _lock;
};
// 鎖的開關(guān)
class LockGuard
{
public:
    LockGuard(Mutex *lockp):_lockp(lockp)
    {
        _lockp->Lock();
    }
    ~LockGuard()
    {
        _lockp->Unlock();
    }
private:
    Mutex *_lockp;
};
#endif

// 獲取當(dāng)前時(shí)間的字符串表示（格式：YYYY-MM-DD HH:MM:SS）
std::string GetTimeStamp()
{
    // 獲取從1970-01-01 UTC到當(dāng)前時(shí)刻的秒數(shù)（Unix時(shí)間戳）
    time_t timestamp = time(nullptr);
    // 定義tm結(jié)構(gòu)體用于存儲(chǔ)分解后的本地時(shí)間
    struct tm data_time;
    // 將時(shí)間戳轉(zhuǎn)換為本地時(shí)間（線程安全版本，localtime_r是POSIX標(biāo)準(zhǔn)）
    localtime_r(&timestamp, &data_time);
    // 緩沖區(qū)，用于存放格式化后的時(shí)間字符串
    char data_time_str[128];
    // 使用snprintf進(jìn)行格式化，限制最大寫入長(zhǎng)度，防止溢出
    // 格式：年-月-日 時(shí):分:秒，各部分不足兩位時(shí)補(bǔ)零
    snprintf(data_time_str, sizeof(data_time_str), "%4d-%02d-%02d %02d:%02d:%02d",
             // tm_year 從1900年開始計(jì)數(shù)，需要加1900得到實(shí)際年份
             data_time.tm_year + 1900,
             // tm_mon 范圍0~11，需要加1轉(zhuǎn)換為實(shí)際月份
             data_time.tm_mon + 1,
             data_time.tm_mday,   // 日（1~31）
             data_time.tm_hour,   // 小時(shí)（0~23）
             data_time.tm_min,    // 分鐘（0~59）
             data_time.tm_sec);   // 秒（0~60，閏秒時(shí)可達(dá)60）
    // 返回std::string對(duì)象，自動(dòng)拷貝緩沖區(qū)內(nèi)容
    return data_time_str;
}

#include <iostream>
#include <memory>
#include <unistd.h>
#include "Logger.hpp"
using namespace LogModule;
// 測(cè)試時(shí)間戳模塊
void testTime()
{
    for(int i = 0; i < 5; i++)
    {
        std::cout << GetTimeStamp() << std::endl;
        sleep(1);
    }
}
int main()
{
    // 1. 測(cè)試時(shí)間
    testTime();
    return 0;
}

// 日志等級(jí)枚舉，用于區(qū)分事件的嚴(yán)重程度
enum LogLevel
{
    DEBUG,   // 調(diào)試信息，僅開發(fā)階段使用，生產(chǎn)環(huán)境通常關(guān)閉
    INFO,    // 常規(guī)信息，如服務(wù)啟動(dòng)、正常業(yè)務(wù)流轉(zhuǎn)
    WARNING, // 警告信息，表示潛在問題，但系統(tǒng)仍可正常運(yùn)行
    ERROR,   // 運(yùn)行時(shí)錯(cuò)誤，某個(gè)功能可能受損，需要關(guān)注
    FATAL    // 致命錯(cuò)誤，程序即將終止（如內(nèi)存分配失?。?
};
// 將日志等級(jí)枚舉轉(zhuǎn)換為對(duì)應(yīng)的字符串（用于日志輸出）
std::string LogLevel2String(LogLevel level)
{
    switch (level)
    {
    case LogLevel::DEBUG:
        return "DEBUG";     // 調(diào)試等級(jí)
    case LogLevel::INFO:
        return "INFO";      // 信息等級(jí)
    case LogLevel::WARNING:
        return "WARNING";   // 警告等級(jí)
    case LogLevel::ERROR:
        return "ERROR";     // 錯(cuò)誤等級(jí)
    case LogLevel::FATAL:
        return "FATAL";     // 致命等級(jí)
    default:
        return "UNKNOWN";   // 未匹配到的等級(jí)（防護(hù)性代碼）
    }
}

#include <iostream>
#include <memory>
#include <unistd.h>
#include "Logger.hpp"
using namespace LogModule;
// 測(cè)試日志類枚舉類型轉(zhuǎn)字符類型模塊
void testEnum()
{
    std::cout << LogLevel2String(LogLevel::DEBUG) << std::endl;
    std::cout << LogLevel2String(LogLevel::INFO) << std::endl;
    std::cout << LogLevel2String(LogLevel::WARNING) << std::endl;
    std::cout << LogLevel2String(LogLevel::ERROR) << std::endl;
    std::cout << LogLevel2String(LogLevel::FATAL) << std::endl;
}
int main()
{
    // 2. 測(cè)試枚舉類轉(zhuǎn)字符串類型
    testEnum();
    return 0;
}

namespace LogModule 
{
    // 3. 刷新策略
    // 基類: 策略模式 (Strategy Pattern)
    // 核心思想：將“日志的產(chǎn)生”與“日志的刷新目的地”解耦。
    // 通過定義統(tǒng)一的接口，使得程序可以在運(yùn)行時(shí)動(dòng)態(tài)決定將日志輸出到控制臺(tái)、文件、數(shù)據(jù)庫(kù)或網(wǎng)絡(luò)。
    class LogStrategy
    {
    public:
        // 虛析構(gòu)函數(shù)：在多態(tài)體系中，基類必須擁有虛析構(gòu)函數(shù)。
        // 這樣當(dāng)我們通過基類指針刪除派生類對(duì)象時(shí)，才能確保調(diào)用到子類的析構(gòu)函數(shù)，防止內(nèi)存泄漏。
        virtual ~LogStrategy() = default; // 不在這里析構(gòu)
        // 核心刷新接口：這是一個(gè)純虛函數(shù)。
        // 純虛函數(shù)的核心作用是定義一種“契約”，強(qiáng)制派生類（子類）必須實(shí)現(xiàn)具體的邏輯。
        // 不同的子類可以根據(jù)自己的策略（如 ConsoleStrategy 或 FileStrategy）來(lái)實(shí)現(xiàn)不同的刷新行為。
        virtual void SyncLog(const std::string &message) = 0; // 強(qiáng)制子類對(duì)其進(jìn)行重寫
    };
}

namespace LogModule
{
    // 策略1: 控制臺(tái)日志策略
    // 子類：繼承自策略基類，用于將日志直接刷新到標(biāo)準(zhǔn)輸出（顯示器），常用于本地開發(fā)與調(diào)試 
    class ConsoleLogStrategy: public LogStrategy
    {
    public:
        // 構(gòu)造函數(shù)與析構(gòu)函數(shù)：當(dāng)前策略不涉及復(fù)雜資源申請(qǐng)，故使用默認(rèn)實(shí)現(xiàn)即可 
        ConsoleLogStrategy(){}
        ~ConsoleLogStrategy(){}
        /**
         * @brief 實(shí)現(xiàn)具體的日志同步邏輯——刷新到控制臺(tái)
         * @param message 組裝好的完整日志字符串
         */
        void SyncLog(const std::string &message) override // 檢查重寫的錯(cuò)誤
        {
            // 【核心原理】顯示器（stdout）在多線程環(huán)境下屬于“臨界資源”。
            // 如果不加保護(hù)，多個(gè)線程同時(shí)調(diào)用 std::cout 會(huì)導(dǎo)致各條日志的字符在屏幕上發(fā)生“交織”或亂碼 。
            // 使用自定義的 LockGuard 配合互斥鎖，確保這一系列操作的原子性 。
            LockGuard logGuard(&_mutex);
            std::cout << message << std::endl;
        }
    private:
        // 互斥鎖：專門用于保護(hù)當(dāng)前控制臺(tái)輸出的原子性，防止并發(fā)打印時(shí)消息錯(cuò)亂 
        Mutex _mutex;
    };
}

#include <fstream>
#include <filesystem>

namespace LogModule 
{
    // 定義全局默認(rèn)路徑與文件名常量 
    const static std::string gdefaultlogdir = "./log/";
    const static std::string gdefaultlogfilename = "log.txt";

    // 策略2：文件類日志策略
    // 子類：繼承自策略基類，實(shí)現(xiàn)將日志持久化到磁盤文件的邏輯 
    class FileLogStrategy: public LogStrategy
    {
    public:
        /**
         * @brief 構(gòu)造函數(shù)：初始化日志路徑并確保目錄環(huán)境就緒
         * @param logdir 日志存儲(chǔ)目錄
         * @param logfilename 日志文件名稱
         */
        FileLogStrategy(const std::string &logdir = gdefaultlogdir, const std::string &logfilename = gdefaultlogfilename)
            :_logdir(logdir),
            _logfilename(logfilename)
        {
            // 【重點(diǎn)】構(gòu)造階段即進(jìn)行加鎖保護(hù)。
            // 理由：判斷目錄是否存在并創(chuàng)建目錄屬于“先檢查再執(zhí)行(Check-Then-Act)”模式，
            // 必須保證這一系列操作的原子性，防止多線程同時(shí)創(chuàng)建導(dǎo)致競(jìng)態(tài)沖突 。
            LockGuard lockGuard(&_mutex);
            
            // 使用 C++17 的 <filesystem> 庫(kù)進(jìn)行跨平臺(tái)路徑檢查 
            if(std::filesystem::exists(_logdir))
            {
                return;
            }
            else 
            {
                try 
                {
                    // 遞歸創(chuàng)建目錄（類似于 Linux 命令 mkdir -p），如果路徑中包含多級(jí)不存在的目錄會(huì)一并創(chuàng)建 
                    std::filesystem::create_directories(_logdir);
                } 
                catch (std::filesystem::filesystem_error &e) 
                {
                    // 捕獲文件系統(tǒng)異常（如權(quán)限不足、磁盤空間不足等）并輸出錯(cuò)誤信息 
                    std::cerr << e.what() << std::endl;
                }
            }
        }

        // 析構(gòu)函數(shù)：由于不涉及手動(dòng)管理的堆內(nèi)存或特殊文件句柄（使用局部變量流管理），故使用默認(rèn)實(shí)現(xiàn)
        ~FileLogStrategy(){}

        /**
         * @brief 執(zhí)行具體的日志落盤操作
         * @param message 待寫入的完整日志字符串
         */
        void SyncLog(const std::string &message) override
        {
            // 加鎖保護(hù)：防止多線程同時(shí)寫入同一文件導(dǎo)致內(nèi)容交織（Interleaving）亂碼 
            LockGuard logGuard(&_mutex);
            
            // 構(gòu)造完整的目標(biāo)文件路徑
            std::string target = _logdir + _logfilename;
            
            // 以追加模式(std::ios::app)打開文件流：
            // 核心邏輯：保證每條新日志都寫在文件末尾，不會(huì)覆蓋已有日志內(nèi)容 。
            std::ofstream out(target, std::ios::app); // 追加

            if(!out.is_open()) // 打開文件檢查
            {
                return; // 如果因權(quán)限或路徑問題打開失敗，則放棄本次寫入，防止程序崩潰
            }
            
            // 將消息流式寫入文件，并手動(dòng)添加換行符以符合日志排版規(guī)范 
            out << message << "\n"; // 流式寫入
            
            // 文件流離開作用域或顯式調(diào)用 close 會(huì)自動(dòng)觸發(fā)刷新并關(guān)閉文件
            out.close();
        }

    private:
        std::string _logdir;      // 存儲(chǔ)目錄路徑
        std::string _logfilename; // 存儲(chǔ)文件名稱
        Mutex _mutex;             // 用于保障當(dāng)前策略類實(shí)例在多線程環(huán)境下的線程安全 
    };
}

#include <memory>
#include <sstream>
#include <unistd.h>

namespace LogModule
{
    // 真正要的日志類
    class Logger
    {
    public: 
        Logger()
        {
            UseConsoleLogStrategy();
        }
        ~Logger(){}
        // 顯示器的刷新策略
        void UseConsoleLogStrategy()
        {
            _strategy = std::make_unique<ConsoleLogStrategy>();
        }
        // 文件的刷新策略
        void UseFileLogStrategy()
        {
            _strategy = std::make_unique<FileLogStrategy>();
        }
        // 內(nèi)部類：一條日志
        // 目標(biāo)是把一個(gè)類對(duì)象，變成一個(gè)string
        class LogMessage
        {
        public:
            LogMessage(LogLevel level,std::string &filename,int line,Logger &self)
                :_level(level),
                 _curr_time(GetTimeStamp()),
                 _pid(getpid()),
                 _filename(filename),
                 _line(line),
                 _logger(self)
            {   
                std::stringstream ss; 
                ss << "[" << _curr_time << "] "
                   << "[" << LogLevel2String(_level) << "] "
                   << "[" << _pid << "] "
                   << "[" << _filename << "] "
                   << "[" << _line << "] "
                   << "- ";
                _loginfo = ss.str();
            }
            template<typename T>
            LogMessage &operator << (const T &info) 
            {
                std::stringstream ss;
                ss << info;
                _loginfo += ss.str();
                return  *this;
            }
            ~LogMessage() // RAII風(fēng)格的日志刷新
            {
                if(_logger._strategy)
                {
                    _logger._strategy->SyncLog(_loginfo);
                }
            }
        private:
            LogLevel _level;         // 日志等級(jí)
            std::string _curr_time;  // 當(dāng)前時(shí)間
            pid_t _pid;              // 進(jìn)程pid
            std::string _filename;   // 文件名
            int _line;               // 行號(hào)
            std::string _loginfo;    // 一條完整的日志
            Logger &_logger;         // 外部類的引用
        };
        // LogMessage 對(duì)象打印日志的時(shí)候，故意返回一個(gè)臨時(shí)的 LogMessage對(duì)象
        // 為什么要返回臨時(shí)內(nèi)部類對(duì)象？
        LogMessage operator()(LogLevel level,std::string filename, int line)
        {
            return LogMessage(level,filename,line,*this);
        }
    private:
        std::unique_ptr<LogStrategy> _strategy; // 刷新日志的策略
    };
    Logger logger;
    // 使用宏，包裝我們的日志打印過程，宏有一個(gè)特點(diǎn)，#define A B，B替換成A
    #define LOG(level) logger(level,__FILE__,__LINE__)
    // 動(dòng)態(tài)調(diào)整日志策略
    #define ENABLE_CONSOLE_LOG_STRATEGY() logger.UseConsoleLogStrategy()
    #define ENABLE_FILE_LOG_STRATEGY() logger.UseFileLogStrategy()
}

#ifndef __LOGGER_HPP
#define __LOGGER_HPP
#include <iostream>
#include <cstdio>
#include <string>
#include <ctime>
#include <filesystem> // C++17
#include "Mutex.hpp"
#include <fstream>
#include <sstream>
#include <memory>
#include <unistd.h>
namespace LogModule
{
    // 1.獲取時(shí)間
    std::string GetTimeStamp()
    {
        time_t timestamp = time(nullptr);
        struct tm data_time;
        localtime_r(&timestamp, &data_time);
        char data_time_str[128];
        snprintf(data_time_str, sizeof(data_time_str), "%4d-%02d-%02d %02d:%02d:%02d",
                 data_time.tm_year + 1900, // 從1900開始記的
                 data_time.tm_mon + 1,     // 默認(rèn)月份從0開始記的
                 data_time.tm_mday,
                 data_time.tm_hour,
                 data_time.tm_min,
                 data_time.tm_sec);
        return data_time_str;
    }
    enum LogLevel
    {
        DEBUG,
        INFO,
        WARNING,
        ERROR,
        FATAL
    };
    // 2.日志等級(jí)
    std::string LogLevel2String(LogLevel level)
    {
        switch (level)
        {
        case LogLevel::DEBUG: 
            return "DEBUG";
        case LogLevel::INFO: 
            return "INFO";
        case LogLevel::WARNING: 
            return "WARNING";
        case LogLevel::ERROR: 
            return "ERROR";
        case LogLevel::FATAL: 
            return "FATAL";
        default:
            return "UNKNOWN";
        }
    }
    // 3.日志刷新
    // 基類：策略基類,設(shè)置刷新策略的
    class LogStrategy
    {
    public:
        virtual ~LogStrategy() = default;
        virtual void SyncLog(const std::string &logmessage) = 0;
    };
    // 子類：繼承純虛接口類
    // 策略1
    class ConsoleLogStrategy : public LogStrategy
    {
    public:
        ConsoleLogStrategy(){}
        ~ConsoleLogStrategy(){}
        virtual void SyncLog(const std::string &logmessage) override
        {
            LockGuard lockguard(&_mutex); 
            std::cout<<logmessage<<std::endl;
        }
    private:
        Mutex _mutex;
    };
    static const std::string glogdir = "./log/";
    static const std::string glogfilename = "log.log";
    // 子類：繼承純虛接口類
    // 策略2
    class FileLogStrategy : public LogStrategy
    {
    public:
        FileLogStrategy(const std::string &dir = glogdir,const std::string &filename = glogfilename)
            :_logdir(dir),_logfilename(filename)
        {
            // log/log.txt
            LockGuard lockguard(&_mutex);
            if(std::filesystem::exists(_logdir))
            {
                return;
            }
            else
            {
                try
                {
                    std::filesystem::create_directories(_logdir);
                }
                catch (const std::filesystem::filesystem_error &e)
                {
                    std::cerr<< e.what() <<std::endl;
                }
            }
        }
        ~FileLogStrategy()
        {}
        void SyncLog(const std::string &logmessage) override
        {
            std::string target = _logdir + _logfilename;
            std::ofstream out(target,std::ios::app); // 追加寫入文件
            if(!out.is_open())
            {
                return;
            }
            // 方法1：
            // out.write(logmessage.c_str(), logmessage.size());
            // out.write("\n", 1); // 寫入換行符
            // 方法2：
            // std::string line = logmessage + '\n';
            // out.write(line.c_str(), line.size());
            // 方法3：
            out << logmessage << '\n';
            out.close();
        }
    private:
        std::string _logdir;
        std::string _logfilename; // ./log/XXX.log
        Mutex _mutex;
    };
    // 真正要的日志類
    class Logger
    {
    public: 
        Logger()
        {
            UseConsoleLogStrategy();
        }
        ~Logger(){}
        // 顯示器的刷新策略
        void UseConsoleLogStrategy()
        {
            _strategy = std::make_unique<ConsoleLogStrategy>();
        }
        // 文件的刷新策略
        void UseFileLogStrategy()
        {
            _strategy = std::make_unique<FileLogStrategy>();
        }
        // 內(nèi)部類：一條日志
        // 目標(biāo)是把一個(gè)類對(duì)象，變成一個(gè)string
        class LogMessage
        {
        public:
            LogMessage(LogLevel level,std::string &filename,int line,Logger &self)
                :_level(level),
                 _curr_time(GetTimeStamp()),
                 _pid(getpid()),
                 _filename(filename),
                 _line(line),
                 _logger(self)
            {   
                std::stringstream ss; 
                ss << "[" << _curr_time << "] "
                   << "[" << LogLevel2String(_level) << "] "
                   << "[" << _pid << "] "
                   << "[" << _filename << "] "
                   << "[" << _line << "] "
                   << "- ";
                _loginfo = ss.str();
            }
            template<typename T>
            LogMessage &operator << (const T &info) 
            {
                std::stringstream ss;
                ss << info;
                _loginfo += ss.str();
                return  *this;
            }
            ~LogMessage() // RAII風(fēng)格的日志刷新
            {
                if(_logger._strategy)
                {
                    _logger._strategy->SyncLog(_loginfo);
                }
            }
        private:
            LogLevel _level;         // 日志等級(jí)
            std::string _curr_time;  // 當(dāng)前時(shí)間
            pid_t _pid;              // 進(jìn)程pid
            std::string _filename;   // 文件名
            int _line;               // 行號(hào)
            std::string _loginfo;    // 一條完整的日志
            Logger &_logger;         // 外部類的引用
        };
        // LogMessage 對(duì)象打印日志的時(shí)候，故意返回一個(gè)臨時(shí)的 LogMessage對(duì)象
        // 為什么要返回臨時(shí)內(nèi)部類對(duì)象？
        LogMessage operator()(LogLevel level,std::string filename, int line)
        {
            return LogMessage(level,filename,line,*this);
        }
    private:
        std::unique_ptr<LogStrategy> _strategy; // 刷新日志的策略
    };
    Logger logger;
    // 使用宏，包裝我們的日志打印過程，宏有一個(gè)特點(diǎn)，#define A B，B替換成A
    #define LOG(level) logger(level,__FILE__,__LINE__)
    // 動(dòng)態(tài)調(diào)整日志策略
    #define ENABLE_CONSOLE_LOG_STRATEGY() logger.UseConsoleLogStrategy()
    #define ENABLE_FILE_LOG_STRATEGY() logger.UseFileLogStrategy()
}
#endif

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include "Logger.hpp" // 我們實(shí)現(xiàn)的日志頭文件
using namespace LogModule;
// 多線程測(cè)試函數(shù)：10個(gè)線程同時(shí)打印日志
void *thread_log_test(void *arg)
{
    char *thread_name = (char *)arg;
    for (int i = 0; i < 5; i++)
    {
        LOG(LogLevel::INFO) << thread_name << " 執(zhí)行日志打印, 循環(huán)次數(shù): " << i;
        usleep(1000);
    }
    return nullptr;
}
int main()
{
    // 1. 基礎(chǔ)控制臺(tái)日志輸出
    std::cout << "===== 控制臺(tái)日志測(cè)試 =====" << std::endl;
    ENABLE_CONSOLE_LOG_STRATEGY();
    LOG(LogLevel::DEBUG) << "這是DEBUG調(diào)試日志, 數(shù)值: " << 3.14159;
    LOG(LogLevel::INFO) << "這是INFO常規(guī)日志, 服務(wù)啟動(dòng)成功";
    LOG(LogLevel::WARNING) << "這是WARNING警告日志, 配置缺失, 使用默認(rèn)值";
    LOG(LogLevel::ERROR) << "這是ERROR錯(cuò)誤日志, 文件讀取失敗";
    LOG(LogLevel::FATAL) << "這是FATAL致命日志, 內(nèi)存耗盡, 服務(wù)退出";
    // 2. 切換為文件日志策略
    std::cout << "\n===== 文件日志測(cè)試 =====" << std::endl;
    ENABLE_FILE_LOG_STRATEGY();
    LOG(LogLevel::INFO) << "切換為文件日志策略, 日志將持久化到./log/log.txt";
    LOG(LogLevel::DEBUG) << "文件日志測(cè)試, 支持鏈?zhǔn)狡唇? " << "字符串 " << 1234 << " 浮點(diǎn)數(shù) " << 2.71828;
    // 3. 多線程線程安全測(cè)試
    std::cout << "\n===== 多線程日志測(cè)試 =====" << std::endl;
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, nullptr, thread_log_test, (void *)"thread-1");
    pthread_create(&t2, nullptr, thread_log_test, (void *)"thread-2");
    pthread_create(&t3, nullptr, thread_log_test, (void *)"thread-3");
    pthread_create(&t4, nullptr, thread_log_test, (void *)"thread-4");
    // 等待所有線程執(zhí)行完畢
    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);
    pthread_join(t4, nullptr);
    LOG(LogLevel::INFO) << "多線程日志測(cè)試完成, 無(wú)亂序、無(wú)交錯(cuò)";
    return 0;
}