devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

CPP项目：Boost搜索引擎

作者：羊村懒王 | 2024-03-13 00:37:42

赞

踩

CPP项目：Boost搜索引擎

1.项目背景

对于Boost库来说，它是没有搜索功能的，所以我们可以实现一个Boost搜索引擎来实现一个简单的搜索功能，可以更快速的实现Boost库的查找，在这里，我们实现的是站内搜索，而不是全网搜索。

2.对于搜索引擎的相关宏观理解

3.搜索引擎技术栈及项目环境

技术栈：c/c++,c++11,STL,Boost准标准库，Jsoncpp，cppjieba，cpp-httplib,html5,css,js,

Ajax,jQuery，不使用爬虫。

项目环境：Centos 7云服务器，vim/gcc(g++)/Makefile , vs code

4.正排索引、倒排索引

正排索引：通过文档ID寻找文档内容：

比如：文档1：西游记有一只猴子

           文档2：西游记有一只六耳猕猴

文档1西游记有一只猴子
文档2西游记有一只六耳猕猴

目标文档进行分词（目的：方便建立倒排索引和查找）：

文档1：西游记/有/一只/猴子/

文档2：西游记/有/一只/六耳/猕猴/

注：停止词：了，的，吗，a，the，一般我们在分词的时候可以不考虑

倒排索引：根据文档内容，分词，整理不重复的各个关键字，对应联系到文档ID的方案。

关键字：文档ID, weight(权重)
西游记文档1.文档2
有文档1，文档2
一只文档1.文档2
猴子文档1
六耳文档2
猕猴文档2

模拟一次查找的过程：

用户输入：西游记->倒排索引中查找->提取出文档id->根据正排索引->找到文档内容,通过文档标题，内容，URL，对文档内容进行摘要->构建响应结果。

5.编写数据去标签与数据清洗的模块 Parser

5.1 什么是标签：

我们既然要去标签，那么就要知道什么是标签，比如：

  1. //原始数据 -> 去标签之后的数据
  2. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
  3. "http://www.w3.org/TR/html4/loose.dtd">
  4. <html> <!--这是一个标签-->
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>Chapter 30. Boost.Process</title>
  8. <link rel="stylesheet" href="../../doc/src/boostbook.css" type="text/css">
  9. <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
  10. <link rel="home" href="index.html" title="The Boost C++ Libraries BoostBook Documentation
  11. Subset">
  12. <link rel="up" href="libraries.html" title="Part I. The Boost C++ Libraries (BoostBook
  13. Subset)">
  14. <link rel="prev" href="poly_collection/acknowledgments.html" title="Acknowledgments">
  15. <link rel="next" href="boost_process/concepts.html" title="Concepts">

上述代码中，<!--这是一个标签-->，这就是一个标签，<>这些标签对于我们的搜索来说是没有意义的，所以我们需要去掉这些标签。标签分为两类，一类是只有一个的<>,一类是有两个的<>,</>,这些都是我们需要去掉的。

5.2 搜索内容

由于我们使用的是本地搜索，即将Boost库下载下来，通过本地搜索，然后再通过建立网站，实现站内搜索。所以第一步，下载Boost库：

Boost库官网：Boost C++ Libraries

Boost库下载：Index of main/release/1.84.0/source

目前只需要boost库/doc/html目录下的html文件，用它来进行建立索引，不需要使用其他的

下载完成之后，我们把他上传到云服务器上。之后建立一个保存*.html文件的文件夹，我们之后需要使用它，然后再创建一个保存去标签之后的*.html文件的文档，方便我们搜索。

5.3 具体逻辑实现

  1. const std::string src_path = "/home/SSS/data/input";//搜索路径
  2. const std::string output = "/home/SSS/data/raw_html/raw.txt";//保存文档
  3.  
  4. typedef struct DocInfo
  5. {
  6.   std::string title;   // 文档标题
  7.   std::string content; // 文档标题
  8.   std::string url;     // 文档url
  9. } DocInfo_t;
  10.  
  11. // &: 输入
  12. //*: 输出
  13. //&：输入输出
  14. bool EnumFile(const std::string &src_path, std::vector<std::string> *files_list);
  15. bool ParseHtml(const std::vector<std::string> &files_list, std::vector<DocInfo_t> *results);
  16. bool SaveHtml(const std::vector<DocInfo_t> &results,const std::string& output);
  17.  
  18. int main()
  19. {
  20.   std::vector<std::string> files_list; //保存文件路径
  21.   //递归式的把每个html文件名带路径，保存到files_list中，方便后期进行一个一个的文件进行读取
  22.   if (!EnumFile(src_path, &files_list))
  23.   {
  24.     std::cerr << "enum file name error1" << std::endl;
  25.     return 1;
  26.   }
  27.   // 按照files_list读取每个文件的内容，并进行解析
  28.   std::vector<DocInfo_t> results;
  29.   if (!ParseHtml(files_list, &results))
  30.   {
  31.     //std::cout<<"1"<<std::endl;
  32.     std::cerr << "enum file name error2" << std::endl;
  33.     return 2;
  34.   }
  35.   std::cout<<results.size()<<std::endl;
  36.   //把解析完毕的各个文件内容，写入到output,按照\3作为每个文档的分割符 
  37.   if (!SaveHtml(results,output))
  38.   {
  39.     std::cerr << "enum file name error3" << std::endl;
  40.     return 3;
  41.   }
  42.   return 0;
  43. }

