日志项目1

文章目录

  • 【C++ - 基于多设计模式下的同步&异步日志系统】
    • 项目介绍 + 前置技术
      • 1. 项目介绍
      • 2. 开发环境
      • 3. 核心技术
      • 4. 环境搭建
      • 5. 日志系统介绍
        • 5.1 为什么需要日志系统
        • 5.2 日志系统技术实现
          • 5.2.1 同步写日志
          • 5.2.2 异步写日志
      • 6. 前置技术补充
        • 6.1 不定参函数
          • 6.1.1 不定参宏函数
          • 6.1.2 C风格不定参函数
          • 6.1.3 C++风格不定参函数
        • 6.2 设计模式
          • 6.2.1 六大原则
          • 6.2.2 单例模式
          • 6.2.3 工厂模式
          • 6.2.4 建造者模式
          • 6.2.5 代理模式

【C++ - 基于多设计模式下的同步&异步日志系统】

项目介绍 + 前置技术

1. 项目介绍

本项目主要实现一个日志系统, 其主要支持以下功能:

  • 支持多级别日志消息
  • 支持同步日志和异步日志
  • 支持可靠写入日志到控制台、文件以及滚动文件中
  • 支持多线程程序并发写日志
  • 支持扩展不同的日志落地目标地

2. 开发环境

  • CentOS 7
  • vscode/vim
  • g++/gdb
  • Makefile

3. 核心技术

  • 类层次设计(继承和多态的应用)
  • C++11(多线程、auto、智能指针、右值引用等)
  • 双缓冲区
  • 生产消费模型
  • 多线程
  • 设计模式(单例、工厂、代理、模板等)

4. 环境搭建

本项目不依赖其他任何第三方库, 只需要安装好CentOS/Ubuntu + vscode/vim环境即可开发。

5. 日志系统介绍

5.1 为什么需要日志系统
  • 生产环境的产品为了保证其稳定性及安全性是不允许开发人员附加调试器去排查问题, 可以借助日志系统来打印一些日志帮助开发人员解决问题

  • 上线客户端的产品出现bug无法复现并解决, 可以借助日志系统打印日志并上传到服务端帮助开发人员进行分析

  • 对于一些高频操作(如定时器、心跳包)在少量调试次数下可能无法触发我们想要的行为,通过断点的暂停方式,我们不得不重复操作几十次、上百次甚至更多,导致排查问题效率是非常低下, 可以借助打印日志的方式查问题

  • 在分布式、多线程/多进程代码中, 出现bug比较难以定位, 可以借助日志系统打印log帮助定位bug

  • 帮助首次接触项目代码的新开发人员理解代码的运行流程

5.2 日志系统技术实现

日志系统的技术实现主要包括三种类型:

  • 利用printf、std::cout等输出函数将日志信息打印到控制台

  • 对于大型商业化项目, 为了方便排查问题,我们一般会将日志输出到文件或者是数据库系统方便查询和分析日志, 主要分为同步日志和异步日志方式

    • 同步写日志
    • 异步写日志
5.2.1 同步写日志

同步日志是指当输出日志时,必须等待日志输出语句执行完毕后,才能执行后面的业务逻辑语句,日志输出语句与程序的业务逻辑语句将在同一个线程运行。每次调用一次打印日志API就对应一次系统调用write写日志文件

在这里插入图片描述

在高并发场景下,随着日志数量不断增加,同步日志系统容易产生系统瓶颈:

  • 一方面,大量的日志打印陷入等量的write系统调用,有一定系统开销
  • 另一方面,使得打印日志的进程附带了大量同步的磁盘IO,影响程序性能
5.2.2 异步写日志

异步日志是指在进行日志输出时,日志输出语句与业务逻辑语句并不是在同一个线程中运行,而是有专门的线程用于进行日志输出操作。业务线程只需要将日志放到一个内存缓冲区中不用等待即可继续执行后续业务逻辑(作为日志的生产者),而日志的落地操作交给单独的日志线程去完成(作为日志的消费者), 这是一个典型的生产-消费模型

