【项目】云备份系统基础功能实现

最新推荐文章于 2024-09-06 18:35:20 发布
最新推荐文章于 2024-09-06 18:35:20 发布
阅读量945 收藏
点赞数
分类专栏： 项目 文章标签： github git c++ http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52094687/article/details/134448312
版权

目录

云备份系统项目代码链接

一.项目介绍

1.云备份认识

自动将本地计算机上指定文件夹中需要备份的文件上传备份到服务器中。并且能够随时通过浏览器进行查看并且下载，其中下载过程支持断点续传功能，而服务器也会对上传文件进行热点管理，将非热点文件进行压缩存储，节省磁盘空间。
在这里插入图片描述
这个云备份项目需要我们实现两端程序，其中包括部署在用户机的客户端程序，上传需要备份的文件，以及运行在服务器上的服务端程序，实现备份文件的存储和管理，两端合作实现总体的自动云备份功能。

2.服务端程序负责功能与功能模块划分

功能：

  • 针对客户端上传的文件进行备份存储。
  • 能够对文件进行热点文件管理，对非热点文件进行压缩存储，节省磁盘空间。
  • 支持客户端浏览器查看访问文件列表。
  • 支持客户端浏览器下载文件，并且下载支持断点续传。

功能模块划分：

  • 数据管理模块：负责服务器上备份文件的信息管理。
  • 网络通信模块：搭建网络通信服务器，实现与客户端通信。
  • 业务处理模块：针对客户端的各个请求进行对应业务处理并响应结果。
  • 热点管理模块：负责文件的热点判断，以及非热点文件的压缩存储。

3.客户端程序负责功能与功能模块划分

功能：

  • 能够自动检测客户机指定文件夹中的文件，并判断是否需要备份。
  • 将需要备份的文件逐个上传到服务器。

功能模块划分：

  • 数据管理模块：负责客户端备份的文件信息管理，通过这些数据可以确定一个文件是否需要备份。
  • 文件检测模块：遍历获取指定文件夹中所有文件路径名称。
  • 网络通信模块：搭建网络通信客户端，实现将文件数据备份上传到服务器。

4.开发环境

centos7.6、VS Code、g++、gdb、makefile 以及 windows10/vs2019

二.环境搭建

1.gcc升级7.3版本

  • 因为后面的第三方库要求使用更高版本的gcc，若版本过低需要升级版本
  • 查看gcc/g++版本的指令：gcc -v、g++ -v
sudo yum install centos-release-scl-rh centos-release-scl
sudo yum install devtoolset-7-gcc devtoolset-7-gcc-c++
source /opt/rh/devtoolset-7/enable  // 加载配置文件，该指令当前生效，重新打开终端后gcc版本不变
echo "source /opt/rh/devtoolset-7/enable" >> ~/.bashrc // 将加载配置文件放入配置文件中，使其永久有效

2.安装jsoncpp库

sudo yum install epel-release
sudo yum install jsoncpp-devel
[YX@localhost ~]$ ls /usr/include/jsoncpp/json/
assertions.h config.h forwards.h reader.h version.h
autolink.h features.h json.h value.h writer.h
#注意，centos版本不同有可能安装的jsoncpp版本不同，安装的头文件位置也就可能不同了。
  • 安装后位置为/usr/include/jsoncpp/json/

3.下载bundle数据压缩库

sudo yum install git
git clone https://github.com/r-lyeh-archived/bundle.git

bundle库Github链接

4.下载httplib库

git clone https://github.com/yhirose/cpp-httplib.git

httplib库Github链接

  • 注意： bundle和httplib是github上的库，下载安装可能会比较慢甚至失败，建议在网络环境好的情况下多安装几次

三.第三方库认识

1.json

(1)json认识

json是一种数据交换格式，采用完全独立于编程语言的文本格式来存储和表示数据。

例如：小明同学的学生信息

char name = "小明";
int age = 18;
float score[3] = {88.5, 99, 58};

则json这种数据交换格式是将这多种数据对象组织成为一个字符串：
[
    {
        "姓名" : "小明",
        "年龄" : 18,
        "成绩" : [88.5, 99, 58]
    },
    {
        "姓名" : "小黑",
        "年龄" : 18,
        "成绩" : [88.5, 99, 58]
    }
]

json 数据类型：对象，数组，字符串，数字

对象：使用花括号 {} 括起来的表示一个对象。

数组：使用中括号 [] 括起来的表示一个数组。

字符串：使用常规双引号 “” 括起来的表示一个字符串

数字：包括整形和浮点型，直接使用。

(2)jsoncpp认识

jsoncpp 库用于实现 json 格式的序列化和反序列化，完成将多个数据对象组织成为 json 格式字符串，以及将json格式字符串解析得到多个数据对象的功能。

这其中主要借助三个类(Json数据类、序列化类、反序列化类)以及其对应的少量成员函数完成：

//Json数据对象类
class Json::Value{
    Value &operator=(const Value &other); //Value重载了[]和=，因此所有的赋值和获取数据都可以通过
    Value& operator[](const std::string& key);//简单的方式完成 val["姓名"] = "小明";
    Value& operator[](const char* key);
    Value removeMember(const char* key);//移除元素
    const Value& operator[](ArrayIndex index) const; //val["成绩"][0]
    Value& append(const Value& value);//添加数组元素val["成绩"].append(88);
    ArrayIndex size() const;//获取数组元素个数 val["成绩"].size();
    std::string asString() const;//转string string name = val["name"].asString();
    const char* asCString() const;//转char* char *name = val["name"].asCString();
    Int asInt() const;//转int int age = val["age"].asInt();
    float asFloat() const;//转float
    bool asBool() const;//转 bool
};

//json序列化类，低版本用这个更简单
class JSON_API Writer {
	virtual std::string write(const Value& root) = 0;
};
class JSON_API FastWriter : public Writer {
	virtual std::string write(const Value& root);
};
class JSON_API StyledWriter : public Writer {
	virtual std::string write(const Value& root);
};

//json序列化类，高版本推荐，如果用低版本的接口可能会有警告
class JSON_API StreamWriter {
	virtual int write(Value const& root, std::ostream* sout) = 0;
};
class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
	virtual StreamWriter* newStreamWriter() const;
};

//json反序列化类，低版本用起来更简单
class JSON_API Reader {
	bool parse(const std::string& document, Value& root, bool collectComments = true);
};