第一个函数通过对文件路径的处理，将我们所需要的html文件保存到vector中，方便我们后续查找。第二个函数进行对html文件的处理，将html文件的标题，内容，url进行提取，保存到数组中。第三个函数将处理好的内容放入到文件中，方便后续进行建立索引。

三个函数的具体实现过程：

第一步：

  1. bool EnumFile(const std::string &src_path, std::vector<std::string> *files_list)
  2. {
  3.   namespace fs = boost::filesystem;
  4.   fs::path root_path(src_path);
  5.   if (!fs::exists(root_path)) // 判断文件路径是否存在，在这里我们使用Boost库中的函数，判断文件路径是否存在
  6.   {
  7.     std::cerr << "root_path not exits" << std::endl;
  8.     return false;
  9.   }
  10.   fs::recursive_directory_iterator end; // 递归的判断文件
  11.   for (fs::recursive_directory_iterator iter(root_path); iter != end; iter++)
  12.   {
  13.     if (!fs::is_regular_file(*iter)) // 文件是否为普通文件，Boost库中判断文件是否为普通文件。
  14.     {
  15.       continue;
  16.     }
  17.     if (iter->path().extension() != ".html") // 文件是否为html文件，Boost库函数
  18.     {
  19.       continue;
  20.     }
  21.     files_list->push_back(iter->path().string());//将所有带路径的html保存在files_list,方便后续进行文本分析
  22.     
  23.   }
  24.   return true;
  25. }

第二步：

  1. namespace ns_util
  2. {
  3.  class FileUtil
  4.     {   
  5.     public:
  6.         static bool ReadFile(const std::string &file_path, std::string *out)
  7.         {
  8.             std::ifstream in(file_path,std::ios::in);
  9.            if(!in.is_open())//c++中文件处理函数
  10.            {
  11.                 std::cerr <<"open in error"<<std::endl;
  12.                 return false;
  13.            }
  14.             std::string line;
  15.             while(std::getline(in,line))//将文件内容写入到（string）out中
  16.             {
  17.                 *out += line;
  18.                 //std::cout<<line<<std::endl;
  19.             }
  20.             in.close();//关闭文件！！！
  21.             return true;
  22.         }
  23.     };
  24. }
  25.  
  26. // 文档标题
  27. static bool ParseTitle(const std::string &file, std::string *title)
  28. {
  29.  
  30.   std::size_t begin = file.find("<title>");//对文档标题进行处理，由于网页的标题保存在<title>标
  31.   //签中，以</title>结尾，所以中间的内容就是我们所要的标题
  32.   //std::cout<<begin<<std::endl;
  33.   if (begin == std::string::npos)
  34.   {
  35.      //std::cout<<"1:"<<begin<<std::endl;
  36.     return false;
  37.   }
  38.   std::size_t end = file.find("</title>");
  39.   if (end == std::string::npos)
  40.   {
  41.     return false;
  42.   }
  43.   begin += std::string("<title>").size();
  44.  
  45.   if (begin > end)
  46.   {
  47.     return false;
  48.   }
  49.   *title = file.substr(begin, end - begin);//标题
  50.   
  51.   //std::cout<<*title<<std::endl;
  52.   return true;
  53. }
  54. // 对内容进行解析
  55. static bool ParseContent(const std::string &file, std::string *content)
  56. {
  57.   //去标签，基于一个简易的状态机
  58.   enum status
  59.   {
  60.     LABLE,
  61.     CONTENT
  62.   };
  63.   enum status s = LABLE;
  64.   for (char c : file)
  65.   {
  66.     switch (s)
  67.     {
  68.     case LABLE:
  69.       if (c == '>')
  70.         s = CONTENT;
  71.       break;
  72.     case CONTENT :
  73.       if (c == '<')
  74.         s = LABLE;
  75.         else 
  76.         {
  77.           // 不想保留原始文件中的\n,用\n作为html解析之后文本的分隔符
  78.           if (c == '\n') c = ' ';
  79.           content->push_back(c);
  80.         } 
  81.         break;
  82.       default:
  83.         break;
  84.     }
  85.   }
  86.   return true;
  87. }
  88. static bool ParseUrl(const std::string &file_path, std::string *url)
  89. {
  90.   std::string url_head = "https://www.boost.org/doc/libs/1_78_0/doc/html";
  91.   std::string url_tail = file_path.substr(src_path.size());
  92.  
  93.   *url = url_head + url_tail;//文档的url
  94.   return true;
  95. }
  96. // 对内容进行解析
  97. bool ParseHtml(const std::vector<std::string> &files_list, std::vector<DocInfo_t>* results)
  98. {
  99.   for (const std::string &file : files_list)
  100.   {
  101.     std::string result; // 读取文件
  102.     if (!ns_util::FileUtil::ReadFile(file, &result))
  103.     {
  104.       continue;
  105.     }
  106.     DocInfo_t doc;
  107.     // 解析文件，提取title
  108.     if (!ParseTitle(result, &doc.title))
  109.     {
  110.       //std::cout<<"1"<<std::endl;
  111.       continue;
  112.     }
  113.     // 解析文件内容，去标签
  114.     if (!ParseContent(result, &doc.content))
  115.     {
  116.       continue;
  117.     }
  118.     // 解析内容，获得url
  119.     if (!ParseUrl(file, &doc.url))
  120.     {
  121.       continue;
  122.     }
  123.  
  124.     results->push_back(std::move(doc)); // 减少拷贝次数，提高效率
  125.     //std::cout<<results->back()->title<<std::endl;
  126.   }
  127.   return true;
  128. }