在这里插入图片描述

这样做的好处是即使日志没有真的地完成输出也不会影响程序的主业务,可以提高程序的性能:

  • 主线程调用日志打印接口成为非阻塞操作
  • 同步的磁盘IO从主线程中剥离出来交给单独的线程完成

6. 前置技术补充

6.1 不定参函数

在初学C语言的时候,我们都用过printf函数进行打印。其中printf函数就是一个不定参函数,在函数内部可以根据格式化字符串中格式化字符分别获取不同的参数进行数据的格式化。

而这种不定参函数在实际的使用中也非常多见,在这里简单做一介绍:

6.1.1 不定参宏函数
#include<cstdio>// __FILE__: 文件名  __LINE__: 行号
// ##: 一旦不定参数为空,取消前面的 ,
#define LOG(fmt,...) printf("[%s:%d] " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__) int main()
{LOG("%s-%s","hello","比特");LOG("比特");
}

在这里插入图片描述

6.1.2 C风格不定参函数
#include<cstdio>
#include<cstdarg>
#include<cstdlib>// C语言中不定参函数的使用, 不定参数据的访问
void PrintNum(int count,...)
{va_list ap;va_start(ap,count); // 获取指定参数的起始地址, 这里是让ap指向count参数之后的第一个参数的起始地址for(int i=0;i<count;++i){int num=va_arg(ap,int);printf("param[%d]:%d\n",i,num);}va_end(ap);  // 将ap指针置空
}int main()
{PrintNum(3,1,2,4);PrintNum(4,1,2,3,88);
}

在这里插入图片描述

模拟实现printf

#include<cstdio>
#include<cstdarg>
#include<cstdlib>void myprintf(const char*fmt,...)   // 模拟实现printf
{// int vasprintf(char **strp, const char *fmt, va_list ap);va_list ap;va_start(ap,fmt);char*res;int len=vasprintf(&res,fmt,ap);    // 通过ap指针根据fmt组织好数据后放入res中if(len!=-1){printf(res);free(res);}va_end(ap);
}
int main()
{myprintf("%s-%d\n","比特", 666);myprintf("%s-%f\n","比特", 6.0);return 0;
}

在这里插入图片描述

6.1.3 C++风格不定参函数
// C++风格的不定参数使用void xprintf()
{std::cout<<std::endl;
}
template<class T, class ...Args>
void xprintf(const T&val, Args &&...args)  // 万能引用 + 完美转发
{std::cout<<val<<" ";if((sizeof...(args)) > 0)xprintf(std::forward<Args>(args)...);elsexprintf();
}int main()
{xprintf();xprintf("比特");xprintf("比特", 666);return 0;
}

在这里插入图片描述

6.2 设计模式

设计模式是前辈们对代码开发经验的总结,是解决特定问题的一系列套路。它不是语法规定,而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

