云备份服务端——实用类工具实现

一，文件实用类设计实现

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

我们对文件的操作主要有以下几种，也就是我们文件实用类需要实现的功能

• 获取文件大小
• 获取文件最后一次修改时间（客户端在判断文件是否需要上传时需要用到）
• 获取文件最后一次访问时间（判断文件是否属于热点文件就是通过最后一次访问时间）
• 获取文件路径中的文件名
• 向文件写入数据、获取文件数据
• 获取文件指定位置，指定长度的数据（断点重传功能的实现需要该接口）
• 判断文件是否存在
• 创建文件目录、浏览文件目录
• 压缩文件、解压文件
• 删除文件

设计接口如下

class FileUtil
    {
    public:
        //获取文件大小
        size_t size();
        //获取文件最后一次修改时间&最后一次访问时间
        time_t LastMTime();
        time_t LastATime();
        //获取文件路径名中的文件名
        std::string FileName();
        //向文件写入数据&向文件读取数据
        bool SetContent(const std::string& body);
        bool GetContent(std::string* body);
        //获取文件指定位置指定长度字符串
        bool GetPosLen(std::string* body,size_t pos,size_t len);
        //判断文件是否存在
        bool Exists();
        //创建文件目录&获取文件目录
        bool CreateDirectory();
        bool ScanDirectory();
        //压缩文件&解压文件
        bool Compress(const std::string& packname);
        bool UnCompress(const std::string& filename);

        bool Remove();

    private:
        std::string _filename;
    };

代码实现如下

注意创建目录和浏览目录文件用到了filesystem库，该库使用手册如下所示

Filesystem library - cppreference.com