ParseHtml()这个函数内部包含四个函数，其中包括读取文件，将文件标题，内容，url分别提取出来，放入到数组中。

网站处理：

官网URL样例： https /www.boost.org/doc/libs/1_79_0/doc/html/accumulators.html
我们下载下来的url样例：boost_1_79_0 / doc / html / accumulators.html
我们拷贝到我们项目中的样例：data / input / accumulators.html
url_head = “https://www.boost.org/doc/libs/1_79_0/doc/html”;
url_tail = (data / input)(删除) / accumulators.html->url_tail = / accumulators.html
url = url_head + url_tail; 相当于形成了一个官网链接。

5.4建立索引

实现原理：

建立索引我们需要建立正排索引和倒排索引，这需要我们建立一个struct,用来保存文档的title,content,url,id。因为正排索引是通过文档id来寻找文档内容的，所以我们可以通过一个数组来实现id的编号，倒排索引是通过关键字来锁定在哪一个文档id里面的，所以我们可以通过建立一个哈希映射来完成，通过关键字来寻找文档id。由于我们只需要建立一次索引，所以我们可以通过创建一个单例模式来实现所以得初始化。

由于我们通过关键字可以映射到多个文档内容中，所以我们可以通过建立相关性的方式来排序我们所查找得的文档内容。

相关性的建立：由于相关性的问题涉及到的范围十分的大，可能有相近词，同义词，不连续的关键词，字符拆分的不确定性等等，在这里我们使用关键字在文档中出现的频次来决定。由于关键字可以出现在标题中，也可以出现在文档内容中，所以我们通过简单粗暴的方式来解决，即在标题中出现的关键在是10倍与在内容中出现的关键字。当然，相关性的处理方式可以自己设定。

建立索引对象：

  1.  //文档属性
  2.     struct DocInfo{
  3.         std::string _title;//文档标题
  4.         std::string _contant;//文档内容
  5.         std::string _url;//文档url
  6.         uint64_t  _id;//文档id
  7.     };
  8.     //倒排索引
  9.     struct InvertedElem{
  10.         std::string _word;//关键字
  11.         uint64_t _id;//id
  12.         int _weight;//权重
  13.         InvertedElem():_weight(0){}
  14.     };
  15.     //倒排拉链
  16.     typedef std::vector<InvertedElem> InvertedList;

建立索引类：

  1.  class index
  2.     {
  3.     private:
  4.         index(){};
  5.         index(const index&)=delete;
  6.         index operator=(const index&)=delete;
  7.     public:
  8.         static index* GetIndex()//初始化单例模式，在这里我们使用懒汉模式来建立索引
  9.         {
  10.             if(nullptr==instance)
  11.             {
  12.                 mtx.lock();//多线程问题
  13.                 if(nullptr==instance)
  14.                 {
  15.                     instance=new index();
  16.                 }
  17.                 mtx.nulock();
  18.             }
  19.             return instance;
  20.         }
  21.     public:
  22.         //正排索引
  23.         DocInfo *GetForwardIndex(uint64_t _id)//根据文档id找文档内容
  24.         {
  25.             if(_id>=_forward_list.size())//数组下标从0开始
  26.             {
  27.                 std::cerr << "doc_id out range, error!" << std::endl;
  28.                 return nullptr;
  29.             }
  30.             return &_forward_list[_id];
  31.         }
  32.         //根据关键字，获得文档倒排拉链，倒排索引
  33.         InvertedList *GetInvertedList(const std::string &word)
  34.         {
  35.             auto iter = _inverted_index.find(word);//寻找关键字
  36.             if(iter==_inverted_index.end())//没找到
  37.             {
  38.                 std::cerr << "_inverted_index out range, error!" << std::endl;
  39.                 return nullptr;
  40.             }
  41.             return &(iter->second);
  42.         }
  43.         //根据去标签，格式化之后的文档，构建正排和倒排索引
  44.         bool BuildIndex(const std::string &input)
  45.         {
  46.             std::ifstream in(input,std::ios::in|std::ios::binary);
  47.             if(!in.is_open())
  48.             {
  49.                 std::cerr<<" open file error"<<std::endl;
  50.             }
  51.             std::string line;
  52.             int count=0;
  53.             while (std::getline(in, line))//读取内容
  54.             {
  55.                 DocInfo *doc = BuildForwardIndex(line);
  56.                 if (nullptr == doc)
  57.                 {
  58.                     std::cerr << "build " << line << " error" << std::endl; // for deubg
  59.                     continue;
  60.                 }
  61.                 BuildInvertedIndex(*doc);
  62.                 count++;
  63.             }
  64.             return true;
  65.         }
  66.  
  67.     private:
  68.     DocInfo* BuildForwardIndex(const std::string &line)
  69.     {
  70.         //进行字符串切分
  71.         std::vector<std::string> results;
  72.         const std::string sep = "\3";   //行内分隔符
  73.         ns_util::StringUtil::Split(line, &results, sep);//分词
  74.         if(results.size()!=3)
  75.         {
  76.             std::cout<<"split error"std::endl;
  77.             return nullptr;
  78.         }
  79.         //2. 字符串进行填充到DocIinfo
  80.         DocInfo doc;
  81.         doc._title = results[0];//title
  82.         doc._content = results[1];// content
  83.         doc._url = results[2];/// url
  84.         doc._id = forward_index.size(); // 先进行保存id，在插入，对应的id就是当前doc在vector中的下标!
  85.         // 3. 插入到正排索引的vector
  86.         _forward_index.push_back(std::move(doc)); // doc,html文件内容
  87.         return &forward_index.back();
  88.     }
  89.     bool BuildInvertedIndex(const DocInfo &doc)
  90.     {
  91.         // DocInfo{title, content, url, doc_id}
  92.         // word -> 倒排拉链
  93.         struct word_cnt
  94.         {
  95.             int _title_cnt;
  96.             int _content_cnt;
  97.             word_cnt() : _title_cnt(0), _content_cnt(0) {}
  98.         };
  99.  
  100.         std::unordered_map<std::string, word_cnt> word_map; // 用来暂存词频的映射表
  101.  
  102.         // 对标题进行分词
  103.         std::vector<std::string> title_words;
  104.         ns_util::JiebaUtil::CutString(doc._title, &title_words);//分词
  105.         //计算权重
  106.         for(auto e:title_words)
  107.         {
  108.             boost::to_lower(s);      // 需要统一转化成为小写
  109.             word_map[s].title_cnt++; // 如果存在就获取，如果不存在就新建
  110.         }
  111.         //内容分词
  112.         std::vector<std::string> contant_words;
  113.         ns_util::JiebaUtil::CutString(doc._contant, &contant_words);//分词
  114.         for (std::string s : content_words)
  115.         {
  116.             boost::to_lower(s);
  117.             word_map[s].content_cnt++;
  118.         }
  119.         //权重计算
  120.         #define X 10
  121.         #define Y 1
  122.         for(auto e:word_map)
  123.         {
  124.             InvertedElem item;
  125.             item._id = doc._id;
  126.             item.word = e.first;
  127.             item.weight = X * e.second.title_cnt + Y * e.second.content_cnt; // 相关性
  128.             InvertedList &inverted_list = inverted_index[e.first];
  129.             _inverted_list.push_back(std::move(item));
  130.         }
  131.  
  132.     }
  133.     private:
  134.     std::vector<DocInfo> _forward_list;//正排
  135.     //倒排索引一定是一个关键字和一组(个)InvertedElem对应[关键字和倒排拉链的映射关系]
  136.     std::unordered_map<std::string, InvertedList> _inverted_index;
  137.     static Index* instance;
  138.     static std::mutex mtx;
  139.  
  140.     };
  141.     index* index::instance = nullptr;
  142.     std::mutex index::mtx;

 在创建索引的过程中，我们需要对我们搜索的关键字进行分词，而分词需要我们使用cppjieba分词工具，通过使用分词工具来进行分词(当然，有能力的同学可以自己实现一个分词程序)。