6.2.1 六大原则
  • 单一职责原则(Single Responsibility Principle);

    • 类的职责应该单一,一个方法只做一件事。职责划分清晰了,每次改动到最小单位的方法或类。
    • 使用建议:两个完全不一样的功能不应该放一个类中,一个类中应该是一组相关性很高的函数、数据的封装
    • 用例:网络聊天:网络通信 & 聊天,应该分割成为网络通信类 & 聊天类
  • 开闭原则(Open Closed Principle);

    • 对扩展开放,对修改封闭
    • 使用建议:对软件实体的改动,最好用扩展而非修改的方式。
    • 用例:超时卖货:商品价格—不是修改商品的原来价格,而是新增促销价格。
  • 里氏替换原则(Liskov Substitution Principle);

    • 通俗点讲,就是只要父类能出现的地方,子类就可以出现,而且替换为子类也不会产生任何错误或异常。
    • 在继承类时,务必重写父类中所有的方法,尤其需要注意父类的protected方法,子类尽量不要暴露自己的public方法供外界调用。
    • 使用建议:子类必须完全实现父类的方法,孩子类可以有自己的个性。覆盖或实现父类的方法时,输入参数可以被放大,输出可以缩小
    • 用例:跑步运动员类-会跑步,子类长跑运动员-会跑步且擅长长跑, 子类短跑运动员-会跑步且擅长短跑
  • 依赖倒置原则(Dependence Inversion Principle)。

    • 高层模块不应该依赖低层模块,两者都应该依赖其抽象. 不可分割的原子逻辑就是低层模式,原子逻辑组装成的就是高层模块。
    • 模块间依赖通过抽象(接口)发生,具体类之间不直接依赖
    • 使用建议:每个类都尽量有抽象类,任何类都不应该从具体类派生。尽量不要重写基类的方法。结合里氏替换原则使用。
    • 用例:奔驰车司机类–只能开奔驰; 司机类 – 给什么车,就开什么车; 开车的人:司机–依赖于抽象
  • 迪米特法则(Law of Demeter),又叫“最少知道法则”;

    • 尽量减少对象之间的交互,从而减小类之间的耦合。一个对象应该对其他对象有最少的了解。对类的低耦合提出了明确的要求:
      • 只和直接的朋友交流, 朋友之间也是有距离的。自己的就是自己的(如果一个方法放在本类中,既不增加类间关系,也对本类不产生负面影响,那就放置在本类中)。
    • 用例:老师让班长点名–老师给班长一个名单,班长完成点名勾选,返回结果,而不是班长点名,老师勾选
  • 接口隔离原则(Interface Segregation Principle);

    • 客户端不应该依赖它不需要的接口,类间的依赖关系应该建立在最小的接口上
    • 使用建议:接口设计尽量精简单一,但是不要对外暴露没有实际意义的接口。
    • 用例:修改密码,不应该提供修改用户信息接口,而就是单一的最小修改密码接口,更不要暴露数据库操作

从整体上来理解六大设计原则,可以简要的概括为一句话,用抽象构建框架,用实现扩展细节,具体到每一条设计原则,则对应一条注意事项:

  • 单一职责原则告诉我们实现类要职责单一;
  • 里氏替换原则告诉我们不要破坏继承体系;
  • 依赖倒置原则告诉我们要面向接口编程;
  • 接口隔离原则告诉我们在设计接口的时候要精简单一;
  • 迪米特法则告诉我们要降低耦合;
  • 开闭原则是总纲,告诉我们要对扩展开放,对修改关闭
6.2.2 单例模式

一个类只能创建一个对象,即单例模式,该设计模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。

单例模式有两种实现模式:饿汉模式和懒汉模式

  • 饿汉模式: 程序启动时就会创建一个唯一的实例对象。 因为单例对象已经确定, 所以比较适用于多线程环境中, 多线程获取单例对象不需要加锁, 可以有效的避免资源竞争, 提高性能。
// 饿汉模式: 一上来就实例化对象
// 版本1:
class Singleton
{
public:static Singleton& getInsance(){return _ins;}
private:Singleton(const Singleton&)=delete;Singleton& operator=(const Singleton&)=delete;Singleton(){std::cout<<"单例对象构造完成"<<std::endl;}~Singleton(){}static Singleton _ins;
};
Singleton Singleton::_ins;

使用饿汉模式时,无论是否使用单例对象都会创建实例对象,即程序启动就会创建一个唯一实例对象。此时如果单例对象过大,程序启动速度会变慢

在这里插入图片描述

懒汉模式: 第一次使用要使用单例对象的时候创建实例对象。如果单例对象构造特别耗时或者耗费济源(加载插件、加载网络资源等), 可以选择懒汉模式, 在第一次使用的时候才创建对象。

  • 这里介绍的是《Effective C++》一书作者 Scott Meyers 提出的一种更加优雅简便的单例模式Meyers’ Singleton in C++。
  • C++11 Static local variables 特性以确保C++11起,静态变量将能够在满足 thread-safe 的前提下唯一地被构造和析构
