• 服务端业务设计及源码

    本篇有点长，并且包含源码，希望可以结合文章注释看源码，可以通过目录进行跳转

    目录

    一、服务端主要功能划分

    二、服务端模块划分

    三、文件工具模块的实现

    文件工具类需要实现的功能：

    1.构造函数、获取文件名的实现

    2.获取文件大小以及两个时间的功能实现

    3.文件的读和写

    4.目录的两个功能、文件是否存在

    5.文件的压缩与解压缩、文件删除

    6.文件内容的序列化和反序列化的功能

    util.hpp源码

    四、配置文件及配置文件的管理

    ​编辑

    配置文件

    配置文件管理模块

    单例类

    json::Value数据类型转换

    五、数据管理模块的实现

    描述

    组织

    a.读写锁

    b.持久化存储原理

    c.需要持久化储存数据的地方

    六、热点管理模块

    热点管理模块的实现逻辑

    hot.hpp源码

    七、服务端业务处理模块

    业务请求处理

    文件上传请求处理

    模块的业务逻辑

    数据的解包和打包

    展示请求处理

    html页面

    下载请求处理

    Etag

    断点续传功能实现原理

    代码实现逻辑

    源码

    一些小细节

    server.hpp源码

    一、服务端主要功能划分

    1、支持文件上传功能

    2、支持客户端文件辈分列表查看功能

    3、支持文件下载功能（还有文件下载被意外中断时，再次下载可以接着下载的功能—断点续传）

    4、热点功能管理（对长时间无访问的文件进行压缩）

    二、服务端模块划分

    1、文件工具模块（双端都会进行大量的文件操作，通过这个模块可以降低操作难度）

    2、数据管理模块（管理备份的文件信息，以便于及时存取）

    3、网络通信模块（实现与客户端的网络通信）

    4、业务处理模块（上传、查看、下载）

    5、热点管理模块（对长时间无访问的文件进行压缩）

    三、文件工具模块的实现

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

    文件工具类需要实现的功能：

    • 文件名的获取（文件名是会携带自己的地址的，我们有时仅仅需要获取到单纯的文件名）
    • 文件大小的获取
    • 文件最后一次修改时间以及最后一次访问时间（用于服务热点管理模块）
    • 文件的读写
    • 目录的创建功能（会用到两个目录——正常存储目录、非热点文件压缩目录）
    • 遍历目录的功能（管理文件需要获取上面两个目录里面的文件名）
    • 判断文件是否存在
    • 文件内容的序列化与反序列化
    • 文件的压缩以及解压缩
    • 删除文件（压缩和解压缩需要将原文件删除）

    以下就是需要实现的函数,在util.hpp实现：

    1. /*util.hpp*/
    2. namespace cloud{
    3.     class FileUtil{
    4.      private:
    5.        std::string _filename;
    6.         public:
    7.        FileUtil(const std::string &name);
    8.        size_t FileSize();
    9.        time_t LastATime();//最后一次访问时间
    10.        time_t LastMTime();//最后一次修改时间
    11.        std::string FileName();
    12.        bool GetPosLen(std::string *content, size_t pos, size_t len);//获取文件pos到len的内容
    13.        bool GetContent(std::string *content);
    14.        bool SetContent(std::strint *content);
    15.        bool Compress(const std::string &packname);
    16.        bool UnCompress(const std::string &filename);
    17.        bool Exists();
    18.        bool CreateDirectory();
    19.        bool ScanDirectory(std::vector *arry);
    20.     };
    21. }

    1.构造函数、获取文件名的实现

    1. FileUtil(const std::string &filename):_filename(filename){}
    2. std::string FileName()
    3. {
    4. 	size_t pos;
    5. 	std::string filename="/"+_filename;
    6. 	pos=filename.find_last_of("/");//找到最后一个‘/’后面就是我们不带路径的文件名了
    7. 	if(pos==std::string::npos)
    8. 	{
    9. 		std::cout<<"find name failed!(util.hpp)\n";
    10. 		exit;
    11. 	}
    12. 	return filename.substr(pos+1);
    13. }

    查找文件名时需要注意的是linux的路径分隔符是‘/’而Windows的分隔符是“\\”，所以这段代码适用于linux却不适用于windows下，不具有良好的跨平台性。

    由于我们的客户端是针对的Windows的环境，为了后续代码的可移植性，我们可以写成：

    1. std::string FileName()
    2. {
    3. 	/*size_t pos;
    4. 	std::string filename="/"+_filename;
    5. 	pos=filename.find_last_of("/");
    6. 	if(pos==std::string::npos)
    7. 	{
    8. 		std::cout<<"find name failed!(util.hpp)\n";
    9. 		exit(1);
    10. 	}*/
    11. 	return std::experimental::filesystem::path(_filename).filename().string();
    12. }

    这样可以直接获取到不带路径的文件名

    2.获取文件大小以及两个时间的功能实现

    1. 			int64_t FileSize()
    2. 			{
    3. 				struct stat st;
    4. 				if(stat(_filename.c_str(),&st)<0)
    5. 				{
    6. 					std::cout<<"get file size failed!\n";
    7. 					return -1;
    8. 				}
    9. 				return st.st_size;
    10.  
    11. 			}
    12. 			time_t LastMTime(){
    13. 				struct stat st;
    14. 				if(stat(_filename.c_str(),&st)<0)
    15. 				{
    16. 					std::cout<<"get file last mtimg failed!\n";
    17. 					return -1;
    18. 				}
    19. 				return st.st_mtime;
    20. 			}
    21. 	
    22. 			time_t LastATime(){
    23. 				struct stat st;
    24. 				if(stat(_filename.c_str(),&st)<0)
    25. 				{
    26. 					std::cout<<"get file last atimg failed!\n";
    27. 					return -1;
    28. 				}
    29. 				return st.st_atime;
    30. 			}

    介绍一下stat是一个用于获取文件属性的函数，它需要传入一个stat结构体来储存属性，我们利用这一特性获取文件属性。

    1. #include 
    2. #include 
    3. #include 
    4. struct stat 
    5. { 
    6.  dev_t st_dev; /* 文件所在设备的 ID */ 
    7.  ino_t st_ino; /* 文件对应 inode 节点编号 */ 
    8.  mode_t st_mode; /* 文件对应的模式 */ 
    9.  nlink_t st_nlink; /* 文件的链接数 */ 
    10.  uid_t st_uid; /* 文件所有者的用户 ID */ 
    11.  gid_t st_gid; /* 文件所有者的组 ID */ 
    12.  dev_t st_rdev; /* 设备号（指针对设备文件） */ 
    13.  off_t st_size; /* 文件大小（以字节为单位） */ 
    14.  blksize_t st_blksize; /* 文件内容存储的块大小 */ 
    15.  blkcnt_t st_blocks; /* 文件内容所占块数 */ 
    16.  struct timespec st_atim; /* 文件最后被访问的时间 */ 
    17.  struct timespec st_mtim; /* 文件内容最后被修改的时间 */ 
    18.  struct timespec st_ctim; /* 文件状态最后被改变的时间 */
    19. };

    3.文件的读和写

    1. 			bool GetPosLen(std::string &body,size_t pos,size_t len)
    2. 			{
    3. 				if(this->FileSize()
    4. 				{
    5. 					std::cout<<"GetPosLen failed!\n";
    6. 					return false;
    7. 				}
    8. 				std::ifstream ifs;
    9. 				ifs.open(_filename,std::ios::binary);
    10. 				if(ifs.good()==false)
    11. 				{
    12. 					std::cout<<"open file failed!\n";
    13. 					return false;
    14. 				}
    15. 				ifs.seekg(pos,std::ios::beg);//使ifs的指针指向pos位置
    16. 				body.resize(len);
    17. 				ifs.read(&body[0],len);
    18. 				if(!ifs.good())
    19. 				{
    20. 					std::cout<<"read failede!\n";
    21. 					return false;
    22. 				}
    23. 				ifs.close();
    24. 				return true;
    25. 			}
    26. 			bool GetContent(std::string *body)
    27. 			{ 
    28. 				size_t fsize=this->FileSize();
    29. 				return GetPosLen(*body,0,fsize);
    30. 			}
    31.  
    32. 			bool SetContent(const std::string &body)
    33. 			{
    34. 				std::ofstream ofs;
    35. 				ofs.open(_filename,std::ios::binary);
    36. 				if(ofs.is_open()==false)
    37. 				{
    38. 					std::cout<<"write open failede!\n";
    39. 					return false;
    40. 				}
    41. 				ofs.write(&body[0],body.size());
    42. 				if(!ofs.good())
    43. 				{
    44. 					std::cout<<"write failede!\n";
    45. 					return false;
    46. 				}
    47. 				ofs.close();
    48. 				return true;
    49. 			}

    两个流的使用：ofstream是从内存到硬盘——set，ifstream是从硬盘到内存——get，其实所谓的流缓冲就是内存空间

    4.目录的两个功能、文件是否存在

    1.             #include 			
    2.             namespace fs=namespace fs=std::experimental::filesystem;
    3.             bool Exists()
    4. 			{
    5. 				return fs::exists(_filename);
    6. 			}
    7. 			bool CreateDirectory()
    8. 			{	
    9. 				if(this->Exists()==true)
    10. 				{
    11. 					return true;	
    12. 				}		
    13. 				return fs::create_directories(_filename);
    14. 			}
    15. 			bool ScanDirectory(std::vector* arry )
    16. 			{	
    17. 				for(auto& p:fs::directory_iterator(_filename))
    18. 				{	
    19. 					if(fs::is_directory(p))
    20. 					continue;
    21. 					arry->push_back(fs::path(p).relative_path().string());
    22. 				}
    23. 				return true;
    24. 			}

    namespace fs=std::experimental::filesystem这样的写法是C++17引入的一个命名空间别名，用于访问文件系统相关的功能。

    std::experimental::filesystem提供了一组函数和类，用于操作文件、目录和路径例如删除、创建和重命名文件或目录，以及获取文件或目录的属性信息等。

    包括我们上面获取文件名的方法二就是它提供的。

    使用小例子：

    1. #include 
    2. #include 
    3.  
    4. namespace fs = std::experimental::filesystem;
    5.  
    6. int main() {
    7.     // 创建目录
    8.     fs::create_directory("my_directory");
    9.  
    10.     // 创建文件
    11.     fs::path file_path = "my_directory/my_file.txt";
    12.     std::ofstream file(file_path);
    13.     file << "Hello, World!";
    14.     file.close();
    15.  
    16.     // 判断文件是否存在
    17.     if (fs::exists(file_path)) {
    18.         std::cout << "File exists." << std::endl;
    19.     }
    20.  
    21.     // 获取文件大小
    22.     std::cout << "File size: " << fs::file_size(file_path) << " bytes" << std::endl;
    23.  
    24.     // 删除文件
    25.     fs::remove(file_path);
    26.  
    27.     // 删除目录
    28.     fs::remove("my_directory");
    29.  
    30.     return 0;
    31. }

    5.文件的压缩与解压缩、文件删除

    1.             bool Compress(const std::string &packname)
    2. 			{
    3. 				std::string body;
    4. 				this->GetContent(&body);
    5. 				std::string packed=bundle::pack(bundle::LZIP,body);
    6. 				FileUtil fu(packname);
    7. 				if(fu.SetContent(packed)==false)
    8. 				{
    9. 					std::cout<<"compress failed!\n";
    10. 					return false;	
    11. 				}
    12. 				return true;
    13. 			}
    14. 			bool UnCompress(const std::string packname)
    15. 			{	
    16. 				std::string body;
    17. 				this->GetContent(&body);
    18. 				std::string upbody2;
    19. 				upbody2=bundle::unpack(body);
    20. 				FileUtil fu(packname);
    21. 				if(fu.SetContent(upbody2)==false)
    22. 				{
    23. 					std::cout<<"uncompress failed!\n";
    24. 					return false;
    25. 				}
    26. 				return true;			
    27. 			}
    28. 			bool Remove(){
    29. 				if(this->Exists()==false)
    30. 					return true;
    31. 				remove(_filename.c_str());
    32. 				return true;
    33. 			}

    压缩的方法：

    1. 先获取文件的数据，就是一个字符串
    2. 将字符串压缩，得到压缩后的数据
    3. 创建一个压缩包，将压缩后的数据写入
    4. 最后将原文件删除，不删除也没有节省磁盘空间的作用

    创建压缩包的时候，该压缩包创建的地址取决于你传进来的压缩包位置——在该项目中就是在压缩目录packdir中。

    解压缩的方法：

    1. 获取压缩包中的数据
    2. 将该数据解压
    3. 将建一个文件，并写入解压数据
    4. 删除压缩包

    6.文件内容的序列化和反序列化的功能

    1. class JsonUtil{
    2. 		public:
    3. 			static bool Serialize(Json::Value &root,std::string *str)
    4. 			{
    5. 				Json::StreamWriterBuilder swb;
    6. 				std::unique_ptr sw(swb.newStreamWriter());
    7. 				std::stringstream ss;
    8. 				sw->write(root,&ss);
    9. 				*str=ss.str();
    10. 				return true;
    11. 			}
    12. 			static bool UnSerialize(std::string &str,Json::Value *root)
    13. 			{
    14. 				Json::CharReaderBuilder crb;
    15. 				std::unique_ptr cr(crb.newCharReader());
    16. 				std::string err;
    17. 				bool ret=cr->parse(str.c_str(),str.c_str()+str.size(),root,&err);
    18. 				if(ret==false)
    19. 				{
    20. 					std::cout<<"error:"<
    21. 					return false;
    22. 				}
    23. 				return true;
    24. 			}
    25. };

    json序列化的使用：

    1. 通过StreamWriterBuilder实例化出来一个StreamWriter
    2. 用智能指针进行存储
    3. 调用write函数，将数据序列化后存入ss字符串

    反序列化的使用：

    1. 通过CharReaderBuilder实例化出来一个CharReader
    2. 用智能指针存储
    3. 调用parse函数将反序列化后的数据放入json::Value 变量中

    util.hpp源码

    1. #ifndef __MY_UTIL__
    2. #define __MY_UTIL__
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include"bundle.h"
    10. #include
    11. #include
    12. namespace cloud{
    13. 	namespace fs=std::experimental::filesystem;
    14. 	class FileUtil{		
    15. 		private:
    16. 			std::string _filename;
    17. 		public:
    18. 			FileUtil(const std::string &filename):_filename(filename){}
    19. 			int64_t FileSize()
    20. 			{
    21. 				struct stat st;
    22. 				if(stat(_filename.c_str(),&st)<0)
    23. 				{
    24. 					std::cout<<"get file size failed!\n";
    25. 					return -1;
    26. 				}
    27. 				return st.st_size;
    28.  
    29. 			}
    30. 			time_t LastMTime(){
    31. 				struct stat st;
    32. 				if(stat(_filename.c_str(),&st)<0)
    33. 				{
    34. 					std::cout<<"get file last mtimg failed!\n";
    35. 					return -1;
    36. 				}
    37. 				return st.st_mtime;
    38. 			}
    39. 	
    40. 			time_t LastATime(){
    41. 				struct stat st;
    42. 				if(stat(_filename.c_str(),&st)<0)
    43. 				{
    44. 					std::cout<<"get file last atimg failed!\n";
    45. 					return -1;
    46. 				}
    47. 				return st.st_atime;
    48. 			}
    49. 			std::string FileName()
    50. 			{
    51. 				size_t pos;
    52. 				std::string filename="/"+_filename;
    53. 				pos=filename.find_last_of("/");
    54. 				if(pos==std::string::npos)
    55. 				{
    56. 					std::cout<<"find name failed!(util.hpp)\n";
    57. 					exit;
    58. 				}
    59. 				return filename.substr(pos+1);
    60. 			}
    61.  
    62. 			bool GetPosLen(std::string &body,size_t pos,size_t len)
    63. 			{
    64. 				if(this->FileSize()
    65. 				{
    66. 					std::cout<<"GetPosLen failed!\n";
    67. 					return false;
    68. 				}
    69. 				std::ifstream ifs;
    70. 				ifs.open(_filename,std::ios::binary);
    71. 				if(ifs.good()==false)
    72. 				{
    73. 					std::cout<<"open file failed!\n";
    74. 					return false;
    75. 				}
    76. 				ifs.seekg(pos,std::ios::beg);
    77. 				body.resize(len);
    78. 				ifs.read(&body[0],len);
    79. 				if(!ifs.good())
    80. 				{
    81. 					std::cout<<"read failede!\n";
    82. 					return false;
    83. 				}
    84. 				ifs.close();
    85. 				return true;
    86. 			}
    87. 			bool GetContent(std::string *body)
    88. 			{ 
    89. 				size_t fsize=this->FileSize();
    90. 				return GetPosLen(*body,0,fsize);
    91. 			}
    92.  
    93. 			bool SetContent(const std::string &body)
    94. 			{
    95. 				std::ofstream ofs;
    96. 				ofs.open(_filename,std::ios::binary);
    97. 				if(ofs.is_open()==false)
    98. 				{
    99. 					std::cout<<"write open failede!\n";
    100. 					return false;
    101. 				}
    102. 				ofs.write(&body[0],body.size());
    103. 				if(!ofs.good())
    104. 				{
    105. 					std::cout<<"write failede!\n";
    106. 					return false;
    107. 				}
    108. 				ofs.close();
    109. 				return true;
    110. 			}
    111.  
    112. 			bool Compress(const std::string &packname)
    113. 			{
    114. 				std::string body;
    115. 				this->GetContent(&body);
    116. 				std::string packed=bundle::pack(bundle::LZIP,body);
    117. 				FileUtil fu(packname);
    118. 				if(fu.SetContent(packed)==false)
    119. 				{
    120. 					std::cout<<"compress failed!\n";
    121. 					return false;	
    122. 				}
    123. 				return true;
    124. 			}
    125. 			bool UnCompress(const std::string packname)
    126. 			{	
    127. 				std::string body;
    128. 				this->GetContent(&body);
    129. 				std::string upbody2;
    130. 				upbody2=bundle::unpack(body);
    131. 				FileUtil fu(packname);
    132. 				if(fu.SetContent(upbody2)==false)
    133. 				{
    134. 					std::cout<<"uncompress failed!\n";
    135. 					return false;
    136. 				}
    137. 				return true;			
    138. 			}
    139. 			bool Remove(){
    140. 				if(this->Exists()==false)
    141. 					return true;
    142. 				remove(_filename.c_str());
    143. 				return true;
    144. 			}
    145. 			bool Exists()
    146. 			{
    147. 				return fs::exists(_filename);
    148. 			}
    149. 			bool CreateDirectory()
    150. 			{	
    151. 				if(this->Exists()==true)
    152. 				{
    153. 					return true;	
    154. 				}		
    155. 				return fs::create_directories(_filename);
    156. 			}
    157. 			bool ScanDirectory(std::vector* arry )
    158. 			{	
    159. 				for(auto& p:fs::directory_iterator(_filename))
    160. 				{	
    161. 					if(fs::is_directory(p))
    162. 					continue;
    163. 					arry->push_back(fs::path(p).relative_path().string());
    164. 				}
    165. 				return true;
    166. 			}
    167. };
    168. 	class JsonUtil{
    169. 		public:
    170. 			static bool Serialize(Json::Value &root,std::string *str)
    171. 			{
    172. 				Json::StreamWriterBuilder swb;
    173. 				std::unique_ptr sw(swb.newStreamWriter());
    174. 				std::stringstream ss;
    175. 				sw->write(root,&ss);
    176. 				*str=ss.str();
    177. 				return true;
    178. 			}
    179. 			static bool UnSerialize(std::string &str,Json::Value *root)
    180. 			{
    181. 				Json::CharReaderBuilder crb;
    182. 				std::unique_ptr cr(crb.newCharReader());
    183. 				std::string err;
    184. 				bool ret=cr->parse(str.c_str(),str.c_str()+str.size(),root,&err);
    185. 				if(ret==false)
    186. 				{
    187. 					std::cout<<"error:"<
    188. 					return false;
    189. 				}
    190. 				return true;
    191. 			}
    192. };	
    193. }
    194. #endif

    四、配置文件及配置文件的管理

    配置文件就是用来存放一些不同模块进程需要用到的信息，直接设置一个配置文件利于实现低耦合

    配置文件

    cloud.conf：

    1. {
    2. 	"hot_time" :30,
    3. 	"server_port": 9090,
    4. 	"server_ip":"0.0.0.0",
    5. 	"downloap_prefix": "/downloap/",
    6. 	"packfile_suffix":".lz",
    7. 	"pack_dir":"./packdir/",
    8. 	"back_dir":"./backdir/",
    9. 	"backup_file":"./cloud.dat"
    10.  
    11. }

    配置文件管理模块

    重点是实现读取配置文件，源码：

    1. #ifndef __MY_CONFIG__
    2. #define __MY_CONFIG__
    3. #include
    4. #include"util.hpp"
    5. namespace  cloud
    6. {		
    7. 	#define CONFIG_FILE "./cloud.conf"
    8. 		class Config
    9. 		{
    10. 			private:
    11. 			Config()
    12. 			{		
    13. 				ReadConfigFile();
    14. 			}
    15.  
    16. 			static Config *_instance;
    17. 			static std::mutex _mutex;
    18. 			private: 
    19. 			int  _hot_time;
    20. 			int _server_port;
    21. 			std::string _server_ip;
    22. 			std::string _download_prefix;
    23. 			std::string _packfile_suffix;
    24. 			std::string _pack_dir;
    25. 			std::string _back_dir;
    26. 			std::string _backup_file;
    27. 			bool ReadConfigFile()
    28. 			{
    29. 				FileUtil fu(CONFIG_FILE);
    30. 				std::string body;
    31. 				if(fu.GetContent(&body)==false)
    32. 				{
    33. 					std::cout<<"get content false\n";
    34. 					return false;	
    35. 				}
    36. 				Json::Value root;
    37. 				if(JsonUtil::UnSerialize(body,&root)==false)
    38. 				{
    39. 					std::cout<<"UnSerialize false! \n";
    40. 					return false;
    41. 				}
    42. 				
    43. 				_hot_time=root["hot_time"].asInt();
    44. 				_server_port=root["server_port"].asInt();
    45. 				_server_ip=root["server_ip"].asString();
    46. 				_download_prefix=root["downloap_prefix"].asString();
    47. 				_packfile_suffix=root["packfile_suffix"].asString();
    48. 				_pack_dir=root["pack_dir"].asString();
    49. 				_back_dir=root["back_dir"].asString();
    50. 				_backup_file=root["backup_file"].asString();
    51. 				return true;
    52. 			}
    53. 			public:
    54. 			static Config * GetInstance()
    55. 			{
    56. 				if(_instance==nullptr)
    57. 				{
    58. 				    _mutex.lock();
    59. 				    if(_instance==nullptr)
    60.    			    	{
    61. 				    	_instance=new(Config); 
    62. 				    }
    63.                     _mutex.unlock();
    64. 				}
    65. 				return _instance;
    66. 				
    67. 			}
    68. 			int GetHotTime()
    69. 			{
    70. 				return _hot_time;
    71. 			}
    72. 			int GetServerPort()
    73. 			{
    74. 				return _server_port;
    75. 			}
    76. 			std::string GetServerIp()
    77. 			{
    78. 				return _server_ip;
    79. 			}
    80. 			std::string GetDownloadPrefix()
    81. 			{
    82. 				return _download_prefix;
    83. 			}
    84. 			std::string GetPackFileSuffix()
    85. 			{
    86. 				return _packfile_suffix;
    87. 			}
    88. 			std::string GetPackDir()
    89. 			{
    90. 				return _pack_dir;
    91. 			}
    92. 			std::string GetBackDir()
    93. 			{
    94. 				return _back_dir;
    95. 			}
    96. 			std::string GetBackupFile()
    97. 			{
    98. 				return _backup_file;
    99. 			}
    100. 		};	
    101. 	Config* Config::_instance=nullptr;
    102. 	std::mutex Config::_mutex;
    103. }
    104.  
    105. #endif

    单例类

    这里的设计模式是单例类，这样是为了使这个类只有一个实例，并为其提供全局访问点。

    我们这个程序的Config只需要一个对象即可，单纯的获取配置文件信息就可以了。就比如：

    有些属性型对象也只需要全局存在一个。比如，假设黑体字属性是一种对象，调用黑体字属性对象的函数来让一个字变成黑体。显然并不需要在每创造一个黑体字时就生成一种属性对象，只需要调用当前存在的唯一对象的函数即可。

    单例类的实现：

    • 将构造函数放入private影藏起来，这样别人调用new就不会调用构造函数生成一个对象了。
    • 只有通过调用GetInstance函数才能获取到Config 指针
    • 每次调用GetInstance函数的时候判断一下指针是否为空
    • 为了保证只会存在一个Config指针我们需要对new（Config）这一步操作加锁。

    这样我们就基本实现了一个单例类了。但这里还是有地方需要改进一下，大部分调用这个函数的线程只是只读操作，而这个程序只有一个获取锁的线程可以使用，低并发环境的话还好，但如果是高并发环境的话，成千上万调用这个函数的线程中只有一个可以正常使用就有点扯了，其他都在阻塞，等待锁，这个锁的使用结束后还会有下一个线程使用锁，这里就会一直保持一个低效率的运行。解决方案——既然你只是只读的请求，那我只返回你数据就行了，除了指针为空时。

    皆大欢喜。

    这里不只是指针是唯一一个，锁也是唯一一个，两个都是static成员变量，静态成员变量只能在类内声明类外定义

    格式：类型+xx::变量名+初始化             xx为作用域，初始化分为自定义变量或内置变量

    json::Value数据类型转换

    json::Value内封装了类型转换的函数，供我们调用————将数据准确的转换成我们需要的类型。

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

    五、数据管理模块的实现

    操作系统的学习中有一句至理名言：先描述，再组织。

    在这个项目中我们应该怎么描述一个文件呢？

    我们将数据以哈希表的形式储存起来，并且为了避免每一次启动都要重新获取数据或者丢失数据，我们直接将数据持久化储存到文件中，也就是内存到磁盘的存储。

    描述

    1. /*data.hpp*/	
    2.     typedef struct BackInfo{
    3. 		//项目需要查看成员变量，可以直接用struct不保护成员变量
    4. 		bool _pack_flag;
    5. 		size_t _fsize;
    6. 		time_t _atime;
    7. 		time_t _mtime;
    8. 		std::string _real_path;// 文件实际存储路径   或者说文件在下载前的地址back_path
    9. 		std::string _pack_path;//压缩路径
    10. 		std::string _url;
    11. 		bool NewBackInfo(const std::string realpath){
    12. 			cloud::Config* config=cloud::Config::GetInstance();
    13. 			cloud::FileUtil fu(realpath);
    14. 			std::string packdir=config->GetPackDir();
    15. 			std::string packsuffix=config->GetPackFileSuffix();
    16. 			std::string downloapprefix=config->GetDownloadPrefix();
    17. 			this->_pack_flag=false;
    18. 			this->_fsize=fu.FileSize();
    19. 			this->_atime=fu.LastATime();
    20. 			this->_mtime=fu.LastMTime();
    21. 			this->_real_path=realpath;
    22. 			this->_pack_path=packdir+fu.FileName()+packsuffix;
    23. 			this->_url=downloapprefix+fu.FileName();
    24. 			return true;
    25. 		}
    26. 	
    27. 		}BackInfo;

    组织

    1.    /*data.hpp*/
    2.      typedef struct DataManager{
    3. 			std::string _backup_file;
    4. 			pthread_rwlock_t _rwlock;
    5. 			//以url为key值，backinfo为值的图
    6. 			std::unordered_map _table;
    7. 			
    8. 			DataManager()
    9. 			{	
    10. 				_backup_file=Config::GetInstance()->GetBackupFile();
    11. 				pthread_rwlock_init(&_rwlock,NULL);
    12. 				InitLoad();
    13. 			}
    14. 			~DataManager()
    15. 			{
    16. 				pthread_rwlock_destroy(&_rwlock);
    17. 			}
    18.  
    19.  
    20. 			bool Insert(BackInfo &info){
    21. 				pthread_rwlock_wrlock(&_rwlock);
    22. 				_table[info._url]=info;
    23. 				/*for(auto a:_table){
    24. 					std::cout<
    25. 				}*/
    26. 				pthread_rwlock_unlock(&_rwlock);
    27. 				Storage();
    28. 				return true;
    29. 			}
    30. 			bool Updata(BackInfo &info){			
    31. 				pthread_rwlock_wrlock(&_rwlock);
    32. 				_table[info._url]=info;
    33. 				pthread_rwlock_unlock(&_rwlock);
    34. 				Storage();
    35. 				return true;
    36. 			}
    37. 			bool GetOneByUrl(const std::string &url,BackInfo *Info){
    38. 				pthread_rwlock_rdlock(&_rwlock);//读锁
    39. 				auto it=_table.begin();
    40. 				it=_table.find(url);
    41. 				if(it==_table.end()){
    42. 					pthread_rwlock_unlock(&_rwlock);
    43.                     return false;
    44.                 }
    45. 				pthread_rwlock_unlock(&_rwlock);
    46. 				*Info=it->second;
    47. 				return true;
    48. 			}
    49. 			bool GetOneByRealPath(std::string &realpath,BackInfo * info){
    50. 				//直接遍历，通过second的成员来确定
    51. 				pthread_rwlock_rdlock(&_rwlock);//读锁
    52. 				auto it=_table.begin();
    53. 				for(;it!=_table.end();++it){
    54. 					if(it->second._real_path==realpath)
    55. 						*info=it->second;				
    56. 				}
    57. 				if(it==_table.end()){
    58. 				    pthread_rwlock_unlock(&_rwlock);
    59.                 	return false;
    60.                 }
    61. 				pthread_rwlock_unlock(&_rwlock);
    62. 				return true;
    63. 			}
    64. 			bool GetAll(std::vector *arry){
    65. 				pthread_rwlock_rdlock(&_rwlock);
    66. 				auto it=_table.begin();
    67. 				for(;it!=_table.end();++it){
    68. 					arry->push_back(it->second);				
    69. 				}
    70. 				
    71. 				pthread_rwlock_unlock(&_rwlock);
    72. 				return true;
    73. 			}
    74. 			bool InitLoad(){
    75. 				//读取文件
    76. 				FileUtil fu(_backup_file);
    77. 				if(fu.Exists()==false)
    78. 					return true;
    79. 				std::string body;
    80. 				fu.GetContent(&body);
    81. 				Json::Value root;
    82. 				//先反序列化，获取一个Value
    83. 				JsonUtil::UnSerialize(body,&root);
    84. 				//再逐个插入
    85. 				for(int i=0;isize();i++){
    86. 					BackInfo info;
    87. 					info._pack_flag=root[i]["pack_flag"].asBool();
    88. 					info._fsize=root[i]["fsize"].asInt64();
    89. 					info._atime=root[i]["atime"].asInt64();
    90. 					info._mtime=root[i]["mtime"].asInt64();
    91. 					info._real_path=root[i]["real_path"].asString();
    92. 					info._pack_path=root[i]["pack_path"].asString();
    93. 					
    94. 					info._url=root[i]["url"].asString();
    95. 					
    96. 					Insert(info);
    97. 				}
    98. 				return true;
    99.  
    100. 			}
    101. 			bool Storage(){
    102. 				//先获取数据
    103. 				std::vector arry;
    104. 				this->GetAll(&arry);
    105. 				Json::Value root;
    106. 				//遍历存放进value root
    107. 				for(int i=0;isize();i++){
    108. 					Json::Value tem;
    109. 					tem["pack_flag"]=arry[i]._pack_flag;
    110. 					tem["fsize"]=(Json::Value::Int64)arry[i]._fsize;
    111. 					tem["atime"]=(Json::Value::Int64)arry[i]._atime;
    112. 					tem["mtime"]=(Json::Value::Int64)arry[i]._mtime;
    113. 					tem["pack_path"]=arry[i]._pack_path;
    114. 					tem["real_path"]=arry[i]._real_path;
    115. 					tem["url"]=arry[i]._url;
    116. 					root.append(tem);
    117. 				}
    118. 				//将root序列化	
    119. 				std::string body;
    120. 				JsonUtil::Serialize(root,&body);
    121.  
    122. 				//保存至文件完成持久化储存
    123. 				FileUtil fu(_backup_file);
    124. 				fu.SetContent(body);
    125. 				std::cout<<"storage finish"<
    126. 				return true;
    127. 			}
    128. 	}DataManager;

    这里实现了：

    1. 数据的增删查改
    2. 数据的持久化存储
    3. 每次初始化的时候都需要读取持久化的数据

    以下是一些需要注意的地方：

    a.读写锁

    服务器会同时接收多个客户端的请求，每收到一个请求就会创建一个线程执行响应请求（由httplib中的listen实现），因此我们需要注意线程安全问题，在这个项目中线程会访问、读取、修改文件信息，需要用锁解决。但是在这里更合理的处理方式是读写锁——读共享，写互斥。

    • 就是读取的时候是允许数据被多个线程读取的但是不允许读取
    • 写的时候是不允许其他线程读取数据的。

    b.持久化存储原理

    1. 遍历获取所有的backinfo数据
    2. 挨个储存至value变量中
    3. 将value变量组织起来
    4. 将其序列化
    5. 序列化后写入一个文件

    c.需要持久化储存数据的地方

    1. 程序退出的时候
    2. 增加数据的时候
    3. 修改数据的时候———防止程序意外中断导致数据丢失

    源码：

    1. /*data.hpp*/
    2. #ifndef __MY__DATA__
    3. #define	__MY__DATA__
    4. #include
    5. #include
    6. #include
    7. #include"util.hpp"
    8. #include"config.hpp"
    9. namespace cloud{
    10. 	typedef struct BackInfo{
    11. 		//项目需要查看成员变量，可以直接用struct不保护成员变量
    12. 		bool _pack_flag;
    13. 		size_t _fsize;
    14. 		time_t _atime;
    15. 		time_t _mtime;
    16. 		std::string _real_path;// 文件实际存储路径   或者说文件在下载前的地址back_path
    17. 		std::string _pack_path;//压缩路径
    18. 		std::string _url;
    19. 		bool NewBackInfo(const std::string realpath){
    20. 			cloud::Config* config=cloud::Config::GetInstance();
    21. 			cloud::FileUtil fu(realpath);
    22. 			std::string packdir=config->GetPackDir();
    23. 			std::string packsuffix=config->GetPackFileSuffix();
    24. 			std::string downloapprefix=config->GetDownloadPrefix();
    25. 			this->_pack_flag=false;
    26. 			this->_fsize=fu.FileSize();
    27. 			this->_atime=fu.LastATime();
    28. 			this->_mtime=fu.LastMTime();
    29. 			this->_real_path=realpath;
    30. 			this->_pack_path=packdir+fu.FileName()+packsuffix;
    31. 			this->_url=downloapprefix+fu.FileName();
    32. 			return true;
    33. 		}
    34. 	
    35. 		}BackInfo;
    36.  
    37. 	typedef struct DataManager{
    38. 			std::string _backup_file;
    39. 			pthread_rwlock_t _rwlock;
    40. 			//以url为key值，backinfo为值的图
    41. 			std::unordered_map _table;
    42. 			
    43. 			DataManager()
    44. 			{	
    45. 				_backup_file=Config::GetInstance()->GetBackupFile();
    46. 				pthread_rwlock_init(&_rwlock,NULL);
    47. 				InitLoad();
    48. 			}
    49. 			~DataManager()
    50. 			{
    51. 				pthread_rwlock_destroy(&_rwlock);
    52. 			}
    53.  
    54.  
    55. 			bool Insert(BackInfo &info){
    56. 				pthread_rwlock_wrlock(&_rwlock);
    57. 				_table[info._url]=info;
    58. 				/*for(auto a:_table){
    59. 					std::cout<
    60. 				}*/
    61. 				pthread_rwlock_unlock(&_rwlock);
    62. 				Storage();
    63. 				return true;
    64. 			}
    65. 			bool Updata(BackInfo &info){			
    66. 				pthread_rwlock_wrlock(&_rwlock);
    67. 				_table[info._url]=info;
    68. 				pthread_rwlock_unlock(&_rwlock);
    69. 				Storage();
    70. 				return true;
    71. 			}
    72. 			bool GetOneByUrl(const std::string &url,BackInfo *Info){
    73. 				pthread_rwlock_rdlock(&_rwlock);
    74. 				auto it=_table.begin();
    75. 				it=_table.find(url);
    76. 				if(it==_table.end()){
    77. 					pthread_rwlock_unlock(&_rwlock);
    78. 					return false;
    79. 				}
    80. 				pthread_rwlock_unlock(&_rwlock);
    81. 				*Info=it->second;
    82. 				return true;
    83. 			}
    84. 			bool GetOneByRealPath(std::string &realpath,BackInfo * info){
    85. 				//直接遍历，通过second的成员来确定
    86. 				pthread_rwlock_rdlock(&_rwlock);
    87. 				auto it=_table.begin();
    88. 				for(;it!=_table.end();++it){
    89. 					if(it->second._real_path==realpath)
    90. 						*info=it->second;				
    91. 				}
    92. 				if(it==_table.end()){
    93. 					pthread_rwlock_unlock(&_rwlock);
    94. 					return false;
    95. 				}
    96. 				pthread_rwlock_unlock(&_rwlock);
    97. 				return true;
    98. 			}
    99. 			bool GetAll(std::vector *arry){
    100. 				pthread_rwlock_rdlock(&_rwlock);
    101. 				auto it=_table.begin();
    102. 				for(;it!=_table.end();++it){
    103. 					arry->push_back(it->second);				
    104. 				}
    105. 				
    106. 				pthread_rwlock_unlock(&_rwlock);
    107. 				return true;
    108. 			}
    109. 			bool InitLoad(){
    110. 				//读取文件
    111. 				FileUtil fu(_backup_file);
    112. 				if(fu.Exists()==false)
    113. 					return true;
    114. 				std::string body;
    115. 				fu.GetContent(&body);
    116. 				Json::Value root;
    117. 				//先反序列化，获取一个Value
    118. 				JsonUtil::UnSerialize(body,&root);
    119. 				//再逐个插入
    120. 				for(int i=0;isize();i++){
    121. 					BackInfo info;
    122. 					info._pack_flag=root[i]["pack_flag"].asBool();
    123. 					info._fsize=root[i]["fsize"].asInt64();
    124. 					info._atime=root[i]["atime"].asInt64();
    125. 					info._mtime=root[i]["mtime"].asInt64();
    126. 					info._real_path=root[i]["real_path"].asString();
    127. 					info._pack_path=root[i]["pack_path"].asString();
    128. 					
    129. 					info._url=root[i]["url"].asString();
    130. 					
    131. 					Insert(info);
    132. 				}
    133. 				return true;
    134.  
    135. 			}
    136. 			bool Storage(){
    137. 				//先获取数据
    138. 				std::vector arry;
    139. 				this->GetAll(&arry);
    140. 				Json::Value root;
    141. 				//遍历存放进value root
    142. 				for(int i=0;isize();i++){
    143. 					Json::Value tem;
    144. 					tem["pack_flag"]=arry[i]._pack_flag;
    145. 					tem["fsize"]=(Json::Value::Int64)arry[i]._fsize;
    146. 					tem["atime"]=(Json::Value::Int64)arry[i]._atime;
    147. 					tem["mtime"]=(Json::Value::Int64)arry[i]._mtime;
    148. 					tem["pack_path"]=arry[i]._pack_path;
    149. 					tem["real_path"]=arry[i]._real_path;
    150. 					tem["url"]=arry[i]._url;
    151. 					root.append(tem);
    152. 				}
    153. 				//将root序列化	
    154. 				std::string body;
    155. 				JsonUtil::Serialize(root,&body);
    156.  
    157. 				//保存至文件完成持久化储存
    158. 				FileUtil fu(_backup_file);
    159. 				fu.SetContent(body);
    160. 				std::cout<<"storage finish"<
    161. 				return true;
    162. 			}
    163. 	}DataManager;
    164. }
    165.  
    166.  
    167.  
    168.  
    169.  
    170. #endif

    六、热点管理模块

    热点管理模块的实现逻辑

    这个项目我们会接受到文件，然后将这两个文件放入两个文件夹进行管理，这个过程就是热点文件管理模块：

    非热点文件就是上次修改时间距离现在超过了我们在配置文件设置的hot_time，这个hot_time将通过单例类的获取hot_time的方式获取

    1. 接收文件放入backdir文件夹
    2. 模块遍历这个目录时发现非热点文件
    3. 压缩，更新信息，删除源文件

    这里的更新信息指的是我们维护的数据信息——数据管理模块描述中

    是否被压缩的标识，文件下载时会通过这个标识来辨识这个文件是否需要解压缩。

    有同学可能会产生疑问：热点文件管理只负责压缩吗？都不需要解压缩吗？

    解压缩会在文件下载的时候进行，那时候也会将压缩标识改为false。

    hot.hpp源码

    1. #ifndef __MY__HOT__
    2. #define __MY__HOT__
    3. #include"data.hpp"
    4. #include"util.hpp"
    5. #include
    6. #include
    7. extern cloud::DataManager * _data;
    8. namespace cloud{
    9. 	class HotManager{
    10. 		private:
    11. 			std::string _back_dir;//文件储存路径
    12. 			std::string _pack_dir;//文件压缩路径
    13. 			std::string _packfile_suffix;
    14. 			int _hot_time;
    15. 			//遍历文件夹，对比热点时间，压缩文件，删除源文件
    16. 		public:
    17. 			HotManager(){
    18. 				Config *config=Config::GetInstance();
    19. 				_hot_time=config->GetHotTime();
    20. 				_packfile_suffix=config->GetPackFileSuffix();
    21. 				_back_dir=config->GetBackDir();
    22. 				_pack_dir=config->GetPackDir();
    23. 				//不创建目录的话会在遍历那里报错
    24. 				FileUtil tmp1(_pack_dir);
    25. 				FileUtil tmp2(_back_dir);
    26. 				tmp1.CreateDirectory();
    27. 				tmp2.CreateDirectory();
    28. 			}
    29. 			bool HotJudge(std::string filename){
    30. 				time_t cur=time(NULL);
    31. 				FileUtil fu(filename);
    32. 				time_t latime=fu.LastATime();
    33. 				if(cur-latime>_hot_time)
    34. 					return false;//非热点文件
    35. 				return true;
    36. 			}
    37. 			bool RunModule(){
    38. 				while(1){
    39. 					std::vector arry;
    40. 					FileUtil fu(_back_dir);
    41. 					fu.ScanDirectory(&arry);
    42. 					for(auto a:arry){
    43. 						//遍历文件夹
    44. 						BackInfo bi;
    45. 						if(HotJudge(a)==true){
    46. 						//热点文件
    47. 						continue;
    48. 						}
    49. 						//非热点文件
    50. 						if(_data->GetOneByRealPath(a,&bi)==false){
    51. 							//没获取到，非热点文件
    52. 							bi.NewBackInfo(a);
    53. 						}
    54. 						FileUtil fu(a);
    55. 						//压缩文件
    56. 						fu.Compress(bi._pack_path);
    57. 						//删除源文件，更新
    58. 						bi._pack_flag=true;
    59. 						_data->Updata(bi);
    60. 						fu.Remove();					
    61. 					}	
    62. 					usleep(1000);//防止循环太快占用资源
    63. 			
    64. 				}
    65. 				
    66. 			}		
    67.  
    68. };
    69.  
    70. }
    71. #endif

    结合代码谈谈实现逻辑: 

    1. 使用这个模块前，构造函数会获取需要的配置文件信息（hot_time，文件储存目录、文件压缩目录）
    2. 使用这个模块时，需要创建一个线程来调用RunModule函数，这是一个死循环，只有这样才能一直监视backdir目录
    3. 进入循环，我们每次循环都需要获取一次目录下所有文件名，然后通过hotjudge函数判断是否为非热点文件。是热点文件的话直接continue，遍历下一个文件
    4. 如果是非热点文件的话就对其压缩、更新信息、删除源文件

    七、服务端业务处理模块

    我们将通信模块哦与业务处理模块进行了合并，网络通信通过httplib实现。

    业务请求处理

    1. 文件上传请求：备份客户端上传的一个文件，响应上传成功
    2. 文件列表请求：客户端浏览器请求一个备份文件信息的展示页面，响应页面
    3. 文件下载请求：通过展示页面，点击下载，响应客户端需要下载的文件数据

    框架

    1. namespace cloud{
    2. 	class Service{
    3. 		//搭建服务器，进行业务处理
    4. 		//有三个请求upload、listshow、download
    5. 		private:
    6. 		int _server_port;
    7. 		std::string _server_ip;
    8. 		std::string _download_prefix;
    9. 		httplib::Server _server;
    10. 		static void Upload(const httplib::Request &req,httplib::Response &rsp){};
    11. 		static void ListShow(const httplib::Request &req,httplib::Response &rsp){};
    12. 		static void Download(const httplib::Request &req,httplib::Response &rsp){};
    13. 		public:
    14. 		Service(){
    15. 			Config *config=Config::GetInstance();
    16. 			_download_prefix=config->GetDownloadPrefix();	
    17. 			_server_port=config->GetServerPort();	
    18. 			_server_ip=config->GetServerIp();
    19. 			//编译器会自己调用Server的默认构造函数		
    20. 		}
    21. 		void RunModule(){
    22. 			_server.Post("/upload",Upload);
    23. 			_server.Get("/showlist",ListShow);
    24. 			_server.Get("/",ListShow);
    25. 			std::string download_url=_download_prefix+"(.*)";
    26. 			_server.Get(download_url,Download);
    27. 			_server.listen(_server_ip.c_str(),_server_port);//110.41.149   9090
    28. 		}
    29. };	
    30. }

    这里的listen在接受到不同的请求后就生成对应的线程去处理。

    文件上传请求处理

    1. static void Upload(const httplib::Request &req,httplib::Response &rsp){
    2. 			if(req.has_file("file")==false)
    3. 				return ;
    4. 			//获取req中的文件，再创建一个文件放入储存路径
    5. 			const auto & file=req.get_file_value("file");
    6. 			//file.filename--文件名  file.content--文件内容
    7. 			std::string back_dir=Config::GetInstance()->GetBackDir();
    8. 			//怕传过来的文件名含有多个‘/’怕坏文件名统一性
    9.  
    10. 			std::string realpath=back_dir+FileUtil(file.filename).FileName();//文件储存在back_path
    11. 			FileUtil fu(realpath);
    12.  
    13. 			fu.SetContent(file.content);//将数据写入文件中
    14.  
    15. 			BackInfo bi;
    16. 			bi.NewBackInfo(realpath);
    17. 			_data->Insert(bi);	
    18. 			return ;
    19. 		}

    模块的业务逻辑

    1. 从req中获取文件信息（包括文件内容、文件名）
    2. 在backdir目录创建一个同名的文件
    3. 给这个文件赋值
    4. 载入这个文件的信息以供管理

    数据的解包和打包

    这里双端用的都是struct MultipartFormData对数据进行储存。这个对象是用hash表储存的，get_file_value就是传入一个key值然后再传出second。

    我们客户端上传文件就是通给这个对象赋值进行包装的。

    1. 		bool Upload(std::string& filename) {
    2. 			//1.获取文件数据
    3. 			std::string body;
    4. 			FileUtil fu(filename);
    5. 			fu.GetContent(&body);
    6. 			//2.创建本地客户端
    7. 			httplib::Client client(SERVER_IP, SERVER_PORT);
    8. 			httplib::MultipartFormData item;
    9. 			item.content = body;//文件内容
    10. 			item.filename = fu.FileName();
    11. 			item.name = "file";//标识符，和服务端是一一对应的
    12. 			item.content_type = "application/octet-stream";
    13. 			httplib::MultipartFormDataItems items;
    14. 			items.push_back(item);
    15. 			//3.上传
    16. 			auto res = client.Post("/upload",items);
    17. 			if (!res || res->status != 200) {
    18. 				return false;
    19. 			}
    20. 			return true;
    21. 		}

    展示请求处理

    html页面

    我们需要知道展示页面是什么样子的，这样才能让服务器知道要怎么返回一个页面：

    1. <html>
    2. 	<head>
    3. 		<title>Downloadtitle>
    4. 	head>
    5. 	<body>
    6. 		<h1>Downloadh1>
    7. 		<table>
    8. 			<tr>
    9. 				<td><a href="/download/test.txt">test.txta>td>
    10. 				<td align="right">  2021-12-29 10:10:10 td>
    11. 				<td align="right">  28k td>
    12. 			tr>
    13. 		table>
    14. 	body>
    15. html>

    tr中间就是服务器需要遍历获取并且写入的数据

    一旦接收到了申请查看页面的请求，我们就返回上面的页面。

    方法很简单，通过字节流将上面的页面格式写入body就可以了

    1. 		static void ListShow(const httplib::Request &req,httplib::Response &rsp){
    2. 			//先获取所有文件数据，然后遍历依次返回数据
    3. 			std::vector arry;
    4. 			_data->GetAll(&arry);
    5. 			//接下来组织html页面信息
    6. 			std::stringstream ss;
    7. 			ss<<"Download";
    8. 			ss<<"
      Download
      ";
    9. 			for(auto &a:arry){
    10. 				ss<<"
      11. ";	
    11. 				std::string filename =FileUtil(a._real_path).FileName();
    12. 				ss<<"
      13. ";//写入下载地址
    13. 				ss<<"
      14. ";
    14. 				ss<<"
      15. ";
    15. 				ss<<"
      16. ";
    16. 			}
    17. 			ss<<"
      18. "<""<<TimeToStr(a._mtime)<<""<1024<<"k 
      "      ;
    18. 			rsp.body=ss.str();
    19. 			rsp.set_header("Content-Type","text/html");
    20. 			rsp.status=200;
    21. 			return ;
    22. 		}

    返回时我们需要给req设置的一些东西：

    • 有内容返回body肯定是不能落下的
    • 设置报头，标识body的类型——这决定了浏览器是以什么方式、什么编码读取这个文件
    • status就是状态编码，200表示正常

    下载请求处理

    Etag

    http的ETag字段：储存了资源的唯一标识，文件内容改变这个也会改变

    客户端第一次下载文件的时候，会收到这个响应信息。第二次下载会将这个响应信息（通过If-Range）发送给服务器，如果服务器对比后发现这个位移标识没变，就直接使用原先缓存的数据下载。

    http协议对ETag的内容并不关心，只需要服务端能自己标识就行了，我们采用的ETag格式为：

    “文件名-文件大小-最后一次修改时间”

    断点续传功能实现原理

    有时候文件下载时意外中断了，再次下载就需要重新下载了，这样无疑是低效率的提现，为了提高效率，我们需要实现断点续传功能。这样在恢复链接时，可以接着上次下载的数据继续下载。

    原理：

    1. 客户端每次下载的时候需要记录自己当前下载的数据量。
    2. 当异常中断时，下次下载将需要下载的数据区间传给服务器
    3. 服务器接受到后就仅需要传送给客户端需要的数据即可。

    需要考虑的问题：如果在上次下载之后，这个文件在服务器被修改了（通过自定义的ETag和If-Range对比可以判断），我们就需要重新下载文件，如果没修改就继续下载即可。

    这部分本来是我想要自己进行编写的功能，但是我们调用了httplib库，httplib库已经解决了这个问题。

    代码实现逻辑

    1. 获取req的If-Range，将其和ETag对比
    2. 如果是一样，就返回文件数据（httplib实现了断点续传，返回客户端发送来的请求区间）
    3. 不一致，就重新下载。

    源码

    1. 		static std::string GetETag(BackInfo info){
    2. 			//filename-fsize-lastmtime
    3. 			FileUtil fu(info._real_path);
    4. 			std::string etag;
    5. 			etag+=fu.FileName();
    6. 			etag+="-";
    7. 			etag+=info._fsize;
    8. 			etag+="-";
    9. 			etag+=info._mtime;
    10. 			return etag;
    11. 		}
    12.  
    13.         static void Download(const httplib::Request &req,httplib::Response &rsp){
    14. 			//获取路径，然后获取文件信息
    15. 			BackInfo bi;
    16. 			_data->GetOneByUrl(req.path,&bi);//该路径其实就是网页申请的下载路径
    17. 			//查看是否压缩，压缩就解压缩
    18. 			if(bi._pack_flag==true){
    19. 				//解压缩后要删除压缩包，更改压缩信息
    20. 				FileUtil fu(bi._pack_path);      
    21. 				fu.UnCompress(bi._real_path);
    22. 				fu.Remove();
    23. 				bi._pack_flag=false;
    24. 				_data->Updata(bi);
    25. 			}
    26. 			//获取etag并将其和客户端传上来的进行对比
    27. 			std::string etag;
    28. 			int retrans=false;
    29. 			if(req.has_header("If-Range")){
    30. 				etag=req.get_header_value("If-Range");
    31. 				if(etag==GetETag(bi)){
    32. 					retrans=true;
    33. 				}
    34. 			}
    35. 			//读取文件内容，写入rsp
    36. 			FileUtil fu2(bi._real_path);
    37. 			if(retrans==false){
    38. 				fu2.GetContent(&rsp.body);
    39. 				//返回header
    40. 				rsp.set_header("Accept-Ranges","bytes");
    41. 				rsp.set_header("ETag",GetETag(bi));
    42. 				rsp.set_header("Content-Type","application/octet-stream");//说明这是一个字节流，表现在网页上就是点击即可下载
    43. 				rsp.status=200;
    44. 			}
    45. 			else{
    46. 				//httplib内部实现了我们的取件请求也就是断点续传的处理
    47. 				//只需要用户将文件读取到rsp.body里去，它内部会根据请求区间，从body中取出指定区间数据进行响应。
    48.                 //std::string range=req.get_header_value("Range");
    49.                 //bytes= start-end 
    50. 				fu2.GetContent(&rsp.body);
    51. 				rsp.set_header("Accept-Ranges","bytes");
    52. 				rsp.set_header("Content-Type","application/octet-stream");//说明这是一个字节流，表现在网页上就是点击即可下载
    53. 				rsp.set_header("ETag",GetETag(bi));
    54. 				rsp.status=206;
    55. 			}
    56. 			return ;
    57. 		}

    一些小细节

    • Accept-Range：bytes报头表示该服务器支持范围请求
    • status=206表示已经实现部分get请求
    • Content-Type：application/octet-stream表示这是一个字节流，浏览器处理字节流的默认方式就是下载，所以说展示界面点击文件名浏览器就会自动下载文件。

    点击文件名

     点击完浏览器就会想服务器发送一个Get请求，服务器返回一个字节流，浏览器对字节流默认下载——行云流水。

    server.hpp源码

    1. #ifndef __MY__SERVICE__
    2. #define __MY__SERVICE__
    3. #include"httplib.h"
    4. #include"util.hpp"
    5. #include"config.hpp"
    6. #include
    7. extern cloud::DataManager *_data;
    8. namespace cloud{
    9. 	class Service{
    10. 		//搭建服务器，进行业务处理
    11. 		//有三个请求upload、listshow、download
    12. 		private:
    13. 		int _server_port;
    14. 		std::string _server_ip;
    15. 		std::string _download_prefix;
    16. 		httplib::Server _server;
    17. 		static void Upload(const httplib::Request &req,httplib::Response &rsp){
    18. 			if(req.has_file("file")==false)
    19. 				return ;
    20. 			//获取req中的文件，再创建一个文件放入储存路径
    21. 			const auto & file=req.get_file_value("file");
    22. 			//file.filename--文件名  file.content--文件内容
    23. 			std::string back_dir=Config::GetInstance()->GetBackDir();
    24. 			//怕传过来的文件名含有多个‘/’怕坏文件名统一性
    25.  
    26. 			std::string realpath=back_dir+FileUtil(file.filename).FileName();//文件储存在back_path
    27. 			FileUtil fu(realpath);
    28.  
    29. 			fu.SetContent(file.content);//将数据写入文件中
    30.  
    31. 			BackInfo bi;
    32. 			bi.NewBackInfo(realpath);
    33. 			_data->Insert(bi);	
    34. 			return ;
    35. 		}
    36. 		static std::string TimeToStr(time_t time){
    37. 			return std::ctime(&time);	
    38. 			
    39. 		}
    40. 		static void ListShow(const httplib::Request &req,httplib::Response &rsp){
    41. 			//先获取所有文件数据，然后遍历依次返回数据
    42. 			std::vector arry;
    43. 			_data->GetAll(&arry);
    44. 			//接下来组织html页面信息
    45. 			std::stringstream ss;
    46. 			ss<<"Download";
    47. 			ss<<"
      Download
      ";
    48. 			for(auto &a:arry){
    49. 				ss<<"
      50. ";	
    50. 				std::string filename =FileUtil(a._real_path).FileName();
    51. 				ss<<"
      52. ";//写入下载地址
    52. 				ss<<"
      53. ";
    53. 				ss<<"
      54. ";
    54. 				ss<<"
      55. ";
    55. 			}
    56. 			ss<<"
      57. "<""<<TimeToStr(a._mtime)<<""<1024<<"k 
      "      ;
    57. 			rsp.body=ss.str();
    58. 			rsp.set_header("Content-Type","text/html");
    59. 			rsp.status=200;
    60. 			return ;
    61. 		}
    62. 		
    63. 		static std::string GetETag(BackInfo info){
    64. 			//filename-fsize-lastmtime
    65. 			FileUtil fu(info._real_path);
    66. 			std::string etag;
    67. 			etag+=fu.FileName();
    68. 			etag+="-";
    69. 			etag+=info._fsize;
    70. 			etag+="-";
    71. 			etag+=info._mtime;
    72. 			return etag;
    73. 		}
    74. 		static void Download(const httplib::Request &req,httplib::Response &rsp){
    75. 			//获取路径，然后获取文件信息
    76. 			BackInfo bi;
    77. 			_data->GetOneByUrl(req.path,&bi);//该路径其实就是网页申请的下载路径
    78. 			//查看是否压缩，压缩就解压缩
    79. 			if(bi._pack_flag==true){
    80. 				//解压缩后要删除压缩包，更改压缩信息
    81. 				FileUtil fu(bi._pack_path);      
    82. 				fu.UnCompress(bi._real_path);
    83. 				fu.Remove();
    84. 				bi._pack_flag=false;
    85. 				_data->Updata(bi);
    86. 			}
    87. 			//获取etag并将其和客户端传上来的进行对比
    88. 			std::string etag;
    89. 			int retrans=false;
    90. 			if(req.has_header("If-Range")){
    91. 				etag=req.get_header_value("If-Range");
    92. 				if(etag==GetETag(bi)){
    93. 					retrans=true;
    94. 				}
    95. 			}
    96. 			//读取文件内容，写入rsp
    97. 			FileUtil fu2(bi._real_path);
    98. 			if(retrans==false){
    99. 				fu2.GetContent(&rsp.body);
    100. 				//返回header
    101. 				rsp.set_header("Accept-Ranges","bytes");
    102. 				rsp.set_header("ETag",GetETag(bi));
    103. 				rsp.set_header("Content-Type","application/octet-stream");//说明这是一个二进制数据流，表现在网页上就是点击即可下载
    104. 				rsp.status=200;
    105. 			}
    106. 			else{
    107. 				//httplib内部实现了我们的取件请求也就是断点续传的处理
    108. 				//只需要用户将文件读取到rsp.body里去，它内部会根据请求区间，从body中取出指定区间数据进行响应。
    109. 				fu2.GetContent(&rsp.body);
    110. 				rsp.set_header("Accept-Ranges","bytes");
    111. 				rsp.set_header("Content-Type","application/octet-stream");//说明这是一个二进制数据流，表现在网页上就是点击即可下载
    112. 				rsp.set_header("ETag",GetETag(bi));
    113. 				rsp.status=206;
    114. 			}
    115. 			return ;
    116. 		}
    117. 		
    118. 		public:
    119. 		Service(){
    120. 			Config *config=Config::GetInstance();
    121. 			_download_prefix=config->GetDownloadPrefix();	
    122. 			_server_port=config->GetServerPort();	
    123. 			_server_ip=config->GetServerIp();
    124. 			//编译器会自己调用Server的默认构造函数		
    125. 		}
    126. 		void RunModule(){
    127. 			_server.Post("/upload",Upload);
    128. 			_server.Get("/showlist",ListShow);
    129. 			_server.Get("/",ListShow);
    130. 			std::string download_url=_download_prefix+"(.*)";
    131. 			_server.Get(download_url,Download);
    132. 			_server.listen(_server_ip.c_str(),_server_port);//110.41.149   9090
    133. 		}
    134. };
    135. 	
    136. 	
    137. 	
    138. 	
    139. }
    140.  
    141.  
    142.  
    143. #endif

  • 相关阅读:
    10个常用的损失函数解释以及Python代码实现
    Allegro输出带等长规则的Excel操作指导
    OpenCV 4.10 发布
    浅尝Spring注解开发_Bean生命周期及执行过程
    Java——》MESI
    网络安全（黑客）自学
    【Linux集群教程】05 集群存储 - NFS
    redis（1）NoSQL数据库简介
    敦煌网“星云计划”：助商家开拓新流量和新玩法，测评补单快速提高产品排名和销量
    某云负载均衡获取客户端真实IP的问题
  • 原文地址：https://blog.csdn.net/qq_64484137/article/details/137080778