//json反序列化类，高版本更推荐
class JSON_API CharReader {
	virtual bool parse(char const* beginDoc, char const* endDoc, Value* root, std::string* errs) = 0;
};
class JSON_API CharReaderBuilder : public CharReader::Factory {
	virtual CharReader* newCharReader() const;
};
  • 之所以使用jsoncpp库实现序列化，而不是我们自己实现一个序列化库，是为了开发效率，减少不必要的成本（下边两个库也是相同的）
  • 当然，有兴趣的同学也可以自己实现一个序列化和反序列化库

(3)json实现序列化

编写如下测试代码，测试json实现序列化，熟悉该库，为后面使用做准备

#include <iostream>
#include <sstream>
#include <string>
#include <memory>
#include <jsoncpp/json/json.h>
using namespace std;

stringstream serialize(Json::Value& root)
{
    Json::StreamWriterBuilder swb;
    unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
    stringstream ss;
    sw->write(root, &ss);
    return ss;
}

int main()
{
    const char* name = "张三";
    int age = 18;
    float score[] = {77.5, 88, 93.6};

    Json::Value root;
    root["姓名"] = name;
    root["年龄"] = age;
    root["成绩"].append(score[0]);
    root["成绩"].append(score[1]);
    root["成绩"].append(score[2]);

    stringstream ss = serialize(root); // 序列化
    cout << ss.str() << endl;

    return 0;
}

在这里插入图片描述

(4)jsoncpp实现反序列化

补充知识：

string str = R"({"姓名":"小明", "年龄":18, "成绩":[76.5, 55, 88]})";

上述为C++11的特殊用法，R"()"表示圆括号内的数据是一个原始字符串，所有字符去除特殊含义。

#include <iostream>
#include <sstream>
#include <string>
#include <memory>
#include <jsoncpp/json/json.h>
using namespace std;

stringstream serialize(Json::Value& root)
{
    Json::StreamWriterBuilder swb;
    unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
    stringstream ss;
    sw->write(root, &ss);
    return ss;
}

Json::Value deserialization(string&& str)
{
    Json::Value root;
    Json::CharReaderBuilder crb;
    unique_ptr<Json::CharReader> cr(crb.newCharReader());
    string err;
    bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root, &err);
    if(ret == false)
    {
        cout << "parse error: " << err << endl;
        exit(-1);
    }
    return root;
}

int main()
{
    const char* name = "张三";
    int age = 18;
    float score[] = {77.5, 88, 93.6};

    Json::Value root;
    root["姓名"] = name;
    root["年龄"] = age;
    root["成绩"].append(score[0]);
    root["成绩"].append(score[1]);
    root["成绩"].append(score[2]);

    stringstream ss = serialize(root); // 序列化
    cout << ss.str() << endl;
    Json::Value root1 = deserialization(ss.str());
    cout << root1["姓名"].asString() << endl;
    cout << root1["年龄"].asString() << endl;
    int index = root1["成绩"].size();
    for(int i=0;i<index;i++)
    {
        cout << root1["成绩"][i] << endl;
    }

    return 0;
}

在这里插入图片描述

2.bundle

(1)bundle文件压缩库认识

Bundle是一个嵌入式压缩库，支持23种压缩算法和2种存档格式。使用的时候只需要加入两个文件bundle.h 和 bundle.cpp 即可。

namespace bundle
{
    // low level API (raw pointers)
    bool is_packed( *ptr, len );
    bool is_unpacked( *ptr, len );
    unsigned type_of( *ptr, len );
    size_t len( *ptr, len );
    size_t zlen( *ptr, len );
    const void *zptr( *ptr, len );
    bool pack( unsigned Q, *in, len, *out, &zlen );
    bool unpack( unsigned Q, *in, len, *out, &zlen );
    
    // medium level API, templates (in-place)
    bool is_packed( T );
    bool is_unpacked( T );
    unsigned type_of( T );
    size_t len( T );
    size_t zlen( T );
    const void *zptr( T );
    bool unpack( T &, T );
    bool pack( unsigned Q, T &, T );
    
    // high level API, templates (copy)
    T pack( unsigned Q, T );
    T unpack( T );
}

(3)bundle库实现文件压缩与减压

string ReadData(string& ifilename) // 读取文件中的数据到body
{
    ifstream ifs;
    ifs.open(ifilename, ios::binary); // 打开原始文件
    ifs.seekg(0, ios::end); //跳转读写位置到末尾
    size_t fsize = ifs.tellg(); // 获取末尾偏移量 -- 文件长度
    ifs.seekg(0, ios::beg); // 跳转到文件起始
    string body;
    body.resize(fsize); // 调整bidy大小为文件大小
    ifs.read(&body[0], fsize); // 读取文件所有数据到body
    
    ifs.close();
    return body;
}

void WriteData(string& ofilename, string& packed) // 打开文件写入数据
{
    ofstream ofs;
    ofs.open(ofilename, ios::binary); // 打开压缩包文件
    ofs.write(&packed[0], packed.size()); // 将压缩后的数据写入压缩包文件

    ofs.close();
}

void compressed(string& ifilename, string& ofilename)
{
    string body = ReadData(ifilename);
    string packed = bundle::pack(bundle::LZIP, body); // 以lzip格式压缩文件数据
    WriteData(ofilename, packed);
}

void decompress(string& ifilename, string& ofilename)
{
    string body = ReadData(ifilename);
    string unpacked = bundle::unpack(body); //对压缩包数据解压缩
    WriteData(ofilename, unpacked);
}

int main(int argc, char* argv[])
{
    if(argc < 4) return -1;
    string ifilename = argv[1];
    string ofilename = argv[2];
    string command = argv[3];
    if(command == "compressed")
    {
        compressed(ifilename, ofilename); // 压缩文件
    }
    else if(command == "decompress")
    {
        decompress(ifilename, ofilename); // 解压缩文件
    }

    return 0;
}

在这里插入图片描述
查看减压前后bundle1.cpp和bundle.cpp的md5sum是否一致
在这里插入图片描述

若两文件内容相同，它的md5sum值是相同的否则说明压缩/解压有问题。

3.httplib

(1)httplib库认识

httplib 库，一个 C++11 单文件头的跨平台 HTTP/HTTPS 库。安装起来非常容易。只需包含 httplib.h 在你的代码中即可。