// 懒汉模式: 懒加载---延迟加载的思想---一个对象在用的时候再进行实例化class Singleton
{
public:static Singleton& getInstance(){static Singleton ins;    // C++11, 静态变量是线程安全的return ins;}
private:int _data;
public:int getData(){return _data;}
private:Singleton(){std::cout<<"单例对象构造完成"<<std::endl;}~Singleton(){}Singleton(const Singleton&)=delete;Singleton& operator=(const Singleton&)=delete;
};

C++11之前,懒汉模式实现方法:双检查加锁

class Singleton
{
public:static Singleton* getInstance(){if( _ins == nullptr)      // 提高效率, 不需要每次获取单例都加锁解锁{_mtx.lock();if(_ins==nullptr)    // 保证线程安全和只new一次{_ins=new Singleton;}_mtx.unlock();}return _ins;}
private:Singleton(){std::cout<<"单例对象构造完成"<<std::endl;}~Singleton(){}Singleton(const Singleton&)=delete;Singleton& operator=(const Singleton&)=delete;
private:static Singleton* _ins;static std::mutex _mtx;
};
Singleton* Singleton::_ins=nullptr;
std::mutex Singleton::_mtx;
6.2.3 工厂模式

工厂模式是一种创建型设计模式, 它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不会对上层暴露创建逻辑,而是通过使用一个共同结构来指向新创建的对象,以此实现创建-使用的分离

工厂模式可以分为: 简单工厂模式工厂方法模式抽象工厂模式

简单工厂模式: 简单工厂模式实现由一个工厂对象通过类型决定创建出来指定产品类的实例。假设有个工厂能生产出水果,当客户需要产品的时候明确告知工厂生产哪类水果,工厂需要接收用户提供的类别信息,当新增产品的时候,工厂内部去添加新产品的生产方式。

class Fruit
{
public:Fruit(){}virtual void name()=0;
};class Apple:public Fruit
{
public:Apple(){}virtual void name(){std::cout<<"我是一个苹果"<<std::endl;}
};class Banana:public Fruit
{
public:Banana(){}virtual void name(){std::cout<<"我是一个香蕉"<<std::endl;}
};
class FruitFactory1
{
public:static std::shared_ptr<Fruit> create(const std::string name){if(name=="苹果")return std::make_shared<Apple>();else if(name=="香蕉")return std::make_shared<Banana>();}
};
int main()
{std::shared_ptr<Fruit> fruit=FruitFactory1::create("苹果");fruit->name();fruit=FruitFactory1::create("香蕉");fruit->name();
}

简单工厂模式: 通过参数控制可以生产任何产品

优点: 简单粗暴,直观易懂。使用同一个工厂生产同一等级结构下的任意产品

缺点:

  1. 所有东西生产在一起, 产品太多会导致代码量庞大
  2. 开闭原则遵循(开放扩展, 关闭修改)的不是很好, 要新增产品就必须修改工厂方法

工厂方法模式: 在简单工厂模式下新增多个工厂,多个产品,每个产品对应一个工厂。假设现在有A、B 两种产品,则开两个工厂,工厂 A 负责生产产品 A,工厂 B 负责生产产品 B,用户只知道产品的工厂名,而不知道具体的产品信息,工厂不需要再接收客户的产品类别,而只负责生产产品。

class Fruit
{
public:Fruit(){}virtual void name()=0;
};class Apple:public Fruit
{
public:Apple(){}virtual void name(){std::cout<<"我是一个苹果"<<std::endl;}
};class Banana:public Fruit
{
public:Banana(){}virtual void name(){std::cout<<"我是一个香蕉"<<std::endl;}
};class FruitFactory2
{
public:virtual std::shared_ptr<Fruit> create()=0;
};class AppleFactory:public FruitFactory2
{
public:virtual std::shared_ptr<Fruit> create() override{return std::make_shared<Apple>();}
};class BananaFactory:public FruitFactory2
{
public:virtual std::shared_ptr<Fruit> create() override{return std::make_shared<Banana>();}
};int main()
{std::shared_ptr<FruitFactory2> ff(new AppleFactory());std::shared_ptr<Fruit> fruit=ff->create();fruit->name();ff.reset(new BananaFactory());fruit=ff->create();fruit->name();return 0;
}

工厂方法: 定义一个创建对象的接口, 但是由子类来决定创建哪种对象, 使用多个工厂分别生产指定的固定产品

优点:

  1. 减轻了工厂类的负担, 将某类产品的生产交给指定的工厂来进行
  2. 开闭原则遵循较好, 添加新产品只需要新增产品的工厂即可, 不需要修改原先的工厂类

缺点: 对于某种可以形成一组产品族的情况处理较为复杂, 需要创建大量的工厂类

抽象工厂模式: 工厂方法模式通过引入工厂等级结构,解决了简单工厂模式中工厂类职责太重的问题,但由于工厂方法模式中的每个工厂只生产一类产品,可能会导致系统中存在大量的工厂类,势必会增加系统的开销。此时,我们可以考虑将一些相关的产品组成一个产品族(位于不同产品等级结构中功能相关联的产品组成的家族),由同一个工厂来统一生产,这就是抽象工厂模式的基本思想。

class Animal
{
public:Animal(){}virtual void name()=0;
};class Cat:public Animal
{
public:virtual void name() {std::cout<<"我是一只小猫"<<std::endl;}
};class Dog:public Animal
{
public:virtual void name(){std::cout<<"我是一只小狗"<<std::endl;}
};class Factory
{
public:virtual std::shared_ptr<Fruit> getFruit(const std::string&name)=0;virtual std::shared_ptr<Animal> getAnimal(const std::string&name)=0;
};class FruitFactory:public Factory
{
public:virtual std::shared_ptr<Animal> getAnimal(const std::string&name) override{return std::shared_ptr<Animal>();}virtual std::shared_ptr<Fruit> getFruit(const std::string&name)  override{if(name=="苹果")return std::make_shared<Apple>();else if(name=="香蕉")return std::make_shared<Banana>();}
};class AnimalFactory:public Factory
{
public:virtual std::shared_ptr<Fruit> getFruit(const std::string&name)  override{return std::shared_ptr<Fruit>();}virtual std::shared_ptr<Animal> getAnimal(const std::string&name) override{if(name=="小猫")return std::make_shared<Cat>();else if(name=="小狗")return std::make_shared<Dog>();}
};class FactoryProducer
{
public:static std::shared_ptr<Factory> create(const std::string&name){if(name=="水果")return std::make_shared<FruitFactory>();else if(name=="动物")return std::make_shared<AnimalFactory>();}
};
int main()
{std::shared_ptr<Factory> ff=FactoryProducer::create("水果");std::shared_ptr<Fruit> fruit=ff->getFruit("苹果");fruit->name();fruit=ff->getFruit("香蕉");fruit->name();std::shared_ptr<Factory> fa=FactoryProducer::create("动物");std::shared_ptr<Animal> animal=fa->getAnimal("小猫");animal->name();animal=fa->getAnimal("小狗");animal->name();
}

抽象工厂:围绕一个超级工厂创建其他工厂。每个生成的工厂按照工厂模式提供对象。
思想:将工厂抽象成两层,抽象工厂 & 具体简单工厂子类, 在工厂子类种生产不同类型的子产品

抽象工厂模式适用于生产多个工厂系列产品衍生的设计模式,增加新的产品等级结构复杂,需要对原有系统进行较大的修改,甚至需要修改抽象层代码,违背了“开闭原则”。

6.2.4 建造者模式

建造者模式是一种创建型设计模式, 使用多个简单的对象一步一步构建成一个复杂的对象,能够将一个复杂的对象的构建与它的表示分离,提供一种创建对象的最佳方式。主要用于解决对象的构建过于复杂的问题。

建造者模式主要基于四个核心类实现:

  • 抽象产品类:
  • 具体产品类:一个具体的产品对象类
  • 抽象Builder类:创建一个产品对象所需的各个部件的抽象接口
  • 具体产品的Builder类:实现抽象接口,构建各个部件
  • 指挥者Director类:统一组建过程,提供给调用者使用,通过指挥者来构造产品
#include<iostream>
#include<string>
#include<memory>// 抽象电脑类
class Computer
{
public:Computer(){}void SetBoard(const std::string & board){_board=board;}void SetDisplay(const std::string & display){_display=display;}virtual void SetOS()=0;void ShowParmaters(){std::string param="Computer Paramaters:\n";param+="\tBoard: " + _board + "\n";param+="\tDisplay: " + _display + "\n";param+="\tOs: " + _os + "\n";std::cout<<param<<std::endl;}
protected:std::string _board;std::string _display;std::string _os;
};// 具体产品类
class MacBook:public Computer
{
public:MacBook(){}virtual void SetOS(){_os="Mac Os X12";}
};// 抽象建造者类
class Builder
{
public:virtual void buildBoard(const std::string & board)=0;virtual void buildDisplay(const std::string & display)=0;virtual void buildOS()=0;virtual std::shared_ptr<Computer> build()=0;
};// 具体产品的建造者类: 实现抽象接口, 构建和组装各个部件
class MacBookBuilder: public Builder
{
public:MacBookBuilder():_computer(new MacBook()){}virtual void buildBoard(const std::string & board){_computer->SetBoard(board);}virtual void buildDisplay(const std::string & display){_computer->SetDisplay(display);}virtual void buildOS(){_computer->SetOS();}std::shared_ptr<Computer> build(){return _computer;}
private:std::shared_ptr<Computer> _computer;
};// 指挥者类,提供给调用者使用,通过指挥者来构造复杂产品
class Director
{
public:Director(Builder*builder):_builder(builder){}void construct(const std::string& board, const std::string& display){_builder->buildBoard(board);_builder->buildDisplay(display);_builder->buildOS();}
private:std::shared_ptr<Builder> _builder;
};
int main()
{Builder*builder=new MacBookBuilder();std::unique_ptr<Director> director(new Director(builder));director->construct("华硕主板", "三星显示器");std::shared_ptr<Computer> computer=builder->build();computer->ShowParmaters();return 0;
}

在这里插入图片描述

6.2.5 代理模式

代理模式指代理控制对其他对象的访问, 也就是代理对象控制对原对象的引用。在某些情况下,一个对象不适合或者不能直接被引用访问,而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的结构包括一个是真正的你要访问的对象(目标类)、一个是代理对象。目标对象与代理对象实现同一个接口,先访问代理类再通过代理类访问目标对象。代理模式分为静态代理、动态代理:

  • 静态代理指的是,在编译时就已经确定好了代理类和被代理类的关系。也就是说,在编译时就已经确定了代理类要代理的是哪个被代理类。
  • 动态代理指的是,在运行时才动态生成代理类,并将其与被代理类绑定。这意味着,在运行时才能确定代理类要代理的是哪个被代理类。

以租房为例,房东将房子租出去,但是要租房子出去,需要发布招租启示, 带人看房,负责维修,这些工作中有些操作并非房东能完成,因此房东为了图省事,将房子委托给中介进行租赁。 代理模式实现:

#include<iostream>// 房东要把一个房子通过中介租出去理解代理模式
class RentHouse
{
public:virtual void rentHouse()=0;
};// 房东类:将房子租出去
class Landlord: public RentHouse
{
public:virtual void rentHouse(){std::cout<<"将房子租出去"<<std::endl;}
};// 中介代理类:对租房子进行功能加强,实现租房以外的其他功能
class Intermediary: public RentHouse
{
public:virtual void rentHouse(){std::cout<<"发布招租启示"<<std::endl;std::cout<<"带人看房"<<std::endl;_landlord.rentHouse();std::cout<<"负责租后维修"<<std::endl;}
private:Landlord _landlord;
};int main()
{Intermediary intermediary;intermediary.rentHouse();return 0;
}

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/631736.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

24年地信专业各大院校,考研真题合集

2024年云南师范大学人文地理学考研真题 一、简答题 1. 人文地理学科的任务 2. 文化生态关系的类型与特点人口出生率低的影响因素现代农业的类型与特点 3. 发展中国家工业发展中存在的问题 二、分析题 1. 结合实例说明城市地域结构模型及主要动力 2. 结合实例论述区域协作组织对…

【送酒小程序系统源码】/花店送花系统/蛋糕店系统/奶茶店系统源码

前端uniapp后端thinkphp数据库mysql 多门店外卖餐饮点餐系统预约点餐 匹配附近店铺 堂食 外卖带走 菜品管理. 根据用户的位置匹配附近饭店 点餐后,可以在线等叫号 餐时输入手机号并支付后,可以支持外 支持多规格、备注等快捷功能,以吸多 多门店管理 数据概览 支持微…

克魔助手工具详解、数据包抓取分析、使用教程

目录 摘要 引言 克魔助手界面 克魔助手查看数据捕获列表 数据包解析窗口 数据包数据窗口 克魔助手过滤器表达式的规则 抓包过滤器实例 总结 参考资料 摘要 本文介绍了克魔助手工具的界面和功能&#xff0c;包括数据包的捕获和分析&#xff0c;以及抓包过滤器的使用方…

HarmonyOS—构建第一个ArkTS应用(Stage模型)

创建ArkTS工程 构建第一个页面 若首次打开DevEco Studio&#xff0c;请点击Create Project创建工程。如果已经打开了一个工程&#xff0c;请在菜单栏选择File > New > Create Project来创建一个新工程。选择Application应用开发&#xff0c;选择模板“Empty Ability”&am…

写点东西《什么是网络抓取?》

写点东西《什么是网络抓取&#xff1f;》 什么是网络抓取&#xff1f; 网络抓取合法吗&#xff1f; 什么是网络爬虫&#xff0c;它是如何工作的&#xff1f; 网络爬虫示例 网络抓取工具 结论 您是否曾经想同时比较多个网站上同一件商品的价格&#xff1f;或者自动提取您最喜欢的…

Java-NIO 开篇(1)

NIO简介 高性能的Java通信&#xff0c;离不开Java NIO组件&#xff0c;现在主流的技术框架或中间件服务器&#xff0c;都使用了Java NIO组件&#xff0c;譬如Tomcat、 Jetty、 Netty、Redis、RabbitMQ等的网络通信模块。在1.4版本之前&#xff0c; Java IO类库是阻塞式IO&…

从0开始python学习-49.pytest之日志封装和allure封装

目录 日志封装 1. 在pytest.ini中配置日志的格式 2. 生成日志对象--在请求封装中写 3. 把日志写入文件--在请求封装中写 allure封装 1. 在yaml用例中写入需要的模块、接口等内容 2. 在测试用例封装的函数中通过allure.dynamic的方法写入需要的数据 日志封装 1. 在pytest.…

uniapp写微信小程序实现电子签名

写电子签名一定要注意的是一切全部按照手机上的适配来&#xff0c;为啥这么说呢&#xff0c;因为你在微信开发者工具中调试的时候认为是好的&#xff0c;正常的非常nice,当你发布版本的时候你会发现问题出来了。我下边的写法你可以直接用很简单。就是要记住canvas的几个属性和用…

Android Studi安卓读写NDEF智能海报源码

本示例使用的发卡器&#xff1a;https://item.taobao.com/item.htm?id615391857885&spma1z10.5-c.w4002-21818769070.11.1f60789ey1EsPH <?xml version"1.0" encoding"utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmln…

【NPL】自然语言处理(Natural Language Processing,NLP)的发展简述

大家好&#xff0c;我是全栈小5&#xff0c;欢迎阅读文章&#xff01; 此篇是【话题达人】序列文章&#xff0c;这一次的话题是《自然语言处理的发展》 文章将以博主的角度进行讲述&#xff0c;理解和水平有限&#xff0c;不足之处&#xff0c;望指正。 目录 背景发展线路研发关…

WordPress回收站自动清空时间?如何关闭回收站或设置自动清理天数?

我们在WordPress后台的文章、页面、评论等页面都可以看到有回收站&#xff0c;意思就是我们不能直接删除某篇文章、页面、评论&#xff0c;而是需要现将它们移至回收站&#xff0c;然后再到回收站永久删除&#xff0c;或等回收站自动清理。 如上图所示&#xff0c;WordPress 6.…

归并排序(C语言)

目录 1.归并排序图解 2.归并排序&#xff08;递归版&#xff09; 3.归并排序&#xff08;非递归版&#xff09; 1.归并排序图解 归并排序的核心思想是让左右两边有序的部分进行合并比较排序&#xff0c;具体什么意思呢&#xff1f;分两点&#xff1a; 1.分&#xff1a;左右两边…

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK使用相机日志跟踪功能(C++)

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK使用相机日志跟踪功能&#xff08;C&#xff09; Baumer工业相机Baumer工业相机NEOAPI SDK和短曝光功能的技术背景Baumer工业相机通过NEOAPI SDK使用相机日志跟踪功能1.引用合适的类文件2.通过NEOAPI SDK使用相机日志跟踪功能3.通…

如何用Docker部署Nacos服务并结合内网穿透实现公网访问管理界面?

文章目录 1. Docker 运行Nacos2. 本地访问Nacos3. Linux安装Cpolar4. 配置Nacos UI界面公网地址5. 远程访问 Nacos UI界面6. 固定Nacos UI界面公网地址7. 固定地址访问Plik Nacos是阿里开放的一款中间件,也是一款服务注册中心&#xff0c;它主要提供三种功能&#xff1a;持久化…

区间预测 | Matlab实现GRU-Adaboost-ABKDE的集成门控循环单元自适应带宽核密度估计多变量回归区间预测

区间预测 | Matlab实现GRU-Adaboost-ABKDE的集成门控循环单元自适应带宽核密度估计多变量回归区间预测 目录 区间预测 | Matlab实现GRU-Adaboost-ABKDE的集成门控循环单元自适应带宽核密度估计多变量回归区间预测效果一览基本介绍程序设计参考资料 效果一览 基本介绍 1.Matlab实…

Java 基础知识-反射

大家好我是苏麟 , 今天聊聊反射 . 反射 ​专业的解释&#xff1a; 反射允许对封装类的字段&#xff0c;方法和构造函数的信息进行编程访问 是在运行状态中&#xff0c;对于任意一个类&#xff0c;都能够知道这个类的所有属性和方法 ​ 对于任意一个对象&#xff0c;都能够调…

学习JavaEE的日子 day13补 深入类加载机制及底层

深入类加载机制 初识类加载过程 使用某个类时&#xff0c;如果该类的class文件没有加载到内存时&#xff0c;则系统会通过以下三个步骤来对该类进行初始化 1.类的加载&#xff08;Load&#xff09; → 2.类的连接&#xff08;Link&#xff09; → 3.类的初始化&#xff08;In…

《WebKit 技术内幕》之三(3): WebKit 架构和模块

3 Webkit2 3.1 Webkit2 架构及模块 相比于狭义的WebKit&#xff0c;WebKit2是一套全新的结构和接口&#xff0c;而并不是一个简单的升级版。Webkit2 的思想同 Chrominum 类似&#xff0c;就是将渲染过程放在单独的进程中来完成&#xff0c;独立于用户界面。 webKit2中…

华为路由设备DHCPV6配置

组网需求 如果大量的企业用户IPv6地址都是手动配置&#xff0c;那么网络管理员工作量大&#xff0c;而且可管理性很差。管理员希望实现公司用户IPv6地址和网络配置参数的自动获取&#xff0c;便于统一管理&#xff0c;实现IPv6的层次布局。 图1 DHCPv6服务器组网图 配置思路 …