帝国cms做网站流程,linux系统网站建设,学网页设计有用吗,020网站开发多少钱认识搜索引擎
1、有一个主页、有搜索框。在搜索框中输入的内容 称为“查询词”
2、还有搜索结果页#xff0c;包含了若干条搜索结果
3、针对每一个搜索结果#xff0c;都会包含查询词或者查询词的一部分或者和查询词具有一定的相关性
4、每个搜索结果包含好几个部分…认识搜索引擎
1、有一个主页、有搜索框。在搜索框中输入的内容 称为“查询词”
2、还有搜索结果页包含了若干条搜索结果
3、针对每一个搜索结果都会包含查询词或者查询词的一部分或者和查询词具有一定的相关性
4、每个搜索结果包含好几个部分 a)标题 b)描述 通常是页面的摘要信息 c)子链子链接 d)展示 url e)图片 f)点击 url 点击“点击url”浏览器将跳转到“落地页” 搜索引擎的功能就是“搜索”“查找”
查找用户输入的查询词在哪些网页自然搜索结果网页数据通常是通过爬虫来获取的。广告搜索结果广告主把物料提交给广告平台中出现过或者出现过一部分
把结果展示到网页上。点击结果就能跳转到该页面。
像百度搜狗这样的搜索引擎全网搜索。处理的数据量级是非常庞大的。PB级1PB1024TB
咱们现在不具有搞全网搜索的条件没有那么多服务器可以搞一个数据量小得多的站内搜索。
当前所做的搜索引擎Java API文档 为啥要搜索Java API文档 1、官方文档上没有一个好用的搜索框 2、Java API 文档数量比较少当前有限的硬件资源足以处理。几万个页面 3、文档内容不需要使用爬虫来获取可以直接在官网上下载。 搜索引擎是如何工作的 需要在很多网页数据中找到你输入的查询词部分查询词 搜索引擎后台当前已经获取了很多很多的网页数据。每个网页数据都是一个html。称为一个”文档/Document“想要知道的是该查询词在哪些文档中出现过。 1、暴力搜索 一次遍历每个文件查看当前文件是否包含查询词。文档数目非常多依次遍历的话效率就非常低 2、倒排索引这是一种特殊的数据结构 正排索引docId 文档内容 根据正排索引制作倒排索引需要先针对文档内容进行分词对计算机来说中文分词是一件很CPU疼的事 词 docId 倒排索引 相当于是个键值对的结构乔布斯这个词在文档1和文档2中都出现过 正排根据文档id找到对应文档相关信息 倒排根据词找到这个词在哪些文档id中存在 这是项目中的最核心的部分。也是一个搜索引擎中的最核心部分。 当我们有了倒排序之后针对用户输入的查询词就可以快速找到相关联。 实现分词的基本思路 1、基于词典。几十万个 2、基于概率统计很多的文本信息 哪两个/三个/四个汉字在一起的概率特别高那么就说明是一个词。 当前商业公司分词库都能达到99%以上的准确率分词算法一般都是公司的商业机密。 可以使用现成的第三方库。虽然达不到那么高的准确率但是也够用。 项目的目标 实现一个Java API文档的站内搜索引擎 在线API文档 Java API文档有一个线上版本还有一个可以离线下载的版本 API下载地址。 下载好API文档分析里面的内容在搜索结果中填上线上文档的连接地址。
线上文档和线下文档具有一定的对应关系。
后面分析线下文档的时候就可以根据当前文件的路径拼接出对应的线上文档的url。 项目的模块划分 1、预处理模块把下载好的 html 文档进行一次初步的处理简单分析结构并且干掉其中的 html 标签 2、索引模块预处理得到的结果构建正排倒排索引 3、搜索模块完成一次搜索过程基本流程从用户输入查询词到得到最终的搜索结果 4、前端模块有一个页面展示结果并且让用户输入数据 1、预处理模块
把 api 目录中所有的html进行处理 得到一个单个的文件为了后面制作索引更方便。使用行文本的方式来进行组织组织方式其实也有很多。 这个得到的临时文件中每一行对应到一个html文档每一行中又包含3列。 第一列表示这个文档的标题 第二列表示这个文档的url线上版本文档的url 第三列表示这个文档的正文去掉html格式 过滤掉标签是为了让搜索结果只集中到正文上 1、创建一个common 包表示每个模块都可能用到的公共信息
创建一个DocInfo类对象 2、创建一个Parser包表示预处理
创建一个Parser类遍历文档目录递归的方式读取所有的html文档内容把结果解析成一个行文本文件
每一行都对应一个文档每一行中都包含 文档标题文档的URL文档的正文去掉html标签的内容去除换行符 1、枚举出INPUT_PATH 下所有的 html 文件递归 2、针对枚举出来的html文件路径进行遍历依次打开每个文件并读取内容 把内容转换成需要的结构化的数据DocInfo对象 3、把DocInfo对象写入到最终的输出文件中OUTPUT_PATH。写成行文本的形式 convertcontent这个方法两件事情:
// 1. 把 html 中的标签去掉
// 2. 把 \n 也去掉
eg: body h1hehe/h1 div我是一句话/div /body
一个一个字符读取并判定boolean isContent 值为true当前读取的内容是html正文(不是标签) 为false当前读取的内容是标签。 当当前字符为 把isContent置为false。把读到的字符直接忽略 当当前字符为 把isContent职位true。 如果当前 isContent 为 true 的时候读到的字符就放到一个StringBuilder中即可。 这里使用字符流 补充文件是二进制文件就是用字节流 文件是文本文件就是用字符流用记事本打开能看懂的是文本文件 public class Parser {// 下载好的 Java API 文档在哪private static final String INPUT_PATH E:\\project\\docs\\api;// 预处理模块输出文件存放的目录private static final String OUTPUT_PATH E:\\project\\raw_data.txt;public static void main(String[] args) throws IOException {FileWriter resultFileWriter new FileWriter(new File(OUTPUT_PATH));// 通过 main 完成整个预处理的过程// 1. 枚举出 INPUT_PATH 下所有的 html 文件(递归)ArrayListFile fileList new ArrayList();enumFile(INPUT_PATH, fileList);// 2. 针对枚举出来的html文件路径进行遍历, 依次打开每个文件, 并读取内容.// 把内容转换成需要的结构化的数据(DocInfo对象)for (File f : fileList) {System.out.println(converting f.getAbsolutePath() ...);// 最终输出的 raw_data 文件是一个行文本文件. 每一行对应一个 html 文件.// line 这个对象就对应到一个文件.String line convertLine(f);// 3. 把得到的结果写入到最终的输出文件中(OUTPUT_PATH). 写成行文本的形式resultFileWriter.write(line);}resultFileWriter.close();}// 此处咱们的 raw_data 文件使用行文本来表示只是一种方式而已.// 完全也可以使用 json 或者 xml 或者其他任何你喜欢的方式来表示都行private static String convertLine(File f) throws IOException {// 1. 根据 f 转换出 标题String title convertTitle(f);// 2. 根据 f 转换出 urlString url convertUrl(f);// 3. 根据 f 转换成正文, a) 去掉 html 标签; b) 去掉换行符String content convertContent(f);// 4. 把这三个部分拼成一行文本// \3 起到分割三个部分的效果. \3 ASCII 值为 3 的字符// 在一个 html 这样的文本文件中是不会存在 \3 这种不可见字符// 类似的, 使用 \1 \2 \4 \5....来分割效果也是一样return title \3 url \3 content \n;}private static String convertContent(File f) throws IOException {// 这个方法做两件事情:// 1. 把 html 中的标签去掉// 2. 把 \n 也去掉// 一个一个字符读取并判定FileReader fileReader new FileReader(f);boolean isContent true;StringBuilder output new StringBuilder();while (true) {int ret fileReader.read();if (ret -1) {// 读取完毕了break;}char c (char)ret;if (isContent) {// 当前这部分内容是正文if (c ) {isContent false;continue;}if (c \n || c \r) {c ;}output.append(c);} else {// 当前这个部分内容是标签// 不去写 outputif (c ) {isContent true;}}}fileReader.close();return output.toString();}private static String convertUrl(File f) {// URL 线上文档对应的 URL// 线上文档 URL 形如:// https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html// 本地目录文档路径形如:// E:\jdk1.8\docs\api\java\util\Collection.html// 线上文档的 URL 由两个部分构成.// part1: https://docs.oracle.com/javase/8/docs/api 固定的// part2: /java/util/Collection.html 和本地文件的路径密切相关.// 此处对于 浏览器 来说, / 或者 \ 都能识别.String part1 https://docs.oracle.com/javase/8/docs/api;String part2 f.getAbsolutePath().substring(INPUT_PATH.length());return part1 part2;}private static String convertTitle(File f) {// 把文件名(不是全路径, 去掉.html后缀)作为标题就可以了// 文件名: EntityResolver.html// 全路径: D:\jdk1.8\docs\api\org\xml\sax\EntityResolver.htmlString name f.getName();return name.substring(0, name.length() - .html.length());}// 当这个方法递归完毕后, 当前 inputPath 目录下所有子目录中的 html 的路径就都被收集到// fileList 这个 List 中了private static void enumFile(String inputPath, ArrayListFile fileList) {// 递归的把 inputPath 对应的全部目录和文件都遍历一遍File root new File(inputPath);// listFiles 相当于 Linux 上的 ls 命令.// 就把当前目录下所有的文件和目录都罗列出来了. 当前目录就是 root 对象所对应的目录File[] files root.listFiles();// System.out.println(Arrays.toString(files));// 遍历当前这些目录和文件路径, 分别处理for (File f : files) {if (f.isDirectory()) {// 如果当前这个 f 是一个目录. 递归调用 enumFileenumFile(f.getAbsolutePath(), fileList);} else if (f.getAbsolutePath().endsWith(.html)) {// 如果当前 f 不是一个目录, 看文件后缀是不是 .html。 如果是就把这个文件的对象// 加入到 fileList 这个 List 中fileList.add(f);}}}
} 运行 文件很大直接打开加载不出来。使用less命令 less 特点就是打开大文件速度很快。 很多文本编辑器都是尝试把所有文件内容都加载到内存中 less 只加载一小块。显示哪部分就加载哪部分懒加载 在 less /Vim 如何显示不可见字符呢 \1 ^A \2 ^B \3 ^C 也可以用head - n 1 xxx 补充测试项目测试用例 针对这个预处理程序 1、验证文件整体格式是否是行文本格式 2、验证每一行是否对应一个html文件 3、验证每一行中是不是都包含3个字段是否用\3分割 4、验证标题是否和html文件名一直 5、验证url是否是正确的是否能跳转到线上文档页面 6、验证正文格式是否正确html标签是否去掉是否把 \n 去掉 当前文件内容很多如何验证所有行都是包含3个字段 写一个程序来验证自动化测试
2、索引模块
索引分词
根据 raw_data.txt 得到正排索引和倒排索引 分词
分词第三方库有很多 .ansj
安装对应 jar 包
创建Index索引类
引用权重该词和该文档之间的相关程度。相关程度越高权重就越大。
实际的搜索引擎或根据查询词和文档之间的相关性进行降序排序把相关程度越高的文档排到越靠前。相关程度越低的就排到越靠后。
相关性——有专门的算法工程师团队来做这个事情。人工智能
此处就使用简单粗暴的方式来相关性的衡量。
就看这个词在文档中的出现次数出现次数越多相关性就越强。
词在标题中出现就应该相关性比在正文中出现更强一些。
此处设定一个简单粗暴的公式来描述权重。 weight 标题中出现的次数 * 10 正文中出现的次数 正排索引就是一个数组。docId作为下标知道docId就可以找到DocInfo。 倒排索引根据词找到这个词在哪些文档中出现过。 Index 类需要提供的方法
查正排
查倒排
构建索引把raw_data.txt 文件内容读取出来加载到内存上面的数据结构中
索引模块中最复杂的部分
// 构建索引, 把 raw_data.txt 文件内容读取出来, 加载到内存上面的数据结构中// raw_data.txt 是一个行文本文件. 每一行都有三个部分. 每个部分之间使用 \3 分割// 索引模块中最复杂的部分public void build(String inputPath) throws IOException {class Timer {public long readFileTime;public long buildForwardTime;public long buildInvertedTime;public long logTime;}Timer timer new Timer();long startTime System.currentTimeMillis();System.out.println(build start!);// 1. 打开文件, 并且按行读取文件内容BufferedReader bufferedReader new BufferedReader(new FileReader(new File(inputPath)));// 2. 读取到的每一行.// 加时间是有技巧的. 不应该在比较大的循环中加入过多的打印信息. 打印信息会很多, 看起来很不方便.// 打印函数本身也是有时间消耗的.while (true) {long t1 System.currentTimeMillis();String line bufferedReader.readLine();if (line null) {break;}long t2 System.currentTimeMillis();// 3. 构造正排的过程: 按照 \3 来切分, 切分结果构造成一个 DocInfo 对象, 并加入到正排索引中DocInfo docInfo buildForward(line);long t3 System.currentTimeMillis();// 4. 构造倒排的过程: 把 DocInfo 对象里面的内容进一步处理, 构造出倒排buildInverted(docInfo);long t4 System.currentTimeMillis();// System.out.println(Build docInfo.getTitle() done!);long t5 System.currentTimeMillis();timer.readFileTime (t2 - t1);timer.buildForwardTime (t3 - t2);timer.buildInvertedTime (t4 - t3);timer.logTime (t5 - t4);}bufferedReader.close();long finishTime System.currentTimeMillis();System.out.println(build finish! time: (finishTime - startTime) ms);System.out.println(readFileTime: timer.readFileTime buildForwardTime: timer.buildForwardTime buildInvertedTime: timer.buildInvertedTime logTime: timer.logTime);} 正排索引
private DocInfo buildForward(String line) {// 把这一行按照 \3 切分// 分出来的三个部分就是一个文档的 标题, URL, 正文String[] tokens line.split(\3);if (tokens.length ! 3) {// 发现文件格式有问题~~// 当前场景下咱们有 1w 多个文件. 如果某个文件出现格式问题,// 不应该让某个问题影响到整体的索引构建// 此处我们的处理方式仅仅就是打印了日志.System.out.println(文件格式存在问题: line);return null;}// 把新的 docInfo 插入到 数组末尾.// 如果数组是 0 个元素, 新的元素所处在的下标就是 0DocInfo docInfo new DocInfo();// id 就是正排索引数组下标docInfo.setDocId(forwardIndex.size());docInfo.setTitle(tokens[0]);docInfo.setUrl(tokens[1]);docInfo.setContent(tokens[2]);forwardIndex.add(docInfo);return docInfo;} 倒排索引
private void buildInverted(DocInfo docInfo) {class WordCnt {public int titleCount;public int contentCount;public WordCnt(int titleCount, int contentCount) {this.titleCount titleCount;this.contentCount contentCount;}}HashMapString, WordCnt wordCntHashMap new HashMap();// 前 4 个操作都是为了给后面的计算权重做铺垫// 针对 DocInfo 中的 title 和 content 进行分词, 再根据分词结果构建出 Weight 对象, 更新倒排索引// 1. 先针对标题分词ListTerm titleTerms ToAnalysis.parse(docInfo.getTitle()).getTerms();// 2. 遍历分词结果, 统计标题中的每个词出现的次数for (Term term : titleTerms) {// 此处 word 已经是被转成小写了String word term.getName();WordCnt wordCnt wordCntHashMap.get(word);if (wordCnt null) {// 当前这个词在哈希表中不存在wordCntHashMap.put(word, new WordCnt(1, 0));} else {// 当前这个词已经在哈希表中存在, 直接修改 titleCount 即可wordCnt.titleCount;}}// 3. 再针对正文分词ListTerm contentTerms ToAnalysis.parse(docInfo.getContent()).getTerms();// 4. 遍历分词结果, 统计正文中的每个词出现的次数for (Term term : contentTerms) {String word term.getName();WordCnt wordCnt wordCntHashMap.get(word);if (wordCnt null) {// 当前这个词在哈希表中不存在wordCntHashMap.put(word, new WordCnt(0, 1));} else {wordCnt.contentCount;}}// 5. 遍历 HashMap, 依次构建 Weight 对象并更新倒排索引的映射关系for (HashMap.EntryString, WordCnt entry : wordCntHashMap.entrySet()) {Weight weight new Weight();weight.word entry.getKey();weight.docId docInfo.getDocId();// weight 标题中出现次数 * 10 正文中出现次数weight.weight entry.getValue().titleCount * 10 entry.getValue().contentCount;// weight 加入到倒排索引中. 倒排索引是一个 HashMap, value 就是 Weight 构成的 ArrayList// 先根据这个词, 找到 HashMap 中对应的这个 ArrayList, 称为 倒排拉链ArrayListWeight invertedList invertedIndex.get(entry.getKey());if (invertedList null) {// 当前这个键值对不存在, 就新加入一个键值对就可以了invertedList new ArrayList();invertedIndex.put(entry.getKey(), invertedList);}// 到了这一步, invertedIndex 已经是一个合法的 ArrayList 了, 就可以把 weight 直接加入即可invertedList.add(weight);}}
3、搜索模块
把刚才这些docId所对应的DocInfo信息查找到组装成一个响应数据. public class Result {private String title;// 当前这个场景中, 这两个 URL 就填成一样的内容了private String showUrl;private String clickUrl;private String desc; // 描述. 网页正文的摘要信息, 一般要包含查询词(查询词的一部分)public String getTitle() {return title;}public void setTitle(String title) {this.title title;}public String getShowUrl() {return showUrl;}public void setShowUrl(String showUrl) {this.showUrl showUrl;}public String getClickUrl() {return clickUrl;}public void setClickUrl(String clickUrl) {this.clickUrl clickUrl;}public String getDesc() {return desc;}public void setDesc(String desc) {this.desc desc;}Overridepublic String toString() {return Result{ title title \ , showUrl showUrl \ , clickUrl clickUrl \ , desc desc \ };}
} 通过Searcher这个类来完成核心的搜索过程 思路 1、【分词】针对查询词进行分词 2、【触发】针对查询词的分词结果依次查找倒排索引得到一大堆相关的 docId 3、【排序】按照权重进行降序排序 4、【包装结果】根据刚才查找到的docId在正排中查找DocInfo包装成 Result 对象 用户输入的内容到底是啥 很可能输入的内容中就包含某个词这个词在所有的文档中都不存在。 当我们针对一个集合类进行排序的时候往往需要指定比较规则。尤其是集合类内部包含是引用类型的时候。 Comparable让需要被比较的类实现这个接口重写compareTo方法 Comparator创建一个比较器类实现这个接口实现的这个接口内部重写compare方法。 class WeightComparator implements ComparatorIndex.Weight {Overridepublic int compare(Index.Weight o1, Index.Weight o2) {// 如果 o1 o2 返回一个 0// 如果 o1 o2 返回一个 0// 如果 o1 o2 返回 0return o2.weight - o1.weight;}
}/*** 通过这个类来完成核心的搜索过程*/
public class Searcher {private Index index new Index();public Searcher() throws IOException {index.build(d:/raw_data.txt);}public ListResult search(String query) {// 1. [分词] 针对查询词进行分词ListTerm terms ToAnalysis.parse(query).getTerms();// 2. [触发] 针对查询词的分词结果依次查找倒排索引, 得到一大堆相关的 docId// 这个 ArrayList 中就保存 每个分词结果 得到的倒排拉链的整体结果ArrayListIndex.Weight allTokenResult new ArrayList();for (Term term : terms) {// 此处得到的 word 就已经是全小写的内容了. 索引中的内容也是小写的String word term.getName();ListIndex.Weight invertedList index.getInverted(word);if (invertedList null) {// 用户输入的这部分词很生僻, 在所有文档中都不存在continue;}allTokenResult.addAll(invertedList);}// 3. [排序] 按照权重进行降序排序// 匿名内部类allTokenResult.sort(new WeightComparator());// 4. [包装结果] 根据刚才查找到的 docId 在正排中查找 DocInfo, 包装成 Result 对象ArrayListResult results new ArrayList();for (Index.Weight weight : allTokenResult) {// 根据 weight 中包含的 docId 找到对应的 DocInfo 对象DocInfo docInfo index.getDocInfo(weight.docId);Result result new Result();result.setTitle(docInfo.getTitle());result.setShowUrl(docInfo.getUrl());result.setClickUrl(docInfo.getUrl());// GenDesc 做的事情是从正文中摘取一段摘要信息. 根据当前的这个词, 找到这个词在正文中的位置// 再把这个位置周围的文本都获取到. 得到了一个片段result.setDesc(GenDesc(docInfo.getContent(), weight.word));results.add(result);}return results;}// 这个方法根据当前的词, 提取正文中的一部分内容作为描述.// 以下的实现逻辑还是咱们拍脑门出来的.private String GenDesc(String content, String word) {// 查找 word 在 content 中出现的位置.// word 里内容已经是全小写了. content 里头还是大小写都有.int firstPos content.toLowerCase().indexOf(word);if (firstPos -1) {// 极端情况下, 某个词只在标题中出现, 而没在正文中出现, 在正文中肯定找不到了// 这种情况非常少见, 咱们暂时不考虑return ;}// 从 firstPos 开始往前找 60 个字符, 作为描述开始. 如果前面不足 60 个, 就从正文头部开始;int descBeg firstPos 60 ? 0 : firstPos - 60;// 从描述开始往后找 160 个字符作为整个描述内容. 如果后面不足 160 个, 把剩下的都算上.if (descBeg 160 content.length()) {return content.substring(descBeg);}return content.substring(descBeg, descBeg 160) ...;}
} 针对搜索模块的测试 1、针对某个查询词搜索出来的结构是否都包含指定查询词 2、针对搜索结果是否按照权重排序 3、针对搜索结果里面包含的标题url描述是否正确 4、URL是否能跳转 5、描述是否包含指定的词 6、描述前面比较短的情况 7、描述后面比较短的情况 8、描述中是否带。。。 9、搜索结果的数目是否符合预期 10、搜索时间是否符合预期 …… 搜索模块中核心的搜索类已经完成了。把搜索类放到一个服务器中通过服务器来进行搜索过程。 HTTP Servlet。 前后端交互接口 请求GET /search?queryArrayList 响应通过 Json 来组织 { { tiltle“我是标题” showUrl“我是展示URL” clickUrl“我是点击URL” desc“我是描述信息” } { } } 项目部署到云服务器
maven - package 打包到 target 目录下
当前这个 war 包不能直接放到 Linux 上执行。
Tomcat 肯定会创建 Servlet 实例。Servlet 实例里面包含了 Searcher 对象的实例又包含了 Index 的实例并且需要进行 build。
build 依赖了一个 raw_data.txt 数据文件。
光把 war 包部署到 Linux 上是不行的需要把 raw_data.txt 也部署上去并且要把build 对应的路径给写对。
把 war 包部署到 tomcat 上之后发现收到第一次请求的时候才触发了索引构建Searcher DocSearcherServlet
DocSearcherServlet 并不是在 Tomcat 一启动的时候就实例化而是收到第一个请求的时候才实例化。 问题1第一次请求响应时间太长了。应该让服务器一启动就创建Servlet 的实例。实例创建好了索引构造完了那么后面的响应其实就快了。 让服务器一启动就创建对应 Servlet 的实例如果这个值 0还是表示收到请求才实例化 如果这个值 0 表示服务器启动就立刻实例化。 当 0 的时候这个值越小就越先加载。 问题2如果在加载过程中用户的请求就来了咋办 实际的搜索引擎中会把整个系统拆分成很多不同的服务器。HTTP服务器 搜索服务器需要加载索引启动速度比较慢这样的情况下 搜索服务器 如果在启动过程中HTTP请求就来了HTTP服务器就可以告诉用户“我们还没准备好” 事实上搜索服务器通常有多台。重启不至于把所有的都重启。总会留下一些可以正常工作的服务器。就能保证HTTP服务器始终能获取到想要的结果。 4、前端模块 写了一个简单的前面页面用到的技术栈有 HTMLCSSJavaScript Bootstrap一个用来更好的显示界面的组件库。 JQuery方便的使用 ajax 和 服务器进行数据交互 Vue前端框架方便数据同步展示到界面上 性能优化
运行预处理模块发现执行时间挺长的。
如果要进行性能优化怎么办
1、先看这里有没有必要优化必要性不高。预处理操作其实执行一次就够了 API文档内容是很稳定内容不变预处理结果就不变
2、先找到性能瓶颈。枚举目录转换标题转换正文转换URL写文件
猜测是这两个因为涉及到IO操作
3、根据性能瓶颈分析原因指定解决方案 索引模块有必要进行优化的构建索引过程每次服务器启动都需要构建索引
思路还是一样需要找到性能瓶颈才能优化
给核心步骤加上时间
构建倒排代码中性能瓶颈在于分词操作。 分析原因分词本身就是一个很复杂的操作。
解决方案文档内容固定分词结果一定也固定。完全可以在预处理阶段就把标题和正文都分词分好存到 raw_data 中。后续服务器构建索引直接加载分词结果即可不需要重复进行分词。 总时间 读文件时间 正排索引时间 倒排索引时间 打印时间 之前IDEA里面执行log时间就很短。全缓冲打印换行不会影响刷新缓冲区 在Tomcat上执行log时间就比较久行缓冲每次打印换行都会刷新缓冲区频繁访问磁盘。 取决于这里打印日志的缓冲策略。 优化手段把日志去掉~ 可以每循环处理1000个文档打印1条日志。 结论不要在一个频繁循环中加日志。