httplib 库实际上是用于搭建一个简单的 http 服务器或者客户端的库，这种第三方网络库，可以让我们免去搭建服务器或客户端的时间，把更多的精力投入到具体的业务处理中，提高开发效率。

namespace httplib{
    struct MultipartFormData {
        std::string name;
        std::string content;
        std::string filename;
        std::string content_type;
    };
    using MultipartFormDataItems = std::vector<MultipartFormData>;
    struct Request {
        std::string method;
        std::string path;
        Headers headers;
        std::string body;
        // for server
        std::string version;
        Params params;
        MultipartFormDataMap files;
        Ranges ranges;
        bool has_header(const char *key) const;
        std::string get_header_value(const char *key, size_t id = 0) const;
        void set_header(const char *key, const char *val);
        bool has_file(const char *key) const;
        MultipartFormData get_file_value(const char *key) const;
    };
    struct Response {
        std::string version;
        int status = -1;
        std::string reason;
        Headers headers;
        std::string body;
        std::string location; // Redirect location
        void set_header(const char *key, const char *val);
        void set_content(const std::string &s, const char *content_type);
    };
    class Server {
        using Handler = std::function<void(const Request &, Response &)>;
        using Handlers = std::vector<std::pair<std::regex, Handler>>;
        std::function<TaskQueue *(void)> new_task_queue;
        Server &Get(const std::string &pattern, Handler handler);
        Server &Post(const std::string &pattern, Handler handler);
        Server &Put(const std::string &pattern, Handler handler);
        Server &Patch(const std::string &pattern, Handler handler);
        Server &Delete(const std::string &pattern, Handler handler);
        Server &Options(const std::string &pattern, Handler handler);
        bool listen(const char *host, int port, int socket_flags = 0);
    };
    class Client {
        Client(const std::string &host, int port);
        Result Get(const char *path, const Headers &headers);
        Result Post(const char *path, const char *body, size_t content_length,
        const char *content_type);
        Result Post(const char *path, const MultipartFormDataItems &items);
    };
};
1.1httplib库Request类
    struct Request {
        std::string method; // 请求方法：get、post..
        std::string path;   // 资源路径
        Headers headers;    // 头部字段
        std::string body;   // 正文
        // for server
        std::string version; // 协议版本
        Params params;       // 查询字符串
        MultipartFormDataMap files; // 保存客户端上传的文件信息
        Ranges ranges;       // 用于实现段点续传的请求文件区间
        // 处理请求只需对上述数据逐个处理分析即可
        
        // 查询头部字段中又没有某个字段
        bool has_header(const char *key) const;
        // 获取头部字段的值
        std::string get_header_value(const char *key, size_t id = 0) const;
        // 设置头部字段
        void set_header(const char *key, const char *val);
        // 是否包含某个文件(从files成员变量中的name字段文件名称查看)
        bool has_file(const char *key) const;
        // 获取文件信息
        MultipartFormData get_file_value(const char *key) const;
    };

请求报文结构如下：
在这里插入图片描述
Request类的作用：

  1. 客户端 保存 的所有 http请求 相关信息，最终组织http请求发送给服务器
  2. 服务器收到http请求之后进行解析，将解析的数据保存在Request类中，等待后序处理
1.2httplib库Response类
    struct Response {
        std::string version; // 协议版本
        int status = -1;     // 响应状态码
        std::string reason;  // （涉及不到）
        Headers headers;     // 头部字段
        std::string body;    // 有效载荷
        std::string location; // Redirect location 重定向位置（涉及不到）
        
        // 设置头部字段，设置好后放入headers
        void set_header(const char *key, const char *val);
        // 设置正文，设置好后放入body
        void set_content(const std::string &s, const char *content_type);
    };

响应报文结构如下：
在这里插入图片描述
Response类的作用：

  1. 用户将想要数据放到类中，httplib会将其中的数据按照http响应格式组织成为http响应，发送给客户端
  2. 这个类是我们在业务处理之后填充的类，由httplib组织成响应，在将其发送给客户端
1.3httplib库Server类
    class Server {
        // 函数指针类型
        using Handler = std::function<void(const Request &, Response &)>;
        // 请求与处理函数映射表
        using Handlers = std::vector<std::pair<std::regex, Handler>>;
        // 线程池，用于处理http请求
        std::function<TaskQueue *(void)> new_task_queue;
        // 以下六个接口，针对某种请求方法的某个请求设定映射的处理函数
        Server &Get(const std::string &pattern, Handler handler);
        Server &Post(const std::string &pattern, Handler handler);
        Server &Put(const std::string &pattern, Handler handler);
        Server &Patch(const std::string &pattern, Handler handler);
        Server &Delete(const std::string &pattern, Handler handler);
        Server &Options(const std::string &pattern, Handler handler);
        // 搭建并启动http服务器
        bool listen(const char *host, int port, int socket_flags = 0);
    };

Server类的作用：用于搭建http服务器

其中：

  • Handler： 函数指针类型，定义了一个http请求处理回调函数格式
    httplib搭建的服务器收到请求后，进行解析，得到一个Request结构体，其中包含了请求数据
    根据请求数据我们就可以处理这个请求了，这个处理函数定义的格式就是Handler格式
    • Request参数： 保存请求数据，让用户能够根据请求数据进行业务处理
    • Response参数： 需要用户在业务处理中，填充数据，最终要响应给客户端
  • Handlers： 是一个请求路由数组：其中包含两个信息（请求与处理函数映射表）
    • regex： 正则表达式，用于匹配http请求资源路径
    • Handler： 请求处理函数指针

    可以理解为，Handlers是一张表，映射了一个客户端请求的资源路径和一个处理函数（用户自己定义的函数）
    当服务器收到请求解析得到Request就会根据资源路径以及请求方法到这张表中查看有没有对应的处理函数。
    如果有则调用这个函数进行请求处理，如果没有则响应404
    说白了，handlers这个表就决定了，那个请求应该用那个函数处理

  • new_task_queue： 线程池，处理http请求
    线程池中线程的工作：
    1. 接收请求，解析请求，得到Request类也就是请求的数据
    2. 在Handlers映射表中，根据请求信息查找处理函数，如果有则调用函数处理
      	void(const Request &, Response &)
    3. 当处理函数调用完毕，根据函数返回的Response结构体中的数据组织http响应发送给客户端
