当前位置：首页 > article >正文

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

article 2024/9/22 4:05:33

感谢前人的总结，没有他们，我不会这么快学完･ω･

知识点备忘录
操作记录

知识点备忘录

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

基类需要什么？

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

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

操作记录

继续在log.h中添加类
基类和两个派生类
相比较上一篇，改动在基类派生类和调用类Logger中

#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
		//产生日志事件的线程ID，产生日志事件的协程ID，日志事件的时间戳
		, uint32_t thread_id, uint32_t fiber_id, uint64_t time);

	//成员函数
	//1.返回日志发生的源文件名
	const char* getFile() const {return m_file;}
	//2.返回日志发生的代码行号
	int32_t getLine() const {return m_line;}
	//3.返回日志事件发生的事件，单位ms
	uint32_t getElapse() const {return m_elapse;}
	//4.返回产生日志事件的线程ID
	uint32_t getThreadId() const {return m_threadId;}
	//5.返回产生日志事件的协程ID
	uint32_t getFiberId() const {return m_fiberId;}
	//6.返回日志事件的时间戳
	uint64_t getTime() const {return m_time;}
	//7.返回日志事件的级别
	LogLevel::Level getLevel() const {return m_level;}

private:
	const char* m_file = nullptr;//表示日志事件的源文件名
	int32_t m_line = 0;//表示在源文件中的行号
	uint32_t m_elapse = 0;//表示程序启动到现在的ms
	uint32_t m_threadId = 0;//表示产生日志事件的线程ID
	uint32_t m_fiberId = 0;//表示产生日志事件的协程ID
	uint64_t m_time;//表示日志事件产生的时间戳
	LogLevel::Level m_level;//表示日志级别
};

//日志构造函数的实现
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){
}

//基类
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;
	//override表示重写父类方法，输出
	void log(LogEvent::ptr event) override;
};
//实现log
void StdoutLogAppender::log(LogEvent::ptr event){
	std::cout
		<< event->getTime() << " "
		<< event->getThreadId() << " "
		<< event->getFiberId() << " "
		<< "["
		<< event->getLevel()
		<< "] "
		<< event->getFile() << ":" << event->getLine() << " "
		<< "输出到控制台的信息:"
		<< std::endl;
}

//派生类，输出到磁盘文件
class FileLogAppender : public LogAppender{
public:
	typedef std::shared_ptr<FileLogAppender> ptr;
	//文件操作
	FileLogAppender(const std::string& filename);
	//override重写父类方法，输出
	void log(LogEvent::ptr event) override;
private:
	std::string m_filename;
};
FileLogAppender::FileLogAppender(const std::string& filename)
	:m_filename(filename){
}
void FileLogAppender::log(LogEvent::ptr event){
	std::cout << "输出到文件" << m_filename << std::endl;
}
//日志器
class Logger{
public:
	//定义智能指针，操作Logger的对象
	typedef std::shared_ptr<Logger> ptr;
	//构造函数
	//未指定则给个默认名称root，这里引用生为了避免不必要的拷贝操作，使用const是为了规定这个名称在内部不会被改变
	Logger(const std::string& name = "root");

	//成员函数
	const std::string& getName() const {return m_name;}
	LogLevel::Level getLevel() const {return m_level;}
	void setLevel(LogLevel::Level val) {m_level = val;}

	//定义一个输出日志的方法，传入想要查看的最大日志级别
	void log(LogEvent::ptr event);

	//加一个适配器
	void addAppender(LogAppender::ptr appender);
	//删一个适配器
	void delAppender(LogAppender::ptr appender);
private:
	//m_开头生一个私有变量的规范
	std::string m_name;
	//日志器能输出的最大日志级别
	LogLevel::Level m_level;
	//Appender集合
	std::list<LogAppender::ptr> m_appenders;
};
//实现构造函数
Logger::Logger(const std::string& name)
	:m_name(name)
	//这里指定日志器一个自身默认级别是DEBUG
	,m_level(LogLevel::DEBUG){
}

//实现成员函数addAppender
void Logger::addAppender(LogAppender::ptr appender){
	m_appenders.push_back(appender);
}
//实现成员函数delAppender
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;
		}
	}
}
//实现成员函数log()即输出方法
void Logger::log(LogEvent::ptr event){
	if(event->getLevel() >= m_level){
		for(auto& i : m_appenders){
			i->log(event);
		}
	}
}
#endif

测试文件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;
}