【日志系统】
文章目录
-
- @[TOC](文章目录)
- 一、项目介绍
- 二、模式设计原则
- 三、设计模式
-
- 1.单例模式
- 2.工厂模式
- 3.建造者模式
- 4.代理模式
- 四、等级模块
- 五、信息模块
- 六、格式化模块
- 七、落地模块
- 八、日志器模块
- 九、异步线程模块
- 十、日志器创建模块
文章目录
-
- @[TOC](文章目录)
- 一、项目介绍
- 二、模式设计原则
- 三、设计模式
-
- 1.单例模式
- 2.工厂模式
- 3.建造者模式
- 4.代理模式
- 四、等级模块
- 五、信息模块
- 六、格式化模块
- 七、落地模块
- 八、日志器模块
- 九、异步线程模块
- 十、日志器创建模块
一、项目介绍
多功能的日志系统,支持多线程并发写日志,同步和异步输出方式,不同的输出位置(标准输出,指定文件和滚动文件),输出多级别日志.
按模块分为:等级,信息,格式化,信息落地,日志器,日志器管理,异步线程7个模块.
日志系统的作用,日志系统可以帮助定位bug,分析问题.比如上线产品不能通过调试处理bug时,对于分布式,多线程,多进程代码,很难通过调试定位bug时,帮助首次接触代码的信任理解代码运行流程,这些场景日志系统都能起到很大作用.
二、模式设计原则
1.单一原则:类的职责要单一,只做一件事.
2.里氏替换原则:不要破坏继承关系,父类出现的地方,子类就可以出现.
3.依赖倒置原则: 高层模块不直接依赖低层模块,两者要依赖其抽象.
4.迪米特法则:尽量减少对象之间交互.降低耦合度
5.接口隔离原则,对象之间依赖关系建立在最小接口上,不暴漏不必要的接口.
6.开闭原则,关闭修改,开放扩展.
三、设计模式
1.单例模式
即一个类只能创建一个全局对象,被整个系统共享;单例模式细分为懒汉模式和饿汉模式,懒汉模式使用时才常见对象,适用于单例对象加载耗时,耗资源的场景.饿汉模式程序启动即创建对象.c++11之前有避免被多线程竞争的优点.
2.工厂模式
使用场景
需要根据不同条件创建不同对象时,使用工厂类可以实现.
当对象创建过于复杂,需要封装创建过程时用工厂类封装,隐藏创建过程,暴漏接口,时代码更加简洁;
需要动态切换对象创建方式,使用工厂模式通过切换工厂类创建不同对象,实现灵活的切换对象的创建方式.
需要集中管理对象的创建,使用工厂类集中管理对象的创建,修改时,只需要修改工厂类即可,方便维护.
简单工厂
集中管理所有对象的创建,通过条件判断创建不同的对象.缺点是没有遵循开闭原则,扩展时需要修改工厂类代码.
class Fruit
{
public:
virtual void Show() = 0;
};
class Apple: public Fruit
{
public:
void Show()override
{
std::cout << "Apple" << std::endl;
}
};
class Banana : public Fruit
{
public:
void Show()override
{
std::cout << "Banana" << std::endl;
}
};
class FruitFactory
{
public:
static std::shared_ptr<Fruit> Create(const std::string name)
{
if (name == "Banana")
{
return std::make_shared<Banana>();
}
else
{
return std::make_shared<Apple>();
}
}
};
方法模式
创建基类工厂,不同子类工厂创建不同对象,遵循了开闭原则,只需增加子类工厂,就能扩展对象的创建.
class Fruit
{
public:
virtual void Show() = 0;
};
class Apple: public Fruit
{
public:
void Show()override
{
std::cout << "Apple" << std::endl;
}
};
class Banana : public Fruit
{
public:
void Show()override
{
std::cout << "Banana" << std::endl;
}
};
//工厂基类
class Factory
{
public:
virtual std::shared_ptr<Fruit> Create() = 0;
};
class AppleFactory: public Factory
{
public:
std::shared_ptr<Fruit> Create()override
{
return std::make_shared<Apple>();
}
};
class BananaFactory:public Factory
{
public:
std::shared_ptr<Fruit> Create()override
{
return std::make_shared<Banana>();
}
};
抽象工厂
创建基类工厂,基类工厂定义了不同产品族的创建方法,产品族是一组有依赖关系的类,当增加新的产品族时,只需要在基类工厂添加抽象方法,在增加子类工厂即可.最后用超级工厂通过条件判断创建不同的工厂对象,用工厂对象创建产品族.
//抽象工厂模式
//创建动物类家族
class Animal
{
public:
virtual void name() = 0;
};
class Dog : public Animal
{
public:
void name()override
{
std::cout << "dog" << std::endl;
}
};
class Monkey : public Animal
{
public:
void name()override
{
std::cout << "monkey" << std::endl;
}
};
//超级工厂
class Factory
{
public:
virtual std::shared_ptr<Fruit> FruitCreate(const std::string name) = 0;
virtual std::shared_ptr<Animal> AnimalCreate(const std::string name) = 0;
};
//创建水果类 / 动物类简单工厂
class FruitFactory: public Factory
{
public:
virtual std::shared_ptr<Fruit> FruitCreate(const std::string name)
{
if (name == "Banana")
return std::make_shared<Banana>();
else
return std::make_shared<Apple>();
}
virtual std::shared_ptr<Animal> AnimalCreate(const std::string name)
{
return std::shared_ptr<Animal>();
}
};
class AnimalFactory : public Factory
{
public:
std::shared_ptr<Fruit> FruitCreate(const std::string name)override
{
return std::shared_ptr<Fruit>();
}
std::shared_ptr<Animal> AnimalCreate(const std::string name)override
{
if (name == "Dog")
return std::make_shared<Dog>();
else
return std::make_shared<Monkey>();
}
};
//创建简单模式工厂构建类
class FactoryBuild
{
public:
static std::shared_ptr<Factory> FactoryCreate(const std::string name)
{
if (name == "Animal")
return std::make_shared<AnimalFactory>();
else
return std::make_shared<FruitFactory>();
}
};
3.建造者模式
建造者模式分步骤创建复杂对象的解决方案，隐藏了对象的创建细节。对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式由指导者,建造者,具体建造者组成：
建造者模式常用于创建复杂对象，可以在构建过程中灵活地修改、替换或增加创建步骤，而不需要修改已有的代码。
//抽象类
class Computer
{
public:
void SetMainBoard(const std::string board) { _board = board; }
void SetDisplay(const std::string display) { _display = display; }
void Show()
{
std::string computer = "computer:\n";
computer += "\tboard" + _board + "\n";
computer += "\tdisplay" + _display + "\n";
computer += "\tos" + _os + "\n";
std::cout << computer << std::endl;
}
virtual void SetOs() = 0;
protected:
std::string _board;
std::string _display;
std::string _os;
};
//具体类
class Linux : public Computer
{
public:
void SetOs()
{
_os = "centos 7";
}
};
//抽象创建类
class Build
{
public:
virtual void BuildSetMainBoard(const std::string board) = 0;
virtual void BuildSetDisplay(const std::string display) = 0;
virtual void BuildSetOs() = 0;
virtual std::shared_ptr<Computer> BuildRet() = 0;
};
//具体创建类
class LinuxBuild : public Build
{
public:
LinuxBuild() :_computer(new Linux) {}
void BuildSetMainBoard(const std::string board)
{
_computer->SetMainBoard(board);
}
void BuildSetDisplay(const std::string display)
{
_computer->SetDisplay(display);
}
void BuildSetOs()
{
_computer->SetOs();
}
std::shared_ptr<Computer> BuildRet()
{
return _computer;
}
private:
std::shared_ptr<Computer> _computer;
};
//指挥类
class Director
{
public:
Director(Build* build) :_build(build) {}
void Construct(const std::string board, const std::string display)
{
_build->BuildSetDisplay(display);
_build->BuildSetMainBoard(board);
_build->BuildSetOs();
}
private:
std::shared_ptr<Build> _build;
};
4.代理模式
代理模式可以通过引入代理对象，为目标对象提供额外的功能或控制访问。它能够在不改变目标对象的情况下，灵活地扩展和增强对象的行为。
//代理模式
//抽象类
class Abstract
{
public:
virtual void headler()=0;
};
//真实对象
class Real: public Abstract
{
public:
void headler()override
{
std::cout << "方法处理" << std::endl;
}
};
//代理对象
class Agent : public Abstract
{
public:
void headler()override
{
std::cout << "功能加强" << std::endl;
std::cout << "对象隐藏" << std::endl;
std::cout << "访问控制" << std::endl;
_real.headler();
}
private:
Real _real;
};
四、等级模块
作用:对日志信息做等级划分,以便于控制日志输出,提供等级枚举转字符串功能.
#pragma once
/*
日志等级模块
1.定义日志等级
2.提供日志等级枚举转字符串功能
*/
namespace logspace
{
class LogLevel
{
public:
//日志等级
enum class Level
{
/*未知,调试,提示,警告,错误,致命,关闭*/
UNKNOW=0,
DEBUG,
INFO,
ERROR,
WARN,
FATAL,
OFF,
};
//等级转字符串
static const char* ToString(LogLevel::Level val)
{
if(val==Level::DEBUG)return"DEBUG";
else if(val==Level::ERROR)return"ERROR";
else if(val==Level::FATAL)return"FATAL";
else if(val==Level::INFO)return "INFO";
else if(val==Level::OFF)return "OFF";
return "UNKNOW";
}
};
}
五、信息模块
作用:封装以及格式化存储日志信息
#pragma once
/*
日志信息模块
格式存储日志信息
*/
#include六、格式化模块
格式化信息就依次从消息体中取出需要的信息进行链接,这就需要将不同的信息字段分开实现.以便组织,考虑使用多态实现,这样也方便扩展格式化新的信息字段.
实现思想:使用多态实现不同信息字段的格式化,使用格式化字符与格式化子类形成映射关系,利用格式化字符串组织格式化子类对象到容器中,遍历容器中的对象,将信息格式化并连接.
#pragma once
/*
格式化模块
功能:
提供格式化消息灵活序列化方式,可控制输出字段顺序和字段内容
实现思想:
1.%d{%H:%M:%s}(时间),%c(日志器名字),%t(线程id),%T(制表符),%m(有效载荷),%n(回车),[](其他字符)等单个
项目的序列化类
2.通过诸如[%d{%H:%M:%s}][%c][%t]%T%m%n样式的格式字符串,将不同的单个项目的序列化类按格式化字符顺序组织在数组中,
遍历数组将格式化消息组织成一个序列化字符串.
*/
#include "message.hpp"
#include"level.hpp"
#include七、落地模块
使用多态实现不同落地方式的设计思想:因为需要实现多种落地方式,他们功能一样,只是实现方法不同,所以选择使用C++中多态的特性实现不同落地方式,这样实现也方便后续扩展新的落地方式.
**使用简单工厂模式管理对象的设计思想:**使用不同落地方式,使用时需要创建不同的子类对象,如果后期子类对象的创建方式发生变化,需要修改所有创建该对象的代码,非常不方便,使用简单工厂模式集中管理对象的创建,如果发生变化只需要修改工厂类即可.
由于需要根据类型创建不同的子类对象,而且创建不同的子类对象,需要传递的初始化参数也不同,所以选择使用了模板和可变参数模板来适应不同的传参方式.
#pragma once
/*
日志落地模块
功能:提供多种落地模式,可根据类型灵活选择
实现思想:提过一个落地抽象类,重写多个子类,实现不同落地模式.
通过向工厂类传递不同的类型,建造构建不同的子类对象.
*/
#include八、日志器模块
设计思想:考虑到日志器分为异步日志器和同步日志器两种,且日志器中的日志输出控制,功能相同,只需要实现不同的落地模式即可,所以使用多态实现,这样也方便扩展新的日志器.
异步日志器设计思想:程序在单线程的情况下,如果因为磁盘内存不足或者没有显示器资源就会造成使用日志器的程序被阻塞,异步输出模式,主线程激昂信息保存在内存中,由其他线程实施落地可避免这一情况.
#pragma once
/*
日志器模块
功能:统一管理日志的格式化,落地,日志等级,组织日志的输出.
实现思想:抽象一个基类,基类实现日志的格式化,等级控制,落地方式,子类实现落地模式是异步还是同步
同步是由日志器直接落地,异步日志是将日志暂存到内存缓冲区,创建另一个线程将内存缓冲区异步落地,避免
因落地文件未就绪或者其他原因导致主线程被阻塞.
*/
#include九、异步线程模块
缓冲区的设计思想:为了避免了重复申请和释放空间资源,缓冲区类采用固定大小的字符数组作为缓冲区,使用两个指针来控制缓冲区可用区间.
异步线程模块设计思想:异步线程模块主要完成异步从缓冲区提取数据进行落地输出的操作,为了避免重复的拷贝造作,管理两个缓冲区,一个生产,一个消费,当生产缓冲区有数据时就将交换生产和消费缓冲区的数组以及可用区间指针.
生产缓冲区是主线和异步线程的临界资源,需要维护他们的同步互斥关系,俩个线程不能同时访问缓冲区,当缓冲区满的时候,主线程主动释放锁,阻塞等待,当缓冲区没有信息时,异步线程就主动释放锁,阻塞等待.
#pragma once
/*
异步模块
功能:控制生产/消费缓冲区,创建异步线程将消费缓冲区日志落地.
实现思想:管理生产和消费两个缓冲区,主线程将消息添加到生产缓冲区,子线程将
指向消费缓冲区的有效信息头尾的指针与生产缓冲区交换,然后将日志信息落地
*/
#include"build.hpp"
#include"buffer.hpp"
#include十、日志器创建模块
考虑到日志器的构建需要先构建日志等级对象,信息对象,格式化对象,落地方式对象,比较复杂,所以考虑使用建造者模式构建日志器对象.
#pragma once
/*
建造模块
功能:提供不同异步和同步日志器以及全局日志器的构建方法
实现思想:使用建造者模式,基类提供日志器类型,日志器名字,日志等级,格式化器,落地方式,异步工作模式构造方法
子类提供日志器对象构造.
全局对象构建模块
功能:构建全局对象,可管理多个全局对象,可添加,根据日志器名字获取日志器全局对象,提供默认日志器全局对象
实现思想:使用单例懒汉模式,使用时创建全局对象,对象中管理默认日志器对象,和日志器数组,提供增加日志器,和获取日志器接口.
通过单例类扩展出全局日志器构建模块.
*/
#include