目录
基于设计原理与理念和实践的ElasticSearch学习
一、ES基础入门
ElasticSearch是什么？
ES优点：
ES缺点：
ElasticSearch应用场景
ElasticSearch存储结构
索引（_index）
正向索引
倒排索引
类型（_type）
唯一标识（_id）
ElastSearch 增删改查
Elasticsearch版本控制
1.为什么要进行版本控制
2.悲观锁和乐观锁
二、深入理解ElasticSearch集群设计理念
路由
读写分离
replication
consistency
timeout
分布式局部更新
分布式批量请求(查询)
近实时搜索
持久化（可靠性）
合并段（解决碎片化问题）
1、什么是段？以及段的作用
2、段带来的碎片化问题
9300与9200区别
ElasticSearch高级查询
Term与Match区别
文档映射
映射的分类
ES类型支持
三、ElasticSearch集群搭建
Linux环境安装Elasticsearch
中文分词器
ES集成IK分词器
IK自定义扩展词典
Linux环境安装Kibana
Kabana介绍
Kibana环境安装
Elasticsearch分布式集群搭建
概念
为什么这样设计？
集群搭建
四、ELK分布式日志收集
Logstash原理
ELK搭建
Elasticsearch环境安装：
Logstash环境安装：
将Logstash输入到ES中：
Kabana环境安装：
五、ElasticSearch网盘搜索引擎（Springboot2.0版）
步骤分析：
分析网站：
源码：
添加ElasticSearch数据结构：
Maven依赖：
application.yml
Es实体层：
Es Dao层：
Es API控制层：
Es 控制层：
CrawlBook.java
ReptileMain.java
MultiThread.java
search.html
基于设计原理与理念和实践的ElasticSearch学习
一、ES基础入门
ElasticSearch是什么？
Elasticsearch是一个基于Apache Lucene(TM)的开源搜索引擎。无论在开源还是专有领域，Lucene可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。
Lucene缺点：Shay Banon在构建出Lucene之后发现了Lucene的缺点（Lucene只是一个库。想要使用它，你必须使用Java来作为开发语言）之后在其不断的努力之下开发出了Elasticsearch。
Elasticsearch也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。
ES优点：
- 分布式的实时文件存储，每个字段都被索引并可被搜索;
- 分布式的实时分析搜索引擎;
- (横向扩展)可以扩展到上百台服务器，处理PB级结构化或非结构化数据；
- 分片机制提供更好的分布式性能。
ES缺点：
- 建立索引要消耗很大的磁盘、内存空间；
- 当网页更新后，索引的维护代价也比较大；
- 只支持JSON文件格式，Solr支持多种(HTML、PDF、微软 Office 系列软件格式以及 JSON、XML、CSV 等)；
ElasticSearch应用场景
大型分布式日志分析系统ELK elasticsearch（存储日志）+logstash(收集日志)+kibana(展示数据)
大型电商商品搜索系统、网盘搜索引擎等。
ElasticSearch存储结构
ElasticSearch是文档存储，使用面向文档型数据库，一条数据也许就是一个文档，文档内容的格式采用JSON。
关系型数据库：数据库→表→行→列
ElasticSearch：索引→类型→文档→字段
每一个文档(document)都具备三个元数据（metadata）：索引(_index)、类型(_type)、唯一标识(_id)、版本号（_version）、_source（表标题）
索引（_index）
Es的索引(index)类似于关系型数据库里的“数据库”,事实上，Es的数据会被存储分片(shards)中，索引只是把一个或多个分片组合在一起的逻辑空间，对于程序员而言，只需要知道文档存储在索引中，至于“文档如何被索引的？”不需要关心。
注意：索引名字必须是全部小写，不能以下划线开头，不能包含逗号。
正向索引
正排表是以文档的ID为关键字，表中记录文档中每个字的位置信息，查找时以ID为顺序逐个文档进行匹配，搜索速度慢。
倒排索引
倒排表以字或词为关键字进行索引，表中关键字记录了对应的所有出现这个“字”或“词”的所有文档的ID（索引）。
正排索引是从文档到关键字的映射（已知文档找关键字），倒排索引是从关键字到文档的映射（已知关键字找文档）。
文档内容:
| 序号 | 文档内容 |
| 1 | 小俊是一家科技公司创始人，开的汽车是奥迪a8l，加速爽。 |
| 2 | 小薇是一家科技公司的前台，开的汽车是保时捷911 |
| 3 | 小红买了小薇的保时捷911，加速爽。 |
| 4 | 小明是一家科技公司开发主管，开的汽车是奥迪a6l,加速爽。 |
|
|
|
| 5 | 小军是一家科技公司开发，开的汽车是比亚迪速锐，加速有点慢 |
倒排索引会对以上文档内容进行关键词分词，可以使用关键次直接定位到文档内容。
| 单词ID | 单词 | 倒排列表docId |
| 1 | 小 | 1,2,3,4,5 |
| 2 | 一家 | 1,2,4,5 |
| 3 | 科技公司 | 1,2,4,5 |
| 4 | 开发 | 4,5 |
| 5 | 汽车 | 1,2,4,5 |
| 6 | 奥迪 | 1,4 |
| 7 | 加速爽 | 1,3,4 |
| 8 | 保时捷 | 2,3 |
| 9 | 保时捷911 | 2 |
| 10 | 比亚迪 | 5 |
类型（_type）
Es的类型(type)对应了关系型数据库中的“结构”， 就像传统数据库表中的列一样。所有类型下的文档被存储在同一个索引下。
注意：_type的名字可以是大写或小写，不能包含下划线或逗号。
唯一标识（_id）
id仅仅是一个字符串，它与_index和_type组合时，就可以在Elasticsearch中唯一标识一个文档。当创建一个文档，你可以自定义_id，也可以让Elasticsearch帮你自动生成。
ElastSearch 增删改查
格式：/索引/类型/id
Restful API：http://192.168.13.102:9200/lming/user/1
| 操作 | Kibana示例 |
| 增（POST/PUT） | POST /lming1/user1/2 { "name":"user1", "age":"30" } PUT /lming/user/1 { "name":"Lming", "age":"20" } |
| 删（DELATE） | DELETE /lming1/user1/2 批量删除： DELETE / lming1/user1/_query { "query": { "match_all": {} } } （ES2.0以后版本不支持批量删除，批量删除需要安装delete-by-query插件） |
| 改（PUT） | PUT /lming/user/1 { "name":"Lming2", "age":"20" } |
| 查（GET） | GET /lming/user/1 |
Elasticsearch版本控制
1.为什么要进行版本控制
为了保证数据再多线程操作下的准确性。
2.悲观锁和乐观锁
悲观锁：假设会发生并发冲突，屏蔽一切可能违反数据准确性的操作。
悲观锁：假设不会发生并发冲突，只在提交操作是检查是否违反数据完整性。
二、深入理解ElasticSearch集群设计理念
路由
当用户进行增删改查时，Elasticsearch是如何知道文档属于哪个分片的呢？
进程当然不是随机的。事实上，它根据一个简单的算法决定：
shard = hash(routing) % number_of_primary_shards
routing默认为id，number_of_primary_shards为集群主节点数。
读写分离
集群所有写的操作只能在主分片上完成，因为只要在主分片上完成才能同步到复制分片（也称之为“副分片”、“备用分片”），读的操作由所有分片负载完成，请求依然由主分片接受但内部会进行负载均衡转发到复制节点(默认轮询)。
replication
replication默认为sync，表示主分片得到复制分片的成功响应后才返回客户端(有超时时间)，如果你将其设置为async，则表示请求在主分片上被执行后就会返回给客户端，不论复制节点是否处理成功。
consistency
consistency选举策略衡量标准数量（quorum），默认为总节点数（可以是主节点或复制节点）的(1/2)+1。计算公式如下：
int( (primary(主) + number_of_replicas(复制)) / 2 ) + 1
consistency允许的值为one（只有一个主分片），all（所有主分片和复制分片）或者默认的quorum或过半分片。
注意：
新索引默认有1个复制分片，这意味着为了满足quorum的要求需要两个活动的分片。当然，这个默认设置将阻止我们在单一节点集群中进行操作。为了避开这个问题，规定数量只有在number_of_replicas大于一时才生效。
timeout
当分片副本不足时(宕机)会怎样？Elasticsearch会等待更多的分片出现。默认等待一分钟。可以设置timeout参数让它终止的更早：100表示100毫秒，30s表示30秒。
分布式局部更新
更新首先根据算法找到主节点，然后从主节点开始，一级一级的传递，知道所有节点全部更新完毕之后才会返回响应到客户端。
分布式批量请求(查询)
Es提供两种批量查询API：mget和bulk API
更新首先根据算法找到主节点，然后主节点为每一个节点构造一个请求（可以是主节点也可以是复制节点），当所有的请求全部成功之后，主节点整理响应结果并返回给客户端。
bulk API可以在最上层使用replication和consistency参数，routing参数则在每个请求的元数据中使用。
近实时搜索
简单的说，首先你需要了解什么是磁盘瓶颈问题？Es实现了持久化功能，每次搜索都需要到磁盘中读文档，每一次都refresh代价是很大的(官方称为“fsync同步”)。
为了解决磁盘瓶颈问题，Es引入了文件缓存系统，首次用户读取文档时将其缓存到文件缓存系统（内存）中，之后的用户会直接访问内存，文件在内存中有时间限制，默认一秒刷新到磁盘一次，增删改都会直接出发refresh。
通过refresh_interval进行设定。
PUT /my_logs
{"settings": {"refresh_interval": "30s" <1>}
}官方推荐在创建索引的时候可以关闭自动刷新，在要使用索引的时候再打开它。refresh_interval为-1时关闭自动刷新。
详细参考： 近实时搜索
持久化（可靠性）
简单的说，因为文件缓存系统和fsync同步机制存在，在进行fsync同步时出现宕机/电源断电情况就会导致数据丢失，这个数据我们也不想丢失怎么办？
ES增加了事务日志（translog），来记录每次操作，保证持久化过程的安全性以及可靠性。
详细参考：持久化变更
合并段（解决碎片化问题）
1、什么是段？以及段的作用
Elasticsearch底层依赖的Lucene，引入了per-segment search的概念。一个段(segment)是有完整功能的倒排索引。Lucene中的索引指的是段的集合+提交点(commit point，包括所有段的文件)，也就是一个提交点多个段组成了一个索引，正是因为这种结构所以他的搜索速度是非常可观的。
而新的文档，在被写入磁盘的段之前，首先写入内存缓冲区的索引缓存（In-memory buffer）。
提交后，新的段被加入到提交点中，缓存被清空。
2、段带来的碎片化问题
因为近实时搜索会不断产生“段”，这样用不了多久就会段的数量就爆炸啦。
每个段都需要消费文件句柄，内存，cpu资源，更重要的是，每次搜索请求都需要依次检查每个段。段越多，查询越慢。
ES通过后台合并段解决这个问题。小段被合并成大段，再合并成更大的段。
这个合并的过程有Es自行完成，开发者不必关系过程。
注意：合并大的段会消耗很多IO和CPU，如果不检查会影响到搜索性能。默认情况下，ES会限制合并过程，这样搜索就可以有足够的资源进行。Es提供optimize API进行合并大的段。
详细参考：合并段
9300与9200区别
9300端口： ES节点之间通讯使用
9200端口： ES节点和外部通讯使用
9300是TCP协议端口号，ES集群之间通讯端口号
9200端口号，暴露ES的RESTful接口端口号
ElasticSearch高级查询
格式：/索引/类型/id
| 类型 | Kibana示例 |
| 根据id查询 | GET /lming/user/1 |
| 查询所有类型文档 | GET /lming/user/_search |
| 根据多个ID批量查询 | GET /lming/user/_mget { "ids":[1,2,3] } |
| 复杂条件查询 | GET /lming/user/_search?q=age:21 |
| 区间查询 | GET /lming/user/_search?q=age[30 TO 60] |
Term与Match区别
Term查询不会对字段进行分词查询，会采用精确匹配。Match会根据该字段的分词器，进行分词查询。
文档映射
已经把ElasticSearch的核心概念和关系数据库做了一个对比，索引（index）相当于数据库，类型(type)相当于数据表，映射(Mapping)相当于数据表的表结构。ElasticSearch中的映射（Mapping）用来定义一个文档，可以定义所包含的字段以及字段的类型、分词器及属性等等。
文档映射就是给文档中的字段指定字段类型、分词器。
使用 GET /lming/user/_mapping
映射的分类
动态映射
我们知道，在关系数据库中，需要事先创建数据库，然后在该数据库实例下创建数据表，然后才能在该数据表中插入数据。而ElasticSearch中不需要事先定义映射（Mapping），文档写入ElasticSearch时，会根据文档字段自动识别类型，这种机制称之为动态映射。
静态映射
在ElasticSearch中也可以事先定义好映射，包含文档的各个字段及其类型等，这种方式称之为静态映射。
ES类型支持
基本类型
符串：string，string类型包含 text 和 keyword。
text：该类型被用来索引长文本，在创建索引前会将这些文本进行分词，转化为词的组合，建立索引；允许es来检索这些词，text类型不能用来排序和聚合。
keyword：该类型不需要进行分词，可以被用来检索过滤、排序和聚合，keyword类型自读那只能用本身来进行检索（不可用text分词后的模糊检索）。
注意: keyword类型不能分词，Text类型可以分词查询
数指型：long、integer、short、byte、double、float
日期型：date
布尔型：boolean
二进制型：binary
数组类型（Array datatype）
三、ElasticSearch集群搭建
Linux环境安装Elasticsearch
1.安装JDK环境
ElasticSearch是对Lucene的封装，Lucene使用JDK开发。
export JAVA_HOME=/usr/local/jdk1.8.0_181
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jarsource /etc/profile2.下载elasticsearch安装包
下载elasticsearch安装包
官方文档https://www.elastic.co/downloads/elasticsearch
注意：linux安装内存建议1g内存以上，考虑下面还要安装Kabana设置为1.5g。
3.上传elasticsearch安装包
4.解压elasticsearch
tar -zxvf elasticsearch-6.4.3.tar.gz5.修改elasticsearch.yml
network.host: 192.168.212.151
http.port: 92006.启动elasticsearch报错
cd /usr/local/elasticsearch-6.4.3/bin
./elasticsearch| can not run elasticsearch as root 解决方案: 因为安全问题elasticsearch
不让用root用户直接运行，所以要创建新用户 第一步：liunx创建新用户 adduser XXX 然后给创建的用户加密码 passwd XXX 输入两次密码。 第二步：切换刚才创建的用户 su XXX 然后执行elasticsearch 会显示Permission denied 权限不足。 第三步：给新建的XXX赋权限，chmod 777 * 这个不行，因为这个用户本身就没有权限，肯定自己不能给自己付权限。所以要用root用户登录付权限。 第四步：root给XXX赋权限，chown -R XXX /你的elasticsearch安装目录。 然后执行成功。
创建一个分组 groupadd lming useradd esyushengjun -g lming -p 123456 chown -R esyushengjun: lming elasticsearch-6.4.3 su esyushengjun 切换用户
继续报错 bootstrap checks failed max virtual memory areas vm.max_map_count [65530] is
vi /etc/sysctl.conf vm.max_map_count=655360 sysctl p
max file descriptors [4096] for elasticsearch process is too low, increase to at least [65536] vi /etc/security/limits.conf * soft nofile 65536 * hard nofile 131072 * soft nproc 2048 * hard nproc 4096
重启服务器即可 |
7.访问elasticsearch
关闭防火墙
systemctl stop firewalld.servicehttp://192.168.212.151:9200
中文分词器
什么是分词器？
因为Elasticsearch中默认的标准分词器分词器对中文分词不是很友好，会将中文词语拆分成一个一个中文的汉子。因此引入中文分词器-es-ik插件。
一下为各大主流中文分词器：
| 名称 | 最近更新 | 速度(网上情报) | 扩展性支持、其它 |
| mmseg4j | 2013 | complex 60W字/s (1200 KB/s) simple 100W字/s (1900 KB/s) | 使用sougou词库，也可自定义 (complex\simple\MaxWord) |
| IKAnalyzer | 2012 | IK2012 160W字/s (3000KB/s) | 支持用户词典扩展定义、支持自定义停止词 (智能\细粒度) |
| Ansj | 2014 | BaseAnalysis 300W字/s hlAnalysis 40W字/s | 支持用户自定义词典，可以分析出词性，有新词发现功能 |
| paoding | 2008 | 100W字/s | 支持不限制个数的用户自定义词库 |
ES分词演示（使用Postman进行演示）：
http://192.168.212.181:9200/_analyze post请求
json参数：
| json参数： { "analyzer": "standard", "text": "这是ES自带分词器效果" } |
ES集成IK分词器
下载地址: https://github.com/medcl/elasticsearch-analysis-ik/releases
注意: es-ik分词插件版本一定要和es安装的版本对应
第一步：下载es的IK插件（资料中有）命名改为ik插件
第二步: 上传到/usr/local/elasticsearch-6.4.3/plugins
第三步: 重启elasticsearch即可。
第四步: 重试以上请求会发现分词结果不一样。
IK自定义扩展词典
定义：自定义扩展词典可以帮助我们添加扩展分词。不懂？使用如上请求对自己名字进行分词，结果大多应该是一个一个的字（除非你/他很有名），如果想要让自己的名字被分词之后是一个整体的词的话就需要引入扩展词典。
集成：
① 在/usr/local/elasticsearch-6.4.3/plugins/ik/config目录下添加：
| vim custom/new_dic.dic |
| 把这一行换成你的名字 老铁 王者荣耀 洪荒之力 |
注意：linux可能无法识别dic后缀文件，如果添加自定义词典后没有效果，请查看new_dic.dic是否乱码，如有乱码请copy原始字典进行替换。
② vi IKAnalyzer.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties><comment>IK Analyzer 扩展配置</comment><!--用户可以在这里配置自己的扩展字典 --><entry key="ext_dict">custom/new_word.dic</entry><!--用户可以在这里配置自己的扩展停止词字典--><entry key="ext_stopwords"></entry><!--用户可以在这里配置远程扩展字典 --><!-- <entry key="remote_ext_dict">words_location</entry> --><!--用户可以在这里配置远程扩展停止词字典--><!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>
再次对你的name进行分词验证。
Linux环境安装Kibana
Kabana介绍
Kibana是一个开源的分析和可视化平台，设计用于和Elasticsearch一起工作。
你用Kibana来搜索，查看，并和存储在Elasticsearch索引中的数据进行交互。
你可以轻松地执行高级数据分析，并且以各种图标、表格和地图的形式可视化数据。
Kibana使得理解大量数据变得很容易。它简单的、基于浏览器的界面使你能够快速创建和共享动态仪表板，实时显示Elasticsearch查询的变化。
Kibana环境安装
| tar -zxvf kibana-6.4.3-linux-x86_64.tar.gz vim config/kibana.yml |
| # 将默认配置改成如下： server.port: 5601 server.host: "192.168.212.151" elasticsearch.url: "http:// 192.168.212.151:9200" |
启动Kibana
| ./bin/kibana |
http://192.168.212.179:5601/app/kibana
Kabana使用非常简单，如果有不明白请使用Google浏览器进行翻译，是在不懂就百度。
Elasticsearch分布式集群搭建
概念
首先ES索引被分为多段，每一个段为一个分片（主分片，默认一个集群五个主分片），分片有两种类型主分片、复制分片，每一个主分片可对应多个复制分片，复制分片存放的数据与对应主分片保持同步，主分片与复制分片不能存放在统一个服务器上。
三个主分片，每一个主分片拥有一个复制分片：
P为主分片，R为复制分片
也可以是，三个主分片，每一个主分片拥有两个复制分片：
P0主分片有R0_1和R0_2两个复制节点
思考：为什么主分片数不可变，复制分片数可变？
为什么这样设计？
主分片数不可变是因为ES需要实现路由算法以及负载均衡算法，两种算法在上面已有介绍过
复制分片数可变是因为需要实现动态横向扩展，但匜存在缺点，拓展的的节点只能是从分片，而ES从分片是可读不可写的，因此当系统并发读请求过高的时候，可以直接进行动态横向扩展。
集群搭建
准备三台服务器/虚拟机集群，单台服务器最少1.5G内存。
| 服务器名称 | IP地址 |
| node-1 | 192.168.212.182 |
| node-2 | 192.168.212.183 |
| node-3 | 192.168.212.184 |
服务集群配置
vi elasticsearch.yml
cluster.name: myes ###保证三台服务器节点集群名称相同
node.name: node-1 #### 每个节点名称不一样 其他两台为node-1 ,node-2
network.host: 192.168.212.180 #### 实际服务器ip地址
discovery.zen.ping.unicast.hosts:["192.168.212.184",”192.168.212.185","192.168.212.186"]##多个服务集群ip
discovery.zen.minimum_master_nodes: 1 ##用于选举的参数，详细请参考官方关闭防火墙 systemctl stop firewalld.service，注意yml文件格式，”:”后面有一个空格。
默认底层开启9300 进行集群通讯
验证集群效果
http://192.168.212.185:9200/_cat/nodes?pretty
注意克隆data文件会导致数据不同步
报该错误解决办法
failed to send join request to master
因为克隆导致data文件也克隆呢，直接清除每台服务器data文件。
*号表示为master节点
四、ELK分布式日志收集
Logstash原理
在ELK中Logstash扮演的身份就是日志文件的转存者，如上图中Data Source 在ELK中就是本地的.log文件，输入input负责将.log文件格式化后输入Logstash，Filter可实现各种过滤，如数据解析、删除字段、类型转换等等，输出Output则负责将格式化好的json PUT到ElasticSearch中。
提示：真实集群下，Logstash安装在应用服务器上，（分布式微服务）服务集群则是每一台都需要安装一个Logstash，因为Logstash需要读取本地log文件，而ES与Kabana则是与应用服务器隔开的，是一个单独的集群。
ELK搭建
Elasticsearch+Logstash+Kiabana环境安装 建议内存设置为2G。
es版本必须要与kibana版本对应！！
关闭防火墙
Elasticsearch环境安装：
不懂请看上面☝ ☝ ☝。
Logstash环境安装：
1、上传logstash安装包(资料)
2、解压tar –zxvf logstash-6.4.3.tar.gz
3、在config目录下放入myELK01.conf 读入并且读出日志信息
4、启动 ./bin/logstash -f ./config/myELK01.conf
注意：启动后如果没有报错需要等待logstash 完成，此时间可能比较长
温馨提示：大型日志文件查询
查询前300行 包含node-1内容
| tail -n 300 myes.log | grep 'node-1' |
实时打印日志
| tail -100f myes.log |
myELK01.conf （标准打印）
input {# 从文件读取日志信息 输送到控制台
file {###ES日志存放路径，真实环境改成对应服务的日志文件存放位置即可###input 可配置多个，每一个日志文件对应一个path => "/usr/local/Elasticsearch/elasticsearch-6.4.3/logs/myEs.log" codec => "json" ## 以JSON格式读取日志type => "elasticsearch" ###类型名称随便取start_position => "beginning"}}# filter {
#
# }output {# 标准输出 # stdout {}# 输出进行格式化，采用Ruby库来解析日志 stdout { codec => rubydebug }
}
启动成功之后可以看到myEs.log中的每一行都会被格式化成json输出在控制台，尝试切换回root用户重启ES报错时，报错信息会在Logstash控制台打印。
将Logstash输入到ES中：
修改myELK.conf
input {# 从文件读取日志信息 输送到控制台file {path => "/usr/local/elasticsearch-6.4.3/logs/myes.log"codec => "json" ## 以JSON格式读取日志type => "elasticsearch"start_position => "beginning"}
}# filter {
#
# }output {# 标准输出 # stdout {}# 输出进行格式化，采用Ruby库来解析日志 stdout { codec => rubydebug }elasticsearch {hosts => ["192.168.212.190:9200"]index => "es-%{+YYYY.MM.dd}" ##ES索引名称}
}
Kabana环境安装：
不懂请看上面☝ ☝ ☝。
访问下面的界面，可进行ES界面话查询
http://192.168.13.102:5601/app/kibana#/discover
高级查询：
http://192.168.13.102:5601/app/kibana#/dev_tools/console
相关语法参考：
https://es.xiaoleilu.com/030_Data/00_Intro.html
五、ElasticSearch网盘搜索引擎（Springboot2.0版）
请先安装好lombok插件，至于lombok干啥用的，自己百度吧，这么好的东西都不知道，你是程序员？
Eclipse走：https://blog.csdn.net/Dorothy1224/article/details/79280591/
IDEA走：https://blog.csdn.net/zhglance/article/details/54931430
步骤分析：
爬取网盘链接，网盘链接分为两种，无需密码的分享链接和需要密码的加密链接两种。
无需密码大多直接对百度云盘用户分享文件进行爬虫：
http://yun.baidu.com/s/1c21LahU其中c21LahU是可变的。详细请参考：MultiThread.java示例。
需要密码主要通过网盘资源网站爬得源码并使用Jsoup进行正则匹配链接地址和密码，并进行验证，高级的则是爬取CSDN、Baidu、Google等大型网站。
在这里我们就通过爬取http://bestcbooks.com/链接地址和密码并验证后添加到ElasticSearch中.
分析网站：
分析网站得出解析步骤：
首先通过Jsoup请求http://bestcbooks.com/解析得到源码并使用/categories(.*)正则解析得到分类导航的请求列表。循环执行分类Joup请求解析源码得到单本书籍详细页面的连接，在通过解析详细页面得到网盘链接地址和密码。源码请参考：CrawlBook.java 。
而得到链接地址和密码是不够的，我们还需要进行验证，并进一步得到更多详细信息，如分享人的头像、名称、文件大小等。最后我们还需要添加到ES中。
源码请参考：ReptileMain.java。最后我们还需要实现web端的分页展示ES数据。
源码：
源码下载地址：https://gitee.com/Xie723/SpringCloud2_Config_Server/blob/master/ESou.zip
添加ElasticSearch数据结构：
POST /clouddisk/_mapping/disk
{"disk": {"properties": {"baiduaddres": {"type": "keyword"},"browsetimes": {"type": "long"},"collectiontime": {"type": "date"},"describe": {"type": "text","analyzer": "ik_smart"},"filesize": {"type": "float"},"name": {"type": "text","analyzer": "ik_smart"},"sharpeople": {"type": "keyword"},"shartime": {"type": "date"},"source": {"type": "keyword"}}}
}Maven依赖：
<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.0.RELEASE</version><relativePath /></parent><dependencies><!-- https://mvnrepository.com/artifact/com.google.code.gson/gson --><dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId><version>2.8.0</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.32</version></dependency><!-- sb web 依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- sb es 依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency><!-- jsoup HTML解析依赖 --><dependency><groupId>org.jsoup</groupId><artifactId>jsoup</artifactId><version>1.8.3</version></dependency><!-- lombok驱动包依赖 --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><!-- google collections依赖这个你不会不知道吧？不知道？别学java了！ --><dependency><groupId>com.google.collections</groupId><artifactId>google-collections</artifactId><version>1.0-rc2</version></dependency><!-- springboot整合freemarker --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-freemarker</artifactId></dependency></dependencies>
application.yml
spring:data:elasticsearch:####集群名称，注意如果报错节点不存在，需要在$ES/config/elasticsearch.yml中配置：###cluster.name: myEscluster-name: myEs####地址 cluster-nodes: 192.168.13.102:9300freemarker:# 设置模板后缀名suffix: .html# 设置文档类型content-type: text/html# 设置页面编码格式charset: UTF-8# 设置页面缓存cache: false# 设置ftl文件路径template-loader-path:- classpath:/templates# 设置静态文件路径，js,css等mvc:static-path-pattern: /static/**
Es实体层：
CloudDiskEntity.java
package com.lming.entity;import java.util.Date;import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;import lombok.Data;@Data
@Document(indexName = "clouddisk", type = "disk")
public class CloudDiskEntity {@Idprivate String id;// 名称private String name;// 来源private String source;// 描述private String describe;// 分享时间private Date shartime;// 浏览次数private Long browsetimes;// 文件大小private Double filesize;// 分享人private String sharpeople;// 收录时间private String collectiontime;// 地址private String baiduaddres;
}
Response20.java
package com.lming.entity;import lombok.Data;/*** 服务器返回的json，转java对象 错误码为20 代表需要验证码* * @author gaoqiang**/
@Data
public class Response20 {String errno;String request_id;String server_time;String vcode;String img;
}SetDataBean.java
package com.lming.entity;import lombok.Data;@Data
public class SetDataBean {private String sign;private String timestamp;private String bdstoken;private String uk;private String shareid;private FileList file_list;private String photo; // 头像private String linkusername;@Datapublic static class FileList {String errno;List[] list;}@Datapublic static class List {String app_id;String fs_id;String server_filename;String server_mtime;String size;}}Es Dao层：
public interface CloudDiskDao extends ElasticsearchRepository<CloudDiskEntity, String> {
// 提供自定义化功能
}
Es API控制层：
import java.util.List;
import java.util.Optional;import org.apache.commons.lang.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.data.web.PageableDefault;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import com.google.common.collect.Lists;
import com.lming.entity.CloudDiskEntity;
import com.lming.esdao.CloudDiskDao;
import com.lming.reptile.CrawlBook;
@RestController
public class CloudDiskController {@Autowiredprivate CloudDiskDao cloudDiskDao;// springboot 整合 es 查询// 根据id查询文档信息@RequestMapping("/findById/{id}")public Optional<CloudDiskEntity> findById(@PathVariable String id) {return cloudDiskDao.findById(id);}// 爬取数据@GetMapping("/CrawlBookGo")public void addEs(CloudDiskEntity cde) {CrawlBook.crawlingBook(cloudDiskDao);}
// 实现分页查询@RequestMapping("/search")public List<CloudDiskEntity> search(String name, String describe,@PageableDefault(page = 0, value = 2) Pageable pageable) {// 1.创建查询对象BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();if (!StringUtils.isEmpty(name)) {MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("name", name);boolQuery.must(matchQuery);}if (!StringUtils.isEmpty(describe)) {MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("describe", describe);boolQuery.must(matchQuery);}// 2.调用查询接口Iterable<CloudDiskEntity> search = cloudDiskDao.search(boolQuery, pageable);// 3.将迭代器转换为集合return Lists.newArrayList(search);}
}Es 控制层：
import javax.servlet.http.HttpServletRequest;import org.apache.commons.lang.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.web.PageableDefault;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;import com.lming.entity.CloudDiskEntity;
import com.lming.esdao.CloudDiskDao;
@Controller
public class PageController {@Autowiredprivate CloudDiskDao cloudDiskDao;@RequestMapping("/search")public String search(String keyword, @PageableDefault(page = 0, value = 3) Pageable pageable,HttpServletRequest req) {Long startTime = System.currentTimeMillis();// 查询所有的BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();if (!StringUtils.isEmpty(keyword)) {// 模糊查询 一定要ik中文MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("name", keyword);boolQuery.must(matchQuery);}Page<CloudDiskEntity> page = cloudDiskDao.search(boolQuery, pageable);req.setAttribute("page", page);// 计算查询总数long total = page.getTotalElements();req.setAttribute("total", page.getTotalElements());// 计算分页数int totalPage = (int) ((total - 1) / pageable.getPageSize() + 1);req.setAttribute("totalPage", totalPage);Long endTime = System.currentTimeMillis();// 计算程序的耗时时间req.setAttribute("time", endTime - startTime);req.setAttribute("keyword", keyword);return "search";}
}
CrawlBook.java
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;import com.alibaba.fastjson.JSONArray;
import com.lming.entity.CloudDiskEntity;
import com.lming.esdao.CloudDiskDao;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.SocketException;
import java.net.URL;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CrawlBook {public static void main(String[] args) throws ParseException {String s = "Android\\u9a71\\u52a8\\u5f00\\u53d1\\u4e0e\\u79fb\\u690d\\u5b9e\\u6218\\u8be6\\u89e3.pdf";String[] split = s.split("\\.");System.out.println(JSONArray.toJSON(split));}public static Date stampToDate(String s) {
// String res;
// SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");long lt = new Long(s);Date date = new Date(lt);
// res = simpleDateFormat.format(date);return date;}transient static int modCount;public static void crawlingBook(CloudDiskDao cloudDiskDao) {// 获取分类链接ArrayList<String> arrayList;try {arrayList = getBookClass(getBookUrlCode("http://bestcbooks.com/"));for (int i = 0; i < arrayList.size(); i++) {if (modCount == 10) // 爬取数据过多，为了测试进行中断爬取break;// 循环分类链接请求String read = getBookUrlCode("http://bestcbooks.com" + arrayList.get(i));// 获取所有该分类下所有书籍链接ArrayList<String> book = getBook(read);for (int j = 0; j < book.size(); j++) {String[] bookIn = book.get(j).split("\"");String myBook = bookIn[1];// 请求书籍详情页获得 网盘链接和密码String myBookCode = getBookUrlCode("http://bestcbooks.com" + myBook);// System.out.println(myBookCode);String url = findURL(myBookCode);String password = getPassword(myBookCode);// 验证连接并进一步获取网盘信息Map<String, String> map = null;try {map = ReptileMain.getDetailed(url, password);} catch (SocketException se1) {try {map = ReptileMain.getDetailed(url, password);System.err.println("爬虫重试机制运行：第二次重试.....");} catch (SocketException se2) {try {System.err.println("爬虫重试机制运行：第三次重试.....");map = ReptileMain.getDetailed(url, password);} catch (SocketException se3) {System.out.println("模拟重试机制3次！异常连接：" + url + ",password:" + password);}}} catch (Exception e) {System.err.println(e.getMessage());}CloudDiskEntity cde = new CloudDiskEntity();cde.setName(map.get("server_filename").split("\\.")[0]);cde.setSource("百度云盘");cde.setDescribe("这是一段描述"); // 未爬取cde.setBrowsetimes(10l);cde.setFilesize((double) (Math.round((Float.parseFloat(map.get("size")) / 1024 / 1024) * 10)) / 10);cde.setShartime(stampToDate(map.get("server_mtime") + "000"));cde.setSharpeople(map.get("linkusername"));cde.setCollectiontime(new SimpleDateFormat("yyyy-MM-dd").format(new Date()));cde.setBaiduaddres(url);// save到ElasticSearch中CloudDiskEntity save = cloudDiskDao.save(cde);System.out.println("ElasticSearch添加成功：" + JSONArray.toJSONString(save) + "\n");modCount++;}}} catch (IOException e) {e.printStackTrace();}}/*** 更具URL获取请求资源* * @param url 请求地址* @return 返回字符串型 网页源码* @throws IOException*/public static String getBookUrlCode(String url) throws IOException {URL u;HttpURLConnection httpURLConnection;String ret = "";try {u = new URL(url);httpURLConnection = (HttpURLConnection) u.openConnection();if (httpURLConnection.getResponseCode() == 200) {BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream(), "utf-8"));String read;while ((read = bufferedReader.readLine()) != null) {ret += read;ret += "\r\n";}}} catch (Exception e) {}return ret;}/*** 获得所有书籍分类 链接 列表* * @param read 页面源码* @return*/public static ArrayList<String> getBookClass(String read) {ArrayList<String> arrayList = new ArrayList<String>();Document doc = Jsoup.parse(read);Elements elements = doc.select("a"); // 查询a标签for (Element element : elements) {String aurl = element.attr("href"); // 获取href属性值// 正则：获取aurl中所有以 /categories开头的hrefString con = "/categories(.*)";Pattern ah = Pattern.compile(con);Matcher mr = ah.matcher(aurl);// 进行正则匹配while (mr.find()) {if (!arrayList.contains(mr.group())) {// 将符合正则的内容添加到列表arrayList.add(mr.group());}}}return arrayList;}/*** 正则获取 链接+图片* * @param read* @return*/public static ArrayList<String> getBook(String read) {ArrayList<String> arrayList = new ArrayList<String>();String con = "<a href=(.*)<img src=\"/images/download";Pattern ah = Pattern.compile(con); // 创建正则表达式对象Matcher mr = ah.matcher(read); // 创建匹配器while (mr.find()) {if (!arrayList.contains(mr.group())) {arrayList.add(mr.group());}}return arrayList;}/*** 正则获得百度网盘链接* * @param read 网页源码*/public static String findURL(String read) {String con = "<a href=\"(.*)pan.baidu.com(.*)ref";Pattern ah = Pattern.compile(con);Matcher mr = ah.matcher(read);if (mr.find()) {String[] bookPan = mr.group().split("\"");String bookM = bookPan[1];System.out.print(bookM + " ");return bookM;}return null;}/*** 正则获得百度网盘链接* * @param read 网页源码*/public static String getPassword(String read) {String con = "密码(.*)";Pattern ah = Pattern.compile(con);Matcher mr = ah.matcher(read);if (mr.find()) {String pass = mr.group();System.out.println(pass);return pass.substring(3, 7);}System.out.println();return null;}
}
ReptileMain.java
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;import org.jsoup.Connection;
import org.jsoup.Connection.Method;
import org.jsoup.Connection.Response;
import org.jsoup.Jsoup;import com.alibaba.fastjson.JSONArray;
import com.google.gson.Gson;
import com.lming.entity.SetDataBean;public class ReptileMain {// 下载链接和提取码private static String url = "http://pan.baidu.com/s/1pJ4k7VX";private static String pwd = "6ts6";// 这几个参数不要动private static final String baseUrl = "https://pan.baidu.com/share/verify?surl=";private static String params = "";// 下载参数，文件名及文件大小private static String server_filename = null;private static String size = null;// 从cookie中获取的重要参数 核心参数private static String sekey = "";static Map<String, String> getDetailed(String linkUrl,String password) throws IOException{
// System.out.println("url:"+url+",pwd:"+pwd);url = linkUrl;if(password != null)pwd = password;// 获取CookiesMap<String, String> cookies = getCookies();// 更具请求URL获取页面Connection.Response res2 = Jsoup.connect(url).method(Method.POST).cookies(cookies).timeout(60 * 1000).ignoreContentType(true).execute();
// System.out.println(res2.body());// getBodyParams解析body获取POST请求的参数Map<String, String> params = getBodyParams(res2.body());return params;}/********************* 如下为解析百度网盘获得真实下载地址参考Demo（如果你想要做下载器的话） ***************************/public static void main(String[] args) throws IOException {// 获取CookiesMap<String, String> cookies = getCookies();// 更具请求URL获取页面Connection.Response res2 = Jsoup.connect(url).method(Method.POST).cookies(cookies).ignoreContentType(true).execute();// System.out.println(res2.body());// getBodyParams解析body获取POST请求的参数Map<String, String> params = getBodyParams(res2.body());// getPostUrl获取POST请求URLString post_url = getPostUrl(params);// 设置SekeygetSekeyBycookies(cookies);// 获取dataMap<String, String> data = getPostData(params);// 发送POST请求Response res3 = Jsoup.connect(post_url).method(Method.POST).header("Referer", url).cookies(cookies).data(data).ignoreContentType(true).timeout(1000 * 60).execute();String URL = parseRealDownloadURL(JSONArray.toJSONString(res3));System.out.println(URL);}public static Map<String, String> getCookies() throws IOException {String surl = url.split("/s/1")[1];params += "&t=" + System.currentTimeMillis() + "channel=chunlei&web=1&app_id=230528&clienttype=0";Connection.Response res = Jsoup.connect(baseUrl + surl + params).header("Referer", "https://pan.baidu.com/share/init?surl=" + surl).data("pwd", pwd).method(Method.POST).timeout(60 * 1000).ignoreContentType(true).execute();Map<String, String> cookies = res.cookies();return cookies;}public static String getPostUrl(Map<String, String> params) {StringBuffer sb1 = new StringBuffer();sb1.append("https://pan.baidu.com/api/sharedownload?");sb1.append("sign=" + params.get("sign"));sb1.append("×tamp=" + params.get("timestamp"));sb1.append("&channel=chunlei");sb1.append("&web=1");sb1.append("&app_id=" + params.get("app_id"));sb1.append("&clienttype=0");String post_url = sb1.toString();return post_url;}public static Map<String, String> getBodyParams(String body) {Map<String, String> map = new HashMap<String, String>();String setData = "";Pattern pattern_setData = Pattern.compile("setData.*?;");Matcher matcher_setData = pattern_setData.matcher(body);if (matcher_setData.find()) {String tmp = matcher_setData.group(0);setData = tmp.substring(8, tmp.length() - 2);System.out.println(setData); // 查看完整响应json数据Gson gson = new Gson();SetDataBean bean = gson.fromJson(setData, SetDataBean.class);// map.put("sign", bean.getSign());
// map.put("timestamp", bean.getTimestamp());
// map.put("bdstoken", bean.getBdstoken());
// map.put("app_id", bean.getFile_list().getList()[0].getApp_id());
// map.put("uk", bean.getUk());map.put("photo", bean.getPhoto());map.put("linkusername", bean.getLinkusername());
// map.put("shareid", bean.getShareid());
// map.put("primaryid", bean.getShareid());
// map.put("fs_id", bean.getFile_list().getList()[0].getFs_id());
// map.put("fid_list", bean.getFile_list().getList()[0].getFs_id());map.put("server_filename", bean.getFile_list().getList()[0].getServer_filename());map.put("server_mtime", bean.getFile_list().getList()[0].getServer_mtime());map.put("size", bean.getFile_list().getList()[0].getSize());
// map.put("logid", logid);}
// System.out.println(JSONArray.toJSONString(map));return map;}// 解析cookies获取sekeyprivate static void getSekeyBycookies(Map<String, String> cookies) throws UnsupportedEncodingException {String bdclnd = cookies.get("BDCLND");if (null != bdclnd && !"".equals(bdclnd)) {sekey = java.net.URLDecoder.decode(bdclnd, "UTF-8");}}// 获取POST请求需要的data系参数public static Map<String, String> getPostData(Map<String, String> params) {// POST携带的参数(抓包可看到)Map<String, String> data = new HashMap<String, String>();data.put("encrypt", "0");data.put("product", "share");data.put("uk", params.get("uk"));data.put("primaryid", params.get("primaryid"));// 添加了[]data.put("fid_list", "[" + params.get("fid_list") + "]");data.put("path_list", "");// 可以不写data.put("extra", "{\"sekey\":\"" + sekey + "\"}");return data;}// 获取到真实路径public static String parseRealDownloadURL(String responseJson) {String realURL = "";Pattern pattern = Pattern.compile("\"dlink\":.*?,");Matcher matcher = pattern.matcher(responseJson);if (matcher.find()) {String tmp = matcher.group(0);String dlink = tmp.substring(9, tmp.length() - 2);realURL = dlink.replaceAll("\\\\", "");}return realURL;}}
MultiThread.java
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;class mythread implements Runnable {Long count;public void run() {try {// count最大值 1813454114for (; this.count < 1813454114; this.count++) {PrintWriter printWriter = new PrintWriter(new FileWriter(new File("F:/url.txt"), true));PrintWriter cachePrintWriter = new PrintWriter(new FileWriter(new File("F:/index.txt"), false));cachePrintWriter.println(this.count);cachePrintWriter.close();String url = "http://pan.baidu.com/wap/share/home?uk=" + this.count;Document doc = Jsoup.connect(url).timeout(60000).get();String title = doc.title();System.out.println(title + this.count);Element content = doc.body();Elements emptytag = content.select(".empty-other");// 看是否有分享 为空则是有分享if (emptytag.isEmpty()) {System.out.println("有分享");Elements dataems = content.select("[data-ac=active]");for (Element dataem : dataems) {Elements lists = dataem.select(".list-item");String sourcename = dataem.attr("data-fn");if (sourcename != "") {if (!sourcename.matches("^\\w+.[^sS]+$|^\\w+[-]\\w+.[^sS]+$|^\\w+[.?!;]\\w+.[^Ss]+$|\\w+|^.*[!？?！].*$")) {System.out.println("不是数字");if (sourcename.indexOf("医院") == -1 && sourcename.indexOf("淘宝") == -1&& sourcename.indexOf("彩票") == -1 && sourcename.indexOf("福彩") == -1&& sourcename.indexOf("牌") == -1 && sourcename.indexOf("双色球") == -1&& sourcename.indexOf("创业") == -1 && sourcename.indexOf("咨询") == -1&& sourcename.indexOf("赚") == -1 && sourcename.indexOf("网店") == -1&& sourcename.indexOf("营销") == -1 && sourcename.indexOf("娱乐") == -1&& sourcename.indexOf("cf刷枪") == -1 && sourcename.indexOf("哪里") == -1&& sourcename.indexOf("麻将") == -1 && sourcename.indexOf("作弊") == -1&& sourcename.indexOf("早泄") == -1 && sourcename.indexOf("人流") == -1&& sourcename.indexOf("包皮") == -1 && sourcename.indexOf("痔") == -1&& sourcename.indexOf("肾") == -1 && sourcename.indexOf("治疗") == -1&& sourcename.indexOf("病") == -1 && sourcename.indexOf("哪家") == -1&& sourcename.indexOf("哪个") == -1 && sourcename.indexOf("妇科") == -1&& sourcename.indexOf("男科") == -1 && sourcename.indexOf("复件") == -1&& sourcename.indexOf("痘") == -1 && sourcename.indexOf("免费") == -1&& sourcename.indexOf("qq") == -1 && sourcename.indexOf("QQ") == -1&& sourcename.indexOf("减肥") == -1 && sourcename.indexOf("高考志愿") == -1&& sourcename.indexOf("瘦身") == -1 && sourcename.indexOf("新建") == -1&& sourcename.indexOf("挂") == -1 && sourcename.indexOf("解压") == -1&& sourcename.indexOf("肝") == -1 && sourcename.indexOf("炎") == -1&& sourcename.indexOf("补丁") == -1 && sourcename.indexOf("疤痕") == -1&& sourcename.indexOf(".exe") == -1 && sourcename.indexOf("刷") == -1&& sourcename.indexOf(".com") == -1 && sourcename.indexOf("美女") == -1) {System.out.println(sourcename);printWriter.println(sourcename);for (Element listem : lists) {String linkHref = url + listem.attr("href");printWriter.println(linkHref);System.out.println(linkHref);}} else {System.out.println(sourcename);}} else {System.out.println("是数字");}}}}printWriter.close();cachePrintWriter.close();}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}
search.html
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>ESou搜索引擎</title>
<!-- 新 Bootstrap 核心 CSS 文件 -->
<link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
<!-- 可选的Bootstrap主题文件（一般不使用） -->
<script src="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap-theme.min.css"></script>
<!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
<script src="https://cdn.bootcss.com/jquery/2.1.1/jquery.min.js"></script>
<!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
<script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
</head>
<body style="display: block; margin: 0 auto; width: 50%; " ><div style="width:100%;height:60px;" align="center"><h2 style="color:#985f0d;">ESou网盘搜索引擎</h2></div><br/><div align="center"><span style="font-size: 18px;" >检索出${total}条数据,耗时:${time}毫秒</span></div><br/><br/><div align="center"><a href="/CrawlBookGo" style="font-size: 16px;font-weight: bold;">点击开始爬取www.cnblogs.com网站数据</a></div><br/><br/><div class="bs-example" data-example-id="striped-table"><table class="table table-bordered table-hover"><thead><tr><th style="text-align:center;" scope="row">链接名称</th><th style="text-align:center;">文件大小MB</th><th style="text-align:center;">分享人</th><th style="text-align:center;">云盘地址</th></tr></thead><tbody><#list page.content as p><tr ><th style="text-align: left;" ><#if keyword??>${p.name?replace(keyword, '<span style="color: red">${keyword}</span>')}<#else>${p.name}</#if></th><th style="text-align: center;">${p.filesize}</th><th style="text-align: center;">${p.sharpeople}</th><th style="text-align: center;"><a href="${p.baiduaddres}">云盘地址</a> </th></tr></#list> </tbody></table><div style="font-size: 21px;"><#list 1..totalPage as i> <#if keyword??><a href="/search?keyword=${keyword}&page=${i-1}" >${i}</a><#else><a href="/search?page=${i-1}" >${i}</a></#if> </#list>页</div></div>
</body>
</html>