1.4httplibClient类
    class Client {
        Client(const std::string &host, int port); // 传入服务器IP地址和断口
        Result Get(const char *path, const Headers &headers); // 向服务器发送GET请求
        // 向服务器发送post请求
        Result Post(const char *path, const char *body, size_t content_length,
        const char *content_type);
        // POST请求提交多区域数据，常用于多文件上传
        Result Post(const char *path, const MultipartFormDataItems &items);
    };

(2)httplib搭建简单服务器

#include "httplib.h"
using namespace std;

void Hello(const httplib::Request &req, httplib::Response& rsp)
{
  rsp.set_content("Hello World!", "text/plain");
  rsp.status = 200;
}
void Numbers(const httplib::Request& req, httplib::Response& rsp)
{
    auto num = req.matches[1]; // 0里保存的是整体path，往后下标中保存的是捕捉的数据
    rsp.set_content(num, "text/plain");
    rsp.status = 200;
}
void Multipart(const httplib::Request& req, httplib::Response& rsp)
{
    auto ret = req.has_file("file");
    if(ret == false)
    {
        cout << "not file upload\n";
        rsp.status = 400;
        return;
    }
    const auto& file = req.get_file_value("file");
    rsp.body.clear();
    rsp.body = file.filename; // 文件名称
    rsp.body += '\n';
    rsp.body += file.content; // 文件内容
    rsp.set_header("Content-Type", "text/plain");
    rsp.status = 200;
    return;
}

int main()
{
  httplib::Server server; // 实例化一个Server类对象用于搭建服务器
  server.Get("/hi", Hello); // 注册一个针对/hi的Get请求的处理函数映射关系
  server.Get(R"(/numbers/(\d+))", Numbers);
  server.Post("/mutipart", Multipart);
  server.listen("0.0.0.0", 8889);
  return 0;
}

使用g++ buildServer.cc -o mytest -std=c++11 -lpthread生成可执行文件，因为httplib库用到了线程库，所以需要增加-lpthread

(3)httplib搭建简单客户端

#include "httplib.h"
using namespace std;

#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 8889

int main()
{
    httplib::Client client(SERVER_IP, SERVER_PORT); // 实例化client对象，用于搭建客户端
    
    httplib::MultipartFormData item;
    item.name = "file";
    item.filename = "hello.txt";
    item.content = "Hello World"; // 上传文件时，这里给的就是文件内容
    item.content_type = "text/plain";

    httplib::MultipartFormDataItems items;
    items.push_back(item);

    auto res = client.Post("/mutipart", items); 
    cout << res->status << endl;
    cout << res->body << endl;

    return 0;
}

使用g++ -o mytest buildClient.cc -std=c++11 -lpthread生成可执行文件，因为httplib库用到了线程库，所以需要增加-lpthread

四.功能实现

1.服务端功能实现

(1)工具类模块

1.1文件实用工具类设计

不管是客户端还是服务端，文件的传输备份都涉及到文件的读写，包括数据管理信息的持久化也是如此，因此首先设计封装文件操作类，这个类封装完毕之后，则在任意模块中对文件进行操作时都将变的简单化。

// 文件实用工具类设计：对文件进行操作
class{
private:
	std::string _filename;
	struct stat _st;
public:
	size_t FileSize(); //获取文件大小
	time_t LastMTime(); // 获取文件最后一次修改时间
	time_t LastATime(); // 获取文件最后一次访问时间
	std::string FileName(); // 获取文件路径名中的文件名称 /abc/test.txt -> test.txt
    std::string FilePath(); // 获取文件相对路径（当获取文件不在当前目录下时，需要根据路径获取）
	bool SetContest(std::string& body); // 向文件写入数据
	bool GetContent(std::string* body); // 获取文件数据
	bool GetPosLen(std::string* body, size_t pos, size_t len); //获取文件指定位置指定长度数据
	bool GetDirectory(std::vector<std::string>* arry); //获取文件目录
    bool Remove(); // 删除当前文件
    bool CreateDirector(); //创建目录
    bool Exits(); //判断文件是否存在
    bool ScanDirectory(std::vector<std::string>* arrry)；
    bool Compress(const std::string& packname); //压缩当前文件，压缩包存放位置及文件名由packname决定
    bool UnCompress(const std::string& unpackname); //解压缩，减压后的文件存放位置及文件名由unpackname决定
};

在实现该类时，我给出的代码中服务端文件工具类实用的是Linux系统提供的接口，而在客户端该类中则实用C++17给出的Filesystem库，大家可以按自己的需求来实用。
C++17中Filesystem library - cppreference.com

1.2 Json实用工具类
// 涉及两个接口，一个Json的序列化、一个反序列化
class JsonUtil
{
public:
    static bool Serialize(const Json::Value& root, std::string* str);   // 序列化
    static bool UnSerialize(const std::string* str, Json::Value& root); // 反序列化
};

该类用来配合文件工具类对文件进行序列化和反序列化

1.3 time实用工具类
class TimeUtil
{
public:
    static void AddressTime(time_t time, std::string& tartime); // 将时间转化为 年/月/日 时:分:秒 的格式
    static time_t GetNowTime(); // 获取当前时间
    static bool JudgeHot(time_t&& time, time_t hotTime); // 若当前时间减去最后传输来的时间大于热点时间，文件为非热点文件
};

在浏览器页面展示时，需要显示文件信息，其中就有时间，需要将其转化为 年/月/日 时:分:秒 的格式

(2)配置信息模块

2.1系统配置信息

当我们运行系统时可以在配置文件中读出关键信息，在程序中使用。

使用配置文件，我们的配置信息就可以随时进行更改，更改配置信息后，我们的程序不需要重新生成重新编译，只需重启服务端程序，重新加载配置即可。

使用文件配置加载一些程序的运行关键信息可以让程序的运行更加灵活。

配置信息：

  • 热点判断时间
    热点管理：多长时间没有被访问的文件算是非热点文件，取决于热点判断时间

  • 文件下载URL前缀路径 — 用于表示客户端请求是一个下载请求
    url：http://服务器IP地址:端口号:相对文件根目录
    当用户发来一个备份列表查看请求如：/listshow，我们如何判断这不是一个listshow的文件下载请求
    所以规定，当给出的文件路径为/download/listshow时我们判断此时是要下载listshow文件

  • 压缩包后缀名称
    根据项目中使用的压缩格式自己来定义压缩包命名规则，在文件原名称之后加后缀

  • 上传文件存放路径
    决定了文件上传之后，实际存放在服务器的哪里

  • 压缩文件存放路径
    决定非热点文件压缩后存放的路径

  • 服务端备份信息存放文件
    该项目暂时未使用数据库存储，而是使用文件记录服务端记录的备份文件信息的持久化存储

  • 服务器访问IP地址
    当程序运行在其他主机上，则不需要修改程序，只需要改对应的服务器IP和端口即可

  • 服务器访问端口