由于我们需要使用cppjieba分词工具，我们就需要下载

cppjiaba下载地址：git clone https://gitcode.com/yanyiwu/cppjieba-server.git

下载完成之后，我们只需要使用 这个目录下的文件即可：cppjieba/include/cppjieba

使用细节：使用cppjieba需要注意，我们需要自己执行：cd cppjieba; cp -rf deps/limonp include/cppjieba/, 不然会编译报错。

我们可以建立软链接来使用cppjieba库。

对于cppjieba的使用来说，我们可以到这个路径下查看使用情况:cppjieba/test.

对于使用cppjieba来说，在这个项目中这需要掌握CutString()这个函数的使用，其他的不用我们掌握太多，当然如果你想要学习的更多，可以学习其他函数的使用。 

切分函数的实现

  1. #pragma once 
  2. #include <iostream>
  3. #include <string>
  4. #include <fstream>
  5. #include <vector>
  6. #include <mutex>
  7. #include <unordered_map>
  8. #include <boost/algorithm/string.hpp>
  9. #include "cppjieba/Jieba.hpp"
  10.  
  11.  
  12. namespace ns_util
  13. {
  14.     class FileUtil
  15.     {   
  16.     public:
  17.         static bool ReadFile(const std::string &file_path, std::string *out)
  18.         {
  19.             std::ifstream in(file_path,std::ios::in);
  20.            if(!in.is_open())//c++中文件处理函数
  21.            {
  22.                 std::cerr <<"open in error2"<<std::endl;
  23.                 return false;
  24.            }
  25.             std::string line;
  26.             while(std::getline(in,line))//将文件内容写入到（string）out中
  27.             {
  28.                 *out += line;
  29.                 //std::cout<<line<<std::endl;
  30.             }
  31.             in.close();//关闭文件！！！
  32.             return true;
  33.         }
  34.     };
  35.  
  36.     class StringUtil//切割字符串
  37.     {
  38.     public:
  39.         static void Split(const std::string &target, std::vector<std::string> *out, const std::string &sep)
  40.         {
  41.             //boost split
  42.             boost::split(*out, target, boost::is_any_of(sep), boost::token_compress_on);
  43.         }
  44.     };
  45.  
  46.     const char* const DICT_PATH = "/home/SSS/cppjieba/dict/jieba.dict.utf8";
  47.     const char* const HMM_PATH = "/home/SSS/cppjieba/dict/hmm_model.utf8";
  48.     const char* const USER_DICT_PATH = "/home/SSS/cppjieba/dict/user.dict.utf8";
  49.     const char* const IDF_PATH = "/home/SSS/cppjieba/dict/idf.utf8";
  50.     const char* const STOP_WORD_PATH = "/home/SSS/cppjieba/dict/stop_words.utf8";
  51.     class JiebaUtil
  52.     {
  53.     private:
  54.         static cppjieba::Jieba _jieba;//不去暂停词
  55.     private:
  56.         //去暂停词
  57.         //cppjieba::Jieba _jieba;//创建对象
  58.         //std::unordered_map<std::string, bool> _stop_words;//哈希映射
  59.         //static JiebaUtil* _instance;
  60.     private:
  61.         //JiebaUtil():_jieba(DICT_PATH, HMM_PATH, USER_DICT_PATH, IDF_PATH, STOP_WORD_PATH) {}
  62.         //JiebaUtil(const JiebaUtil &) = delete;
  63.         //ns_util::JiebaUtil operaror=(const JiebaUtil& x)=delete;
  64.     public:
  65.         //去暂停词
  66.         // static JiebaUtil* GetInstance()//初始化
  67.         // {
  68.         //     static std::mutex _mtx;
  69.         //     if(nullptr==_instance)
  70.         //     {
  71.         //         _mtx.lock();
  72.         //         if(nullptr==_instance)
  73.         //         {
  74.         //             _instance=new JiebaUtil();
  75.         //             _instance->InitJiebaUtil();//加载文件
  76.         //         }
  77.         //         _mtx.unlock();
  78.         //     }
  79.         //     return _instance;
  80.         //     //return nullptr;
  81.         // }
  82.         // void InitJiebaUtil()
  83.         // {
  84.         //     std::ifstream in(STOP_WORD_PATH);
  85.         //     if(!in.is_open()) 
  86.         //     {
  87.         //         std::cerr<<"open file error"<<std::endl;
  88.         //         return;
  89.         //     }
  90.         //     std::string line;
  91.         //     while(std::getline(in,line))
  92.         //     {
  93.         //         _stop_words.insert({line, true});
  94.         //     }
  95.         //     in.close();
  96.         // }
  97.         // void CutStringHelper(const std::string &src, std::vector<std::string> *out)//去暂停词
  98.         // {
  99.         //     _jieba.CutForSearch(src, *out);//切分
  100.         //     for(auto iter = out->begin(); iter != out->end();)
  101.         //     {
  102.         //         auto it=_stop_words.find(*iter);
  103.         //         if(it!=_stop_words.end())
  104.         //         {
  105.         //             iter = out->erase(iter);//去暂停词
  106.         //         }
  107.         //         else iter++;
  108.         //     }
  109.         // }
  110.     public:
  111.         static void CutString(const std::string &src, std::vector<std::string> *out)
  112.         {
  113.             //去暂停词，如果云服务器配置高的情况下可以使用，性能不高可能导致出现不必要的错误
  114.             //ns_util::JiebaUtil::GetInstance()->CutStringHelper(src, out);
  115.             //低配版，不去暂停词
  116.            _jieba.CutForSearch(src, *out);
  117.         }
  118.         
  119.     };
  120.     //不去暂停词
  121.     cppjieba::Jieba JiebaUtil::_jieba(DICT_PATH, HMM_PATH, USER_DICT_PATH, IDF_PATH, STOP_WORD_PATH);
  122.     //去暂停词
  123.     //JiebaUtil* _instance=nullptr;
  124. }

 由于我们使用的是cppjieba分词工具，所以我们需要在使用的时建立分词路径，防止出现错误，在建立cppjieba类的时候，我们也是创建的单例模式，只需要建立一个对象即可，不需要创建多个对象，这和建立索引时候的功能是一样的。

