【项目二】C++高性能服务器开发——日志系统(适配器)

知识点备忘录

数据除了打印到控制台还需要打印到本地磁盘和远程日志，所以需要适配器来干这活
涉及多个适配器，打印到控制台的、打印到本地磁盘的，考虑到未来的扩展性，还需要一个实现多态的适配器
所以是类继承类的写法，基类和派生类

基类需要什么？

基类的主要作用是定义所有日志适配器的统一接口，这样派生类（输出到控制台、磁盘和远程日志）可以通过继承这个基类来实现具体的日志输出功能。这样的话，当需要扩展新的日志输出方式的时候，只需要添加一个新的派生类即可。

1. 基类需要一个智能指针，来管理基类对象
2. 基类需要一个虚函数log()，实现多态性。必须是一个纯虚函数，定义了日志输出的接口，但不实现具体逻辑。由继承基类的派生类来实现这个函数！！为什么必须是纯虚函数？因为纯虚函数强制所有派生类实现日志输出的具体逻辑。这样无论是输出到控制台、磁盘、远程服务器，都需要派生类提供自己的实现。
3. 基类需要一个虚析构函数LogAppender()，因为虚析构函数有一个重要的作用——确保通过基类指针删除派生类对象时，能够正确调用派生类的析构函数。简单点来说：如果基类的析构函数不是虚函数，当通过基类指针删除一个派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数，这会导致派生类的资源得不到释放，造成 内存泄漏 或 资源泄漏。

操作记录

继续在log.h中添加类与接口，log.cc中具体实现
基类和两个派生类
相比较上一篇，改动在基类派生类和调用类Logger中
以下是log.h的代码

#ifndef __SYLAR_LOG_H_
#define __SYLAR_LOG_H_

#include <string>
#include <stdint.h>
#include <memory>
#include <iostream>
#include <list>

//日志级别
class LogLevel{
public:
    enum Level{
        UNKNOW = 0,//未知
        DEBUG = 1,//调试
        INFO = 2,//普通
        WARN = 3,//警告
        ERROR = 4,//错误
        FATAL = 5//灾难
    };
};

//日志事件
class LogEvent{
public:
    typedef std::shared_ptr<LogEvent> ptr;
    LogEvent(LogLevel::Level level, const char* file, int32_t line, uint32_t elapse,
             uint32_t thread_id, uint32_t fiber_id, uint64_t time);

    const char* getFile() const;
    int32_t getLine() const;
    uint32_t getElapse() const;
    uint32_t getThreadId() const;
    uint32_t getFiberId() const;
    uint64_t getTime() const;
    LogLevel::Level getLevel() const;

private:
    const char* m_file = nullptr;
    int32_t m_line = 0;
    uint32_t m_elapse = 0;
    uint32_t m_threadId = 0;
    uint32_t m_fiberId = 0;
    uint64_t m_time;
    LogLevel::Level m_level;
};

//日志输出器基类
class LogAppender{
public:
    typedef std::shared_ptr<LogAppender> ptr;
    virtual ~LogAppender() {}
    virtual void log(LogEvent::ptr event) = 0;
};

//控制台日志输出器
class StdoutLogAppender : public LogAppender{
public:
    typedef std::shared_ptr<StdoutLogAppender> ptr;
    void log(LogEvent::ptr event) override;
};

//文件日志输出器
class FileLogAppender : public LogAppender{
public:
    typedef std::shared_ptr<FileLogAppender> ptr;
    FileLogAppender(const std::string& filename);
    void log(LogEvent::ptr event) override;
private:
    std::string m_filename;
};

//日志器
class Logger{
public:
    typedef std::shared_ptr<Logger> ptr;
    Logger(const std::string& name = "root");

    const std::string& getName() const;
    LogLevel::Level getLevel() const;
    void setLevel(LogLevel::Level val);
    void log(LogEvent::ptr event);
    void addAppender(LogAppender::ptr appender);
    void delAppender(LogAppender::ptr appender);

private:
    std::string m_name;
    LogLevel::Level m_level;
    std::list<LogAppender::ptr> m_appenders;
};

#endif

log.cc文件如下：

#include "log.h"
#include <iostream>

//日志事件实现
LogEvent::LogEvent(LogLevel::Level level, const char* file, int32_t line, uint32_t elapse,
                   uint32_t thread_id, uint32_t fiber_id, uint64_t time)
    :m_level(level), m_file(file), m_line(line), m_elapse(elapse),
     m_threadId(thread_id), m_fiberId(fiber_id), m_time(time) {}

const char* LogEvent::getFile() const { return m_file; }
int32_t LogEvent::getLine() const { return m_line; }
uint32_t LogEvent::getElapse() const { return m_elapse; }
uint32_t LogEvent::getThreadId() const { return m_threadId; }
uint32_t LogEvent::getFiberId() const { return m_fiberId; }
uint64_t LogEvent::getTime() const { return m_time; }
LogLevel::Level LogEvent::getLevel() const { return m_level; }

// StdoutLogAppender 实现
void StdoutLogAppender::log(LogEvent::ptr event) {
    std::cout << event->getTime() << " "
              << event->getThreadId() << " "
              << event->getFiberId() << " ["
              << event->getLevel() << "] "
              << event->getFile() << ":" << event->getLine() << " "
              << "输出到控制台的信息:" << std::endl;
}

// FileLogAppender 实现
FileLogAppender::FileLogAppender(const std::string& filename) 
    : m_filename(filename) {}

void FileLogAppender::log(LogEvent::ptr event) {
    std::cout << "输出到文件 " << m_filename << std::endl;
}

// Logger 实现
Logger::Logger(const std::string& name)
    : m_name(name), m_level(LogLevel::DEBUG) {}

const std::string& Logger::getName() const { return m_name; }
LogLevel::Level Logger::getLevel() const { return m_level; }
void Logger::setLevel(LogLevel::Level val) { m_level = val; }

void Logger::addAppender(LogAppender::ptr appender) {
    m_appenders.push_back(appender);
}

void Logger::delAppender(LogAppender::ptr appender) {
    for(auto it = m_appenders.begin(); it != m_appenders.end(); ++it) {
        if(*it == appender) {
            m_appenders.erase(it);
            break;
        }
    }
}

void Logger::log(LogEvent::ptr event) {
    if(event->getLevel() >= m_level) {
        for(auto& i : m_appenders) {
            i->log(event);
        }
    }
}

测试文件log_test.cpp，和上一篇是一个文件，代码覆盖了

#include "log.h"
//测试
int main(int argc,char** argv){
    LogEvent::ptr event(new LogEvent(
        LogLevel::INFO,		//日志级别
        "log.txt", 			//文件名称
        1, 					//行号
        1234567, 			//程序运行时间
        2,					//线程ID
        3, 					//协程ID
        time(0)				//当前时间
    ));
    
    Logger::ptr lg(new Logger("XYZ"));
    //添加控制台输出适配器
    StdoutLogAppender::ptr stdApd(new StdoutLogAppender());
    lg->addAppender(stdApd);
    //添加控制台输出适配器
    FileLogAppender::ptr fileApd(new FileLogAppender("log.txt"));
    lg->addAppender(fileApd);
    //输出
    lg->log(event); 
    return 0;
}

编译代码

g++ log.cc log_test.cpp -o log_test

运行代码

./log_test

输出：