{
  "hot_time" : 30,
  "server_port" : 9191,
  "server_ip" : "43.143.x.x",
  "download_prefix" : "/download/",
  "packfile_suffix" : ".lz",
  "pack_dir" : "./packdir",
  "back_dir" : "./backdir",
  "backup_file" : "./cloud_dat"
}
  • 已经实现了json的工具类，在存放时以json的格式存放，使用时更加方便
2.2 单例文件配置类设计

使用单例模式管理系统配置信息，能够让配置信息的管理控制更加统一灵活。

#define CONFIG_FILE "./cloud.conf"

class Config{
    private:
        int _hot_time;                // 热点管理判断时间
        int _server_port;             // 服务器监听端口
        std::string _download_prefix; // 下载的url前缀路径
        std::string _packfile_suffix; // 压缩包后缀名称
        std::string _back_dir;        // 备份文件存放目录
        std::string _pack_dir;        // 压缩包存放目录
        std::string _backup_file;     // 数据信息存放文件，即上传文件存放相对根目录
        std::string _server_ip;       // 服务器IP地址
    private:
        static std::mutex _mutex;
        static Config *_instance;
        Config();
        bool ReadConfig(const std::string &filename);
    public:
        int GetHotTime();
        int GetServerPort();
        std::string GetServerIp();
        std::string GetURLPrefix();
        std::string GetArcSuffix();
        std::string GetPackDir();
        std::string GetBackDir();
        std::string GetManagerFile();
    public:
    	static Config *GetInstance();
};

(3)数据管理模块

3.1管理的数据信息

后期要用到那些数据，就是我们需要管理的数据，如下：

  • 文件实际存储路径
    客户端下载文件时，从这个文件中读取数据进行响应
    如果文件已经被压缩，则先从压缩目录下找到该文件，进行解压缩，存入实际路径

  • 文件是否压缩标志
    判断文件是否已经被压缩了

  • 压缩包存储路径
    如果这个文件时一个非热点文件回被压缩，则这个就是压缩包路径名称
    客户端要下载文件，需要先减压缩，然后读取减压后的文件数据。

  • 文件属性信息
    如果用户只是需要文件的展示界面，不需要下载，我们不能将已经压缩的文件减压后获取其属性信息，这样效率太低，而是需要事先保存其如下属性（可添加）

    1. 文件大小
    2. 文件最后一次访问时间
    3. 文件最后一次修改时间

  • 文件访问URL中资源路径
    如：/download/a.txt
    告诉用户文件的下载路径是什么

3.2数据管理类的设计

  • 用于数据信息访问：
    内存中以文件访问URL为key，数据信息结构为val，使用哈希表进行管理，查询速度快。使用url作为key是因为往后客户端浏览器下载文件的时候总是以 url 作为请求。

  • 持久化存储管理：
    采用文件形式对数据进行持久化存储（序列化方式采用 json 格式或者自定义方式）

3.3数据管理类的设计

数据管理类：管理服务端系统中会用到的数据

/*data.hpp*/
typedef struct BackupInfo
{
    int pack_flag;         // 是否压缩标志
    time_t mtime;          // 文件最后访问时间
    time_t atime;          // 文件最后修改时间
    size_t fsize;          // 文件大小
    std::string real_path; // 文件实际存储路径
    std::string pack_path; // 压缩包存储路径名
    std::string url;       // 请求资源路径
    bool NewBackupInfo(const std::string &realpath); // 将realpath中内容填写入当前对象
} BackupInfo;

class DataManager
{
private:
    FileUtil _backup_file;                              // 持久化存储文件
    pthread_rwlock_t _rwlock;                           // 读写锁--读共享，写互斥
    std::unordered_map<std::string, BackupInfo> _table; // 内存中以hash表存储
public:
    DataManager();
    bool InitLoad(); // 初始化程序运行时从文件读取数据
    bool Storage();  // 每次有信息改变则需要重新持久化存储一次，防止数据丢失
    bool Insert(const BackupInfo &val); // 新增
    bool Update(const std::string &key, const BackupInfo &val); // 修改
    bool GetOneByURL(const std::string &key, BackupInfo *info); // 通过单个URL获取对应文件数据
    bool GetOneByRealPath(const std::string &realpath, BackupInfo *info); // 根据指定文件真实路径，获取对应文件数据
    bool GetAll(std::vector<BackupInfo> *arry); // 获取所有信息
};
  • 互斥锁是一个串行化的过程，同一时间只有一个线程可以访问临界资源，在该项目中是不合适的，在该项目中我们的多个线程可能不是需要去修改它，而是去访问获取数据而已。所以使用读写锁，读大家多可以读，而到了写的时候，一次只有一个线程可以进行写操作。

(4)热点管理模块

4.1热点管理模块思路

服务器端的热点文件管理是对上传的非热点文件进行压缩存储，节省磁盘空间。

而热点文件的判断在于上传的文件的最后一次访问时间是否在热点判断时间之内，比如如果一个文件一天都没有被访问过我们就认为这是一个非热点文件，其实就是当前系统时间，与文件最后一次访问时间之间的时间差是否在一天之内的判断。

而我们需要对上传的文件每隔一段时间进行热点检测，相当于遍历上传文件的存储文件夹，找出所有的文件，然后通过对逐个文件进行时间差的判断，来逐个进行热点处理。

基于这个思想，我们需要将上传的文件存储位置与压缩后压缩文件的存储位置分开。这样在遍历上传文件夹的时候不、至于将压缩过的文件又进行非热点处理了。

关键点：

  • 上传文件有自己的上传存储位置，非热点文件的压缩存储有自己的存储位置
  • 遍历上传存储位置文件夹，获取所有文件信息。
  • 获取每个文件最后一次访问时间，进而完成是否热点文件的判断。
  • 对非热点文件进行压缩存储，删除原来的未压缩文件。