对于切分字符来说，也就是CutStringHelper()函数来说，我们有两种方法实现它，可以直接调用jieba分词工具直接使用，生成关键字分词，这样做的情况下可能会生成较多的暂停词，搜索结果可能又不太准确的情况，所以我们可以去掉暂停词，这样可以减小关键词的数量，减小查找次数，二区掉暂停词依然需要调用Jieba分词库当中的函数。

对于去暂停词来说，如果服务器配置不高的情况下，不要去暂停词，可能程序运行直接报错！！

5.5建立搜索

索引建议好之后，我们进行搜索模块的建立，对于搜索模块来说，我们需要使用到的工具为Jsoncpp和cpp-httplib这两个工具，使用这两个工具我们先下载下来。

Jsoncpp下载方式：sudo yum install -y jsoncpp-devel

json的功能是实现序列化和反序列化，当然如果你可以使用其他序列化和反序列化的工具，你也可是使用和其他的，比如ProtoBuf,XML等。

cpp-httplib下载方式：GitHub - yhirose/cpp-httplib: A C++ header-only HTTP/HTTPS server and client library

注意：如果使用 centOS 环境，yum源带的 g++ 最新版本是4.8.5，发布于2015年，年代久远。编译该项目会出现异常。将 gcc/g++ 升级为更高版本可解决问题。

# 升级参考：https://juejin.cn/post/6844903873111392263
# 安装gcc 8版本
yum install -y devtoolset-8-gcc devtoolset-8-gcc-c++
# 启用版本
source /opt/rh/devtoolset-8/enable
# 查看版本已经变成gcc 8.3.1
gcc -v

# 启动： 细节，命令行启动只能在本会话有效

source /opt/rh/devtoolset-8/enable

#可选：如果想每次登陆的时候，都是较新的gcc