namespace fs=std::experimental::filesystem;
    class FileUtil
    {
    public:
        FileUtil(const std::string &filename)
            : _filename(filename)
        {
        }
        // 获取文件大小
        size_t FileSize()
        {
            struct stat st;
            if (stat(_filename.c_str(), &st) < 0)
            {
                std::cout << "get file attributes failed" << std::endl;
                return -1;
            }
            return st.st_size;
        }
        // 获取文件最后一次修改时间&最后一次访问时间
        time_t LastMTime()
        {
            struct stat st;
            if (stat(_filename.c_str(), &st) < 0)
            {
                std::cout << "get file attributes failed" << std::endl;
                return -1;
            }
            return st.st_mtime;
        }
        time_t LastATime()
        {
            struct stat st;
            if (stat(_filename.c_str(), &st) < 0)
            {
                std::cout << "get file attributes failed" << std::endl;
                return -1;
            }
            return st.st_atime;
        }
        // 获取文件路径名中的文件名
        //./abc/test.c ->test.c
        std::string FileName()
        {
            int pos = _filename.find_last_of("/");
            if (pos < 0)
            {
                std::cout << "filename error" << std::endl;
                return nullptr;
            }
            return _filename.substr(pos + 1);
        }
        // 获取文件指定位置指定长度字符串
        bool GetPosLen(std::string *body, size_t pos, size_t len)
        {
            std::ifstream ifs(_filename, std::ios::binary);
            if (ifs.is_open() == false)
            {
                std::cout << "open file failed" << std::endl;
                return false;
            }

            size_t size = this->FileSize();
            if (pos + len > size)
            {
                std::cout << "Get filecontent is be illegal" << std::endl;
                return false;
            }
            ifs.seekg(pos, ifs.beg);
            body->resize(size);
            ifs.read(&(*body)[0], len);
            if (ifs.good() == false)
            {
                std::cout << "read file failed" << std::endl;
                return false;
            }
            ifs.close();
            return true;
        }

        // 向文件写入数据&向文件读取数据
        bool SetContent(const std::string &body)
        {
            std::ofstream ofs(_filename, std::ios::binary);
            if (ofs.is_open() == false)
            {
                std::cout << "SetContent open file failed" << std::endl;
                return false;
            }

            ofs.write(&body[0], body.size());
            if (ofs.good() == false)
            {
                std::cout << "write file failed" << std::endl;
                return false;
            }
            ofs.close();
            return true;
        }

        bool GetContent(std::string *body)
        {
            size_t fsize = this->FileSize();
            return GetPosLen(body, 0, fsize);
        }

        // 判断文件是否存在
        bool Exists()
        {
            struct stat sm;
            return stat(_filename.c_str(), &sm) == 0;
        }

        // 创建文件目录&获取文件目录
        bool CreateDirectory()
        {
            if(Exists()) return true;
            return fs::create_directories(_filename);
        }
        bool ScanDirectory(std::vector<std::string> *arry)
        {
            for (auto &i : fs::directory_iterator(_filename))
            {
                if(fs::is_directory(i)==true)//如果文件是路径名则跳过
                {
                    continue;
                }
                arry->push_back(fs::path(i).relative_path().string());
            }
            return true;
        }
        // 压缩文件&解压文件
        bool Compress(const std::string &packname)
        {
            // 1.读取文件内容
            std::string filebody;
            if (GetContent(&filebody) == false)
            {
                std::cout << "get file body failed" << std::endl;
                return false;
            }
            // 2.压缩获取的内容
            std::string packbody;
            packbody = bundle::pack(bundle::LZIP, filebody);
            // 3.将压缩的数据放到压缩包文件中
            FileUtil fu(packname);
            if (fu.SetContent(packbody) == false)
            {
                std::cout << "compress write failed" << std::endl;
                return false;
            }
            return true;
        }
        bool UnCompress(const std::string &filename)
        {
            // 1.读取压缩文件内容
            std::string packbody;
            if (GetContent(&packbody) == false)
            {
                std::cout << "get pack file body failed" << std::endl;
                return false;
            }
            // 2.解压读到的内容
            std::string filebody;
            filebody = bundle::unpack(packbody);
            // 3.将解压后的内容放入文件中
            FileUtil fu(filename);
            if (fu.SetContent(filebody) == false)
            {
                std::cout << "file write failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Remove()
        {
            if (Exists() == false)
            {
                std::cout << "object file unexist" << std::endl;
                return false;
            }
            remove(_filename.c_str());
            return true;
        }

    private:
        // 用于类内使用
        bool exists(const std::string &filename)
        {
            struct stat sm;
            return stat(filename.c_str(), &sm) == 0;
        }

    private:
        std::string _filename;
    };

测试代码

#include "util.hpp"

void Utiltest()
{
    // 测试大小，最后修改时间，最后访问时间
    mjw_cloud::FileUtil fu("./test1.txt");
    std::cout << fu.FileSize() << std::endl;
    std::cout << fu.LastMTime() << std::endl;
    std::cout << fu.LastATime() << std::endl;
    std::cout << "--------------------------------------" << std::endl;

    // 测试获取文件名，文件写入，文件读取
    std::cout << fu.FileName() << std::endl;
    std::string write("hello,word\n");
    std::cout << write << ":";
    fu.SetContent(write);
    std::string read;
    fu.GetContent(&read);
    std::cout << read << std::endl;
    std::cout << "--------------------------------------" << std::endl;

    // 压缩文件，解压文件
    fu.Compress("./test1.lzip");
    std::cout << "压缩成功\n"
              << std::endl;
    fu.UnCompress("./test1_lzip.txt");
    std::cout << "解压成功\n"
              << std::endl;

    std::cout << "--------------------------------------" << std::endl;

    // 创建目录.获取文件目录
    mjw_cloud::FileUtil ex("./a/b/c");
    ex.CreateDirectory();
    std::vector<std::string> vs;
    ex.ScanDirectory(&vs);
    for(auto v:vs)
    {
        std::cout<<v<<std::endl;
    }

    std::cout << "--------------------------------------" << std::endl;

    // 序列化
    const char *name1 = "张三";
    int age1 = 18;
    float grade1[3] = {77.1, 64.74, 56.11};
    Json::Value val;
    val["姓名"] = name1;
    val["年龄"] = age1;
    val["成绩"].append(grade1[0]);
    val["成绩"].append(grade1[1]);
    val["成绩"].append(grade1[2]);
    std::string str;
    mjw_cloud::JsonUtil::Serialize(val, &str);
    std::cout << str << std::endl;
    std::cout << "--------------------------------------" << std::endl;

    Json::Value root;

    mjw_cloud::JsonUtil::UnSerialize(str, &root);
    const char *name2 = root["姓名"].asCString();
    int age2 = root["年龄"].asInt();
    float grade2[3] = {0};
    grade2[0] = root["成绩"][0].asFloat();
    grade2[1] = root["成绩"][1].asFloat();
    grade2[2] = root["成绩"][2].asFloat();

    std::cout << "姓名：" << name2 << std::endl;
    std::cout << "年龄：" << age2 << std::endl;
    std::cout << "--------------------------------------" << std::endl;
}

结果如下

二，Json实用类实现

该类主要是对Json序列化反序列化的通用代码进行一个封装，减少重复代码的实用

/*util.hpp*/
    class JsonUtil
    {
    public:
        static bool Serialize(const Json::Value &root, std::string *str)
        {
            Json::StreamWriterBuilder swb;
            std::shared_ptr<Json::StreamWriter> writer_ptr(swb.newStreamWriter());
            std::ostringstream sst;
            writer_ptr->write(root, &sst);
            *str = sst.str();
            return true;
        }
        static bool UnSerialize(const std::string &str, Json::Value *root)
        {
            std::string err;
            Json::CharReaderBuilder crb;
            std::shared_ptr<Json::CharReader> read_ptr(crb.newCharReader());
            read_ptr->parse(str.c_str(), str.c_str() + str.size(), root, &err);
            return true;
        }
    };