4.2热点管理类设计
// 因为数据数据管理是要在多个模块中访问的，因此将其作为全局数据定义，在此处声明使用即可
extern DataManager* _data;

class HotManager
{
private:
    std::string _back_dir;    // 备份文件路径
    std::string _pack_dir;    // 压缩文件路径
    std::string _pack_suffix; // 压缩包后缀名
    time_t _hot_time;         // 热点判断时间
public:
    HotManager();
    bool RunModule(); // 运行模块，完成热点管理所有功能
};

(5)业务处理模块

5.1设计思想

云备份项目中 ，业务处理模块是针对客户端的业务请求进行处理，并最终给与响应。而整个过程中包含以下要实现的功能：

  • 借助网络通信模块httplib库搭建http服务器与客户端进行网络通信
  • 针对收到的请求进行对应的业务处理并进行响应
    1. 文件上传请求：备份客户端上传的文件，响应上传成功
    2. 文件列表请求：客户端浏览器请求一个备份文件的展示页面，响应页面
    3. 文件下载请求：通过展示页面，点击下载，响应客户端要下载的文件数据，并且实现断点续传
5.2网络通信接口设计

业务处理模块要对客户端的请求进行处理，那么我们就需要提前定义好客户端与服务端的通信，明确客户端发送什么样的请求，服务端接收后应该给与什么样的响应，而这就是网络通信接口的设计。

  1. HTTP文件上传：
    服务器收到如下的请求：

    POST /upload HTTP/1.1
Content-Length：11
Content-Type：multipart/form-data;boundary= ----WebKitFormBoundary+16字节随机字符
------WebKitFormBoundary
Content-Disposition：form-data;filename="a.txt"；
hello world
------WebKitFormBoundary--

    我们规定当服务器收到一个POST方法的/upload请求时，我们认为这是一个文件上传请求，解析该请求，得到文件数据，将数据写入文件中。
    现其返回如下响应：

    // 成功处理
HTTP/1.1 200 OK
Content-Length: 0

// 失败处理(根据不同的错误情况可以设计自己的错误码)
HTTP/1.1 500 NO
Content-Length: 0

  2. HTTP展示页面：
    服务器收到如下的请求：

    GET /listshow HTTP/1.1
...
// 或者如下
GET / HTTP/1.1
...

    响应如下：

    HTTP/1.1 200 OK
Content-length:
Content-Type: text/html

<html> ... </html> <!-- 这是展示页面的数据 -->
    • Content-type：决定了浏览器如何处理响应正文

  3. HTTP文件下载：
    服务器收到如下的请求：

    GET /download/test.txt HTTP/1.1
...

    响应如下：

    HTTP/1.1 200 OK
Content-Length: 100000
ETags: "filename-size-mtime一个能够唯一标识文件的数据"
Accept-Ranges: bytes

文件数据

    其中：

    • ETags： 头部字段的作用是存储了一个资源的唯一标识，客户端第一次下载文件的时候，会收到这个响应信息，第二次下载，就会将这个信息发送给服务器，想要让服务器根据这个唯一标识判断这个资源是否被修改过，如果没有被修改过，直接使用原先缓存的数据，不用再重新下载。
      这里我们根据文件名+文件大小+文件最后修改时间来组成一个ETage
      HTTP协议本身对于etag中是什么数据并不关心，只要你服务端能够自己识别就行。
      etag字段不仅仅是缓存会使用到，后边的断点续传也会使用到，段点续传也要保证文件没有被修改过。
    • http协议的Accept-Ranges：bytes字段：用于告诉客户端支持断点续传，并且数据单位以字节作为单位。

  4. HTTP断点续传：
    服务器收到如下的请求：

    GET /download/a.txt http/1.1
Content-Length: 0
If-Range: "文件唯一标识" // 用于服务器判断这个文件与原先下载的文件是否一致（不一致重新下载，一致按照Range范围读取给客户端）
Range: bytes=89-999 // 从第89个字节开始到999字节结束，告诉服务器客户端需要的区间范围

    响应如下：

    HTTP/1.1 206 Partial Content
Content-Length:
Content-Range: bytes 89-999/100000 // 起始-结束/文件大小
Content-Type: application/octet-stream
ETag: "inode-size-mtime一个能够唯一标识文件的数据" // 客户端收到响应保存这个信息
Accept-Ranges: bytes //告诉客户端服务器支持断点续传功能

对应文件从89到999字节的数据

    断点续传：

    • 功能： 当文件下载过程中，因为某种异常而中断，如果再次进行从头下载，如果将之前已经传输的数据再次传输一遍，效率是很低的。因此，断点续传就是从上次下载断开的位置重新下载即可，之前已经传输过的数据将不需要重新传输。
    • 目的： 提高文件的重新传输效率
    • 实现思想： 客户端在下载文件时，要每次接收到数据写入文件后记录自己当前下载的数据量。当异常下载中断时，下次断点续传时，将要重新下载的数据区间（下载的起始位置，结束位置）发送给服务器，服务器收到后，仅仅回传客户端需要的区间数据即可。
    • 考虑问题： 如果上次下载文件之后，这个文件在服务器上被修改之后，则这时不能重新断点续传，而是应该重新进行文件下载操作。

    在http协议中断点续传的实现：主要关键点

    1. 在于能够告诉服务器区间范围
    2. 服务器上要能够检测上一次下载之后这个文件是否被修改过
5.4服务端业务处理类设计
//因为业务处理的回调函数没有传入参数的地方，因此无法直接访问外部的数据管理模块数据
//可以使用lamda表达式解决，但是所有的业务功能都要在一个函数内实现，于功能划分上模块不够清晰
//因此将数据管理模块的对象定义为全局数据,在这里声明一下，就可以在任意位置访问了 
class Service
{
private:
	int _server_port; // IP地址
	std::string _server_ip; // 端口号
	std::string _download_prefix; // 下载请求前缀
    httplib::Server _server; // 使用该变量搭建服务器
private:
    void Upload(const httplib::Request& req, httplib::Response& rsp); // 上传请求处理
    void ListShow(const httplib::Request& req, httplib::Response& rsp); // 获取展示页面
    void Download(const httplib::Request& req, httplib::Response& rsp); // 文件下载请求
public:
    Server();
    bool RunModule();
};

2.客户端功能实现

要实现的功能：自动对指定文件夹中的文件进行备份