cat ~/.bash_profile

# .bash_profile
# Get the aliases and functions
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
# User specific environment and startup programs
PATH=$PATH:$HOME/.local/bin:$HOME/bin
export PATH
#每次启动的时候，都会执行这个命令

source /opt/rh/devtoolset-8/enable

httplib使用·：

测试代码：

  1. #include "cpp-httplib/httplib.h"
  2. int main()
  3. {
  4.     httplib::Server svr;
  5.     svr.Get("/hi", [](const httplib::Request &req, httplib::Response &rsp){
  6.     rsp.set_content("你好,世界!", "text/plain; charset=utf-8");
  7.                     });
  8.     svr.listen("0.0.0.0", 8081);
  9.     return 0;
  10. }

搜索代码实现：

建立搜索代码之前，我们需要先建立索引，这样才可以快速查找目标。所以我们先实现一个类，包含我们所需要的内容，因为我们是通过关键字找文档id,再通过文档id寻找文档内容，在这期间我们需要通过权重，来找到不同文档的先后顺序，这样我们的类里面应该包含文档id，权重，关键字等。

  1.  struct InvertedElemPrint
  2.     {
  3.         uint64_t _id;
  4.         int _weight;
  5.         std::vector<std::string> _words;
  6.         InvertedElemPrint() : _id(0), _weight(0) {}
  7.     };

对于建立搜索得类：

  1.     class Searcher
  2.     {
  3.     private:
  4.         ns_index::index *_index=nullptr; // 建立索引，进行查找
  5.     public:
  6.         Searcher() {}
  7.         ~Searcher() {}
  8.  
  9.     public:
  10.         void InitSearch(const std::string &input)
  11.         {
  12.             // 获取index对象
  13.             index = ns_index::index::GetInstance();
  14.             //根据index对象建立索引
  15.             index->BulidIndex();
  16.         }
  17.         // query: 搜索关键字
  18.         // json_string: 返回给用户浏览器的搜索结果
  19.         void search(const std::string &query, std::string *json_string)
  20.         {
  21.             std::vector<std::string> words;
  22.             ns_util::JiebaUtil::CutString(query, &words);
  23.  
  24.             //2.[触发]:就是根据分词的各个"词"，进行index查找,建立index是忽略大小写，所以搜索，关键字也需要
  25.             //ns_index::InvertedList inverted_list_all; //内部InvertedElem
  26.             std::vector<InvertedElemPrint> inverted_list_all;
  27.             std::unordered_map<uint64_t, InvertedElemPrint> tokens_map;
  28.             
  29.             for(auto word:words)
  30.             {
  31.                 boost::to_lower(word);
  32.                 ns_index::InvertedList *inverted_list = index->GetInvertedList(word);
  33.                 if(inverted==nullptr) continue;
  34.                 for(const auto &elem:*inverted_list)
  35.                 {
  36.                     auto &item = tokens_map[elem._id]; //[]:如果存在直接获取，如果不存在新建
  37.                     // item一定是doc_id相同的print节点
  38.                     item._id = elem._id;
  39.                     item._weight += elem._weight;
  40.                     item.words.push_back(elem._words);
  41.                 }
  42.             }
  43.             for (const auto &item : tokens_map)
  44.             {
  45.                 inverted_list_all.push_back(std::move(item.second));
  46.             }
  47.             //3.[合并排序]：汇总查找结果，按照相关性(weight)降序排序
  48.               
  49.                   std::sort(inverted_list_all.begin(), inverted_list_all.end(),
  50.                           [](const InvertedElemPrint &e1, const InvertedElemPrint &e2){
  51.                           return e1._weight > e2._weight;
  52.                           });
  53.             //序列化和反序列化
  54.             Json::Value root;
  55.             for(auto &item : inverted_list_all)
  56.             {
  57.                 ns_index::DocInfo * doc = index->GetForwardIndex(item._id);
  58.                 if(doc==nullptr) continue;
  59.                 Json::Value elem;
  60.                 elem["title"]=doc->_title;
  61.                 elem["desc"] = GetDesc(doc->content, item.words[0]); //content是文档的去标签的结果，但是不是我们想要的，我们要的是一部分 TODO
  62.                 elem["url"]=doc->url;
  63.                 elem["id"] = (int)item._id;
  64.                 elem["weight"] = item._weight; // int->string
  65.  
  66.                 root.append(elem);
  67.             }
  68.             Json::FastWriter writer;
  69.             *json_string = writer.write(root);
  70.  
  71.         }
  72.         //得到contant
  73.         std::string GetDesc(const std::string &html_content, const std::string &word)
  74.         {
  75.             //找到word在html_content中的首次出现，然后往前找50字节(如果没有，从begin开始)，往后找100字节(如果没有，到end就可以的)
  76.             //截取出这部分内容
  77.  
  78.             const int prev_step=50;
  79.             const int next_step=150;
  80.             //找到关键字
  81.             auto iter = std::search(html_content.begin(), html_content.end(), word.begin(), word.end(), 
  82.                                     [](int x, int y)
  83.                                     { return (std::tolower(x) == std::tolower(y)); });
  84.             if(iter==html.content.end()) return "NONE1";
  85.             int pos = std::distance(html_content.begin(), iter);
  86.             
  87.             int start=0;
  88.             int end=html_content.size()-1;
  89.             if(pos > start + prev_step) start = pos - prev_step;
  90.             if(pos < end - next_step) end = pos + next_step;
  91.  
  92.             if(start>end) return "NONE2";
  93.  
  94.             std::string desc = html_content.substr(start, end - start);
  95.             desc += "...";
  96.             return desc;
  97.         }
  98.     };
  99. }

对于搜索类来讲。我们通过实现三个函数来解决，第一个函数为InitSearch(),实现初始化函数

完成获取对象和建立对象索引。

search()函数需要我们通过搜索关键字来返回给用户浏览器的搜索结果。这就需要通过序列化和反序列化来实现，通过查找到的内容，合并文档信息，按照权重来进行排序。

GetDesc()函数，通过对得到的信息进行打印，具体实现看代码细节。

至此，后端代码全部实现完成，开始实现前端代码，前端代码的实现需要html,css,js三种编程语言。

5.6 前端代码实现

html: 是网页的骨骼 -- 负责网页结构
css：网页的皮肉 -- 负责网页美观的
js（javascript）：网页的灵魂---负责动态效果，和前后端交互

前端教程：w3school 在线教程

前端代码的编写

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <script src="http://code.jquery.com/jquery-2.1.1.min.js"></script>
  8.  
  9.     <title>boost 搜索引擎</title>
  10.     <style>
  11.         /* 去掉网页中的所有的默认内外边距，html的盒子模型 */
  12.         * {
  13.             /* 设置外边距 */
  14.             margin: 0;
  15.             /* 设置内边距 */
  16.             padding: 0;
  17.         }
  18.         /* 将我们的body内的内容100%和html的呈现吻合 */
  19.         html,
  20.         body {
  21.             height: 100%;
  22.         }
  23.         /* 类选择器.container */
  24.         .container {
  25.             /* 设置div的宽度 */
  26.             width: 800px;
  27.             /* 通过设置外边距达到居中对齐的目的 */
  28.             margin: 0px auto;
  29.             /* 设置外边距的上边距，保持元素和网页的上部距离 */
  30.             margin-top: 15px;
  31.         }
  32.         /* 复合选择器，选中container 下的 search */
  33.         .container .search {
  34.             /* 宽度与父标签保持一致 */
  35.             width: 100%;
  36.             /* 高度设置为52px */
  37.             height: 52px;
  38.         }
  39.         /* 先选中input标签， 直接设置标签的属性，先要选中， input：标签选择器*/
  40.         /* input在进行高度设置的时候，没有考虑边框的问题 */
  41.         .container .search input {
  42.             /* 设置left浮动 */
  43.             float: left;
  44.             width: 600px;
  45.             height: 50px;
  46.             /* 设置边框属性：边框的宽度，样式，颜色 */
  47.             border: 1px solid black;
  48.             /* 去掉input输入框的有边框 */
  49.             border-right: none;
  50.             /* 设置内边距，默认文字不要和左侧边框紧挨着 */
  51.             padding-left: 10px;
  52.             /* 设置input内部的字体的颜色和样式 */
  53.             color: #CCC;
  54.             font-size: 14px;
  55.         }
  56.         /* 先选中button标签， 直接设置标签的属性，先要选中， button：标签选择器*/
  57.         .container .search button {
  58.             /* 设置left浮动 */
  59.             float: left;
  60.             width: 150px;
  61.             height: 52px;
  62.             /* 设置button的背景颜色，#4e6ef2 */
  63.             background-color: #4e6ef2;
  64.             /* 设置button中的字体颜色 */
  65.             color: #FFF;
  66.             /* 设置字体的大小 */
  67.             font-size: 19px;
  68.             font-family:Georgia, 'Times New Roman', Times, serif;
  69.         }
  70.         .container .result {
  71.             width: 100%;
  72.         }
  73.         .container .result .item {
  74.             margin-top: 15px;
  75.         }
  76.  
  77.         .container .result .item a {
  78.             /* 设置为块级元素，单独站一行 */
  79.             display: block;
  80.             /* a标签的下划线去掉 */
  81.             text-decoration: none;
  82.             /* 设置a标签中的文字的字体大小 */
  83.             font-size: 20px;
  84.             /* 设置字体的颜色 */
  85.             color: #4e6ef2;
  86.         }
  87.         .container .result .item a:hover {
  88.             text-decoration: underline;
  89.         }
  90.         .container .result .item p {
  91.             margin-top: 5px;
  92.             font-size: 16px;
  93.             font-family:'Lucida Sans', 'Lucida Sans Regular', 'Lucida Grande', 'Lucida Sans Unicode', Geneva, Verdana, sans-serif;
  94.         }
  95.  
  96.         .container .result .item i{
  97.             /* 设置为块级元素，单独站一行 */
  98.             display: block;
  99.             /* 取消斜体风格 */
  100.             font-style: normal;
  101.             color: green;
  102.         }
  103.     </style>
  104. </head>
  105. <body>
  106.     <div class="container">
  107.         <div class="search">
  108.             <input type="text" value="请输入搜索关键字">
  109.             <button onclick="Search()">搜索一下</button>
  110.         </div>
  111.         <div class="result">
  112.             <!-- 动态生成网页内容 -->
  113.             <!-- <div class="item">
  114.                 <a href="#">这是标题</a>
  115.                 <p>这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要</p>
  116.                 <i>https://search.gitee.com/?skin=rec&type=repository&q=cpp-httplib</i>
  117.             </div>
  118.             <div class="item">
  119.                 <a href="#">这是标题</a>
  120.                 <p>这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要</p>
  121.                 <i>https://search.gitee.com/?skin=rec&type=repository&q=cpp-httplib</i>
  122.             </div>
  123.             <div class="item">
  124.                 <a href="#">这是标题</a>
  125.                 <p>这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要</p>
  126.                 <i>https://search.gitee.com/?skin=rec&type=repository&q=cpp-httplib</i>
  127.             </div>
  128.             <div class="item">
  129.                 <a href="#">这是标题</a>
  130.                 <p>这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要</p>
  131.                 <i>https://search.gitee.com/?skin=rec&type=repository&q=cpp-httplib</i>
  132.             </div>
  133.             <div class="item">
  134.                 <a href="#">这是标题</a>
  135.                 <p>这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要这是摘要</p>
  136.                 <i>https://search.gitee.com/?skin=rec&type=repository&q=cpp-httplib</i>
  137.             </div> -->
  138.         </div>
  139.     </div>
  140.     <script>
  141.         function Search(){
  142.             // 是浏览器的一个弹出框
  143.             // alert("hello js!");
  144.             // 1. 提取数据, $可以理解成就是JQuery的别称
  145.             let query = $(".container .search input").val();
  146.             console.log("query = " + query); //console是浏览器的对话框，可以用来进行查看js数据
  147.  
  148.             //2. 发起http请求,ajax: 属于一个和后端进行数据交互的函数，JQuery中的
  149.             $.ajax({
  150.                 type: "GET",
  151.                 url: "/s?word=" + query,
  152.                 success: function(data){
  153.                     console.log(data);
  154.                     BuildHtml(data);
  155.                 }
  156.             });
  157.         }
  158.  
  159.         function BuildHtml(data){
  160.             // 获取html中的result标签
  161.             let result_lable = $(".container .result");
  162.             // 清空历史搜索结果
  163.             result_lable.empty();
  164.  
  165.             for( let elem of data){
  166.                 // console.log(elem.title);
  167.                 // console.log(elem.url);
  168.                 let a_lable = $("<a>", {
  169.                     text: elem.title,
  170.                     href: elem.url,
  171.                     // 跳转到新的页面
  172.                     target: "_blank"
  173.                 });
  174.                 let p_lable = $("<p>", {
  175.                     text: elem.desc
  176.                 });
  177.                 let i_lable = $("<i>", {
  178.                     text: elem.url
  179.                 });
  180.                 let div_lable = $("<div>", {
  181.                     class: "item"
  182.                 });
  183.                 a_lable.appendTo(div_lable);
  184.                 p_lable.appendTo(div_lable);
  185.                 i_lable.appendTo(div_lable);
  186.                 div_lable.appendTo(result_lable);
  187.             }
  188.         }
  189.     </script>
  190. </body>
  191. </html>