进行的模块划分：

  1. 数据管理模块：管理备份的文件信息
  2. 目录遍历模块：获取指定文件夹中的所有文件路径名
  3. 文件备份模块：将需要备份的文件上传备份到服务器

客户端要备份文件，什么文件需要备份，都是通过数据管理判断的

(1)数据管理模块

客户端要实现的功能是对指定文件夹中的文件自动进行备份上传。但是并不是所有的文件每次都需要上传，我们需要能够判断，哪些文件需要上传，哪些不需要，因此需要将备份的文件信息给管理起来，作为下一次文件是否需要备份的判断。因此需要被管理的信息包含以下：

  • 文件路径名称
  • 文件唯一标识：由文件名，最后一次修改时间，文件大小组成的一串信息

其中的信息用来判断一个文件是否需要重新备份：

  1. 文件是否是新增的
  2. 不是新增的，则上次备份后有没有被修改过

客户端的程序开发是在Windows下开发，毕竟大家是在Windows下使用该功能，使用的工具是VS2017以上版本(需要支持C++17)

实现思想：

  1. 内存存储：高访问效率——使用的是hash表——unordered_map

  2. 持久化存储：文件存储

    文件存储涉及到数据序列化：因为在VS中安装Jsoncpp有先麻烦，这里先不用该库，直接自定义序列化格式

    key val：key是文件路径名，val是文件唯一标识，采用key val\nkey val\n的格式（\n为换行）

    文件唯一标识：用来判断上次文件上传后有没有被修改过

(2)文件检测模块实现

这个其实与服务端的文件实用工具类雷同，只是功能需求并没有服务端那么多，复制过来即可。

// 文件实用工具类设计：对文件进行操作
class{
private:
	std::string _filename;
public:
	size_t FileSize(); //获取文件大小
	time_t LastMTime(); // 获取文件最后一次修改时间
	time_t LastATime(); // 获取文件最后一次访问时间
	std::string FileName(); // 获取文件路径名中的文件名称 /abc/test.txt -> test.txt
    std::string FilePath(); // 获取文件相对路径（当获取文件不在当前目录下时，需要根据路径获取）
	bool SetContest(std::string& body); // 向文件写入数据
	bool GetContent(std::string* body); // 获取文件数据
	bool GetPosLen(std::string* body, size_t pos, size_t len); //获取文件指定位置指定长度数据
	bool GetDirectory(std::vector<std::string>* arry); //获取文件目录
    bool Remove(); // 删除当前文件
    bool CreateDirector(); //创建目录
    bool Exits(); //判断文件是否存在
    bool ScanDirectory(std::vector<std::string>* arrry)；
};

(3)数据管理类设计

class DataManager{
private:
    std::unordered_map<std::string, std::string> _table; // 文件路径名称 ： 文件唯一标识
    std::string _back_file;
public:
    DataManager(const std::string back_file);
    bool InitLoad();//程序运行时加载以前的数据
    bool Storage();//持久化存储
    bool Insert(const std::string &key, const std::string &val);
    bool Update(const std::string &key, const std::string &val);
    bool GetOneByKey(const std::string &key, std::string *val);
};

(4)文件备份类设计

客户端需要将指定文件夹中的文件备份到服务器上

流程如下：

  1. 遍历指定文件夹，获取文件信息
  2. 逐一判断文件是否需要备份
  3. 需要备份的文件进行上传备份