5.7 添加日志

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <cstdio>
  5. #include <cstdarg>
  6. #include <ctime>
  7.  
  8. #define DEBUG 0
  9. #define NORMAL 1
  10. #define WARING 2
  11. #define ERROR 3
  12. #define FATAL 4
  13. #define LOGFILE "./calculator.log"
  14.  
  15. const char* gLevelMap[]={"DEBUG","NORMAL","WARING","ERROR","FATAL"};
  16.  
  17. //完整的日志功能，至少: 日志等级 时间 支持用户自定义(日志内容, 文件行，文件名)，可以将其写到文件中
  18. void logMessage(int level,const char* format,...)
  19. {
  20.     //if(level==0) printf("正确");
  21.     char stdBuff[10024];
  22.     time_t timestamp = time(nullptr);//时间
  23.     snprintf(stdBuff,sizeof(stdBuff),"[%s] [%ld] ", gLevelMap[level], timestamp);
  24.  
  25.     char logBuff[1024]; //自定义部分
  26.     // va_list args;
  27.     // va_start(args, format);
  28.     // // vprintf(format, args);
  29.     // vsnprintf(logBuffer, sizeof logBuffer, format, args);
  30.     // va_end(args);
  31.  
  32.     snprintf(logBuff,sizeof(logBuff),"[%s] [%ld] ", gLevelMap[level], timestamp);
  33.     
  34.  
  35.     FILE *fp = fopen(LOGFILE, "a");
  36.     // printf("%s%s\n", stdBuffer, logBuffer);
  37.     fprintf(fp, "%s %s\n", stdBuff, logBuff);
  38.     fclose(fp);
  39. }

日志分为5个等级，每个等级对应不同的内容，不同的等级需要不同的数字来对应。可以将其写到文件中将其保存。当然，对于不同的级别，日志可能会有不同的表现，具体情况视情况而定。

5.8 结尾

最后需要将写好的程序部署到linux服务器上，完成最后网站的建立。

nohup ./http_server > log/log.txt 2>&1 &[1] 26890

项目扩展方向

1. 建立整站搜索
2. 设计一个在线更新的方案，信号，爬虫，完成整个服务器的设计
3. 不使用组件，而是自己设计一下对应的各种方案（有时间，有精力）
4. 在我们的搜索引擎中，添加竞价排名(强烈推荐)
5. 热次统计，智能显示搜索关键词（字典树，优先级队列）(比较推荐)
6. 设置登陆注册，引入对mysql的使用(比较推荐的)

有兴趣的可以尝试做下。

项目完整代码网址：

C-C++项目: C/C++项目 - Gitee.com

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/226844
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号