#define SERVER_ADDR "43.143.x.x"
#define SERVER_PORT 9191
class Backup
{
private:
    std::string _back_dir; // 要监控的文件夹
    DataManager* _data;
public:
    Backup(const std::string& backdir, const std::string& backup_file);
    bool RunModule(); // 运行模块
    std::string GetFileIdantifier(const std::string& filename); // 获取文件唯一标识
    bool IsCanBeUpload(const std::string& filename); // 判断文件是否需要备份
    bool Upload(const std::string& filename); // 上传文件
};
榶曲
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于阿里云的一般性系统安全措施介绍
shiter编写程序的艺术
09-06 1270
文章大纲1. 基于阿里云的典型生产环境安全架构简介1.1 网络安全1.2 主机安全1.3数据库安全1.4应用安全1.5日志2. 源代码管理2.1源代码安全性保障2.2源代码的授权访问2.3源代码的复制和传播2.4源代码平台日常管理3. 堡垒机访问控制3.1概述3.2权限控制3.3堡垒机的授权访问4. RDS数据库访问控制4.1概述4.2RDS数据账号权限控制4.3白名单5. 数据备份\恢复5.1备份系统日常管理5.2日常巡检管理6. ACM应用配置管理6.1目的6.2ACM作用6.3ACM管理维护7. 应用
C++项目：云备份
m0_51364183的博客
03-16 2056
项目简介 实现一个类似于云盘的功能来备份客户端的文件，服务器根据客户端的请求进行处理，并根据热点管理进行压缩存储，客户端也可以自行下载文件，且服务器端支持通过浏览器进行查看与下载以及断点续传功能。 环境配置 linux，VS019，高版本g++ jsoncpp httplib和bundle库的安装 工具介绍 使用httplib库进行http服务器的搭建，我们更关注服务器的业务处理。 使用bundle库进行压缩解压缩存储 使用jsoncpp库对于内存中的文件进行持久化存储到我们的磁盘中 项目模
有哪些主流的存储云灾备方案？
架构师技术联盟
01-27 1081
混合云作为一个关键能力，越来越吸引公众的眼球了。从技术上讲，混合云是把外部公有云和私有云或企业传统的内部IT环境整合成更具功能性的解决方案。而混合云的关键就是在于中间的连...
基于Java+SpringBoot+Vue前后端分离仓库管理系统设计实现
热门推荐
java李阳勇的博客
04-04 6万+
仓库管理系统进行了字典管理、公告管理、用户管理、物资管理、物资申请管理、仓库员管理、统计报表等服务。设备采用关联数据库里的MySQL做为全面的数据库，合理存放数据，合理备份数据，确保数据稳定性。除此之外，程序流程还具备程序流程所需要的所有功能，大大提升了实际操作安全度，使库房管理系统软件从概念迈向实际，真真正正提升了信息资源管理效率。
【云存储】主流分布式文件系统介绍
dvlinker的技术专栏
07-12 2万+
本文概要性介绍几大主流分布式文件系统，给大家提供一定的参考。
金蝶系统服务器上怎样备份文件,金蝶服务器数据库备份
weixin_30990387的博客
08-11 1449
金蝶服务器数据库备份 内容精选换一换云服务器备份：云服务器备份可以对普通服务器进行整机备份或部分磁盘备份，不适用于部署了数据库等应用的服务器。支持备份弹性云服务器ECS和裸金属服务器BMS，成本相对于VBS较高，适合对需要备份整个服务器和快速发放服务器的场景。可以使用备份恢复至原服务器，或者使用备份创建镜像，也可以将备份复制至其他区域。云硬盘备份：云硬盘备份仅针对磁盘进行备云服务器备份在支持崩溃一...
服务器文件备份拓扑图,云服务器拓扑图
weixin_35048609的博客
08-13 1680
云服务器拓扑图 内容精选换一换精简视图提供了云服务器资源概况和状态的可视化统计结果，帮助您直观的了解云服务器资源。在精简视图中，您可以快速获取弹性云服务器基本信息、登录信息、配置信息、监控信息。精简视图提供了云服务器资源概况和状态的可视化统计结果，直观的了解云服务器资源。请按以下步骤切换至精简视图：登录管理控制台。单击管理控制台左上角的，选择区域和项目。选择“计算 >一台云服务器同一时刻可以...
一个基于SpringBoot+Vue前后端分离学生宿舍管理系统详细设计实现
java李阳勇的博客
09-19 1万+
本论文主要论述了如何使用springboot开发一个学生学生宿舍管理系统，本系统将严格按照软件开发流程进行各个阶段的工作，采用B/S架构，面向对象编程思想进行项目开发。在引言中，作者将论述学生宿舍管理系统的当前背景以及系统开发的目的，后续章节将严格按照软件开发流程，对系统进行各个阶段分析设计。 学生宿舍管理系统的主要使用者分为管理员、宿管员、学生和维修员，实现功能包括管理员：首页、系统用户（管理员、学生、宿管员、维修员）、楼宇管理、宿舍管理、学生管理、申请换寝、请假报备、报修申请、问题反馈、缺
HarmonyOS云开发基础认证【最新题库 满分答案】
_考不上研究生不改名的博客
11-21 3万+
1.应用架构的演进依次经历了微服务架构、单体架构、Serverless架构等阶段。（错误） 2.鸿蒙应用可以使用Arkts开发（正确） 3.认证服务在绑定微信账号后就不能再绑定QQ账号了。 （错误） 4.认证服务手机号码登录需要填写国家码。（正确） 5.自己构建的账号系统可以加入到认证服务中。 （正确） 6.认证服务不同站点的数据是独立的。（正确） 7.Serverless是云计算下一代的默认计算范式。（正确） 8.邮箱用户发送验证码的模板是可以修改的。（错误） 认证服务提供了端侧验证token的。（正确）
快速理解复杂系统组成学习内容整合
张彦峰的博客
02-03 3万+
复杂系统是由多个相互关联、相互作用的组件组成的大型系统，通过这些组件的协同工作来完成特定的任务或提供特定的服务。在设计复杂系统时，通常会考虑以下五个关键模块：接入系统 (Access System)+应用系统 (Application System)+基础平台 (Foundation Platform)+中间件 (Abundant External Middleware)+支撑系统 (Supporting System)
XXX大学云数据中心的备份容灾系统解决方案.docx
09-18
总结来说，XXX大学的云数据中心备份容灾系统解决方案旨在通过先进的存储设备和一体化备份容灾系统，构建一个高效、可靠且适应未来发展的信息基础架构，以确保教育信息化的稳定和安全。这样的系统对于高等教育机构来...
金蝶云星空系统操作手册
02-20
该系统的操作手册是指导用户有效使用系统的重要参考资料，涵盖了从基础设置到高级功能的各个方面。以下是对手册中可能包含的关键知识点的详细解释： 1. **系统登录与界面导航**：首先，手册会介绍如何登录金蝶云...
手机通讯录备份系统，基于servlet+MySQL实现.zip
08-16
《手机通讯录备份系统：基于Servlet+MySQL的实现详解》 在现代生活中，手机通讯录作为个人信息的重要载体，其安全性和可备份性显得尤为重要。本文将深入探讨如何使用Servlet技术结合MySQL数据库，构建一个手机...
远程文件备份系统
04-29
文件备份是远程文件备份系统的基础，它涉及到复制服务器上的文件到另一处存储介质上。备份的主要目标是能够在需要时恢复数据，比如硬件故障、软件错误或者恶意攻击。在这个过程中，"异地备份"起到了关键作用，它意味...
边云协同的分布式云基础设施管理系统.pdf
08-08
此外，对于基于StarlingX的分布式云基础设施管理系统设计与功能实现，需要重点考虑以下几个方面： 1. 系统的可扩展性：能够支持海量资源和服务的动态添加和调整。 2. 系统的健壮性：保证系统能够抵御故障，并且具有...
mysql主从复制搭建
qq_2382495516的博客
09-04 1009
主从同步搭建，传统模式和基于gtid模式。
GitHub图床
tzy18739738749的博客
09-06 581
GitHub图床
GitHub使用教程
AngeliaXue的博客
08-27 1635
创建远程仓库后，在电脑创建本地仓库，下载git并安装，使用git bash(windows命令行工具)和github建立连接，完成代码的上传下载。1) 在本地生成连接的密钥对，生成命令：ssh-keygen -t rsa -C “git账号”， 按路径找到密钥对。去本地打开bash命令行，执行clone命令，就可以执行相关的推拉等git命令了。输入命令，在选择yes后显示成功就说明绑定成功了。3) 通过git bash验证是否绑定成功。2) 绑定ssh密钥。2. Git和GitHub绑定。
GitHub Copilot Issue in Visual Studio Code “Status Ready (disabled)“
最新发布
weixin_46254816的博客
09-06 246
@[TOC](GitHub Copilot Issue in Visual Studio Code “Status Ready (disabled)”GitHub Copilot is not providing code suggestions. Extension settings indicate that it’s enabled globally.In the extensions tab settings, it shows as “disable,” That means it is enab
北京联合大学高校校园云存储系统设计与实现
接下来，文档详细描述了系统的部署过程和各个功能模块的实现细节，包括用户认证、文件存储、备份策略等。在功能测试环节，对系统性能、稳定性、安全性等方面进行了全面的验证，确保了系统的可靠运行。 最后，作者对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

榶曲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值