Elasticsearch 与 Solr 的比较总结
下载地址：https://www.elastic.co/cn/downloads/elasticsearch
安装
1 解压
2 进入bin目录
3 启动 elasticsearch.bat
目录：
bin 启动文件
config 配置文件
log4j2 日志配置文件
jvm.options java 虚拟机相关的配置
elasticsearch.yml elasticsearch 的配置文件！ 默认 9200 端口！ 跨域！
lib 相关jar包
logs 日志！
modules 功能模块
plugins 插件！
访问：http://127.0.0.1:9200/
下载地址：https://github.com/mobz/elasticsearch-head
安装：
1 elasticsearch-head-master 解压
2 npm install 安装环境
3.npm run start 启动
默认端口9100，想访问9200，出现跨域问题
解决：
打开elasticsearch-7.12.1\config\elasticsearch.yml
http.cors.enabled: true #允许跨域
http.cors.allow-origin: "*" #允许所有人访问
下载地址：https://www.elastic.co/cn/downloads/kibana
1、解压
2、启动 kibana.bat
3、访问测试 http://localhost:5601/
4、开发工具！ （Post、curl、head、谷歌浏览器插件测试！）
5、汉化,kibana-7.12.1-windows-x86_64\config\kibana.yml
- i18n.locale: "zh-CN"
关系型数据库和elasticsearch客观的对比！一切都是json
| Relational DB | Elasticsearch |
|---|---|
| 数据库（database） | 索引（indices） |
| 表（tables） | 类型（types） |
| 行（rows） | 文档（documents） |
| 字段（columns） | fields |
elasticsearch（集群）可以包含多个索引（数据库），每个索引中可以包含多个类型（表），每个类型下又包含多个文档（行），每个文档又包含多个字段（列）。
物理设计：
elasticsearch在后台把每个索引划分成多个分片。每个分片可以在集群中的不同服务器间迁移，一个人就是一个集群，默认集群名就是elasticsearch
逻辑设计：
一个索引类型中，包含多个文档，比如文档1，文档2，当我们索引一篇文档时，可以通过这样的一个顺序找到它：索引-》类型-》文档id，通过这个组合我们就能索引到某个具体的文档。注意：ID不必是整数，实际上它是一个字符串。
文档
就是我们的一条条的记录
之前说elasticsearch是面向文档的,那么就意味着索引和搜索数据的最小单位是文档, elasticsearch中,文档有几个重要属性:
尽管我们可以随意的新增或者忽略某个字段,但是,每个字段的类型非常重要,比如一个年龄字段类型,可以是字符串也可以是整形。因为elasticsearch会保存字段和类型之间的映射及其他的设置。这种映射具体到每个映射的每种类型,这也是为什么在elasticsearch中,类型有时候也称为映射类型。
类型
类型是文档的逻辑容器,就像关系型数据库一样,表是行的容器。类型中对于字段的定 义称为映射,比如name映射为字符串类型。我们说文档是无模式的 ,它们不需要拥有映射中所定义的所有字段,比如新增一个字段,那么elasticsearch是怎么做的呢?elasticsearch会自动的将新字段加入映射,但是这个字段的不确定它是什么类型, elasticsearch就开始猜,如果这个值是18 ,那么elasticsearch会认为它是整形。但是elasticsearch也可能猜不对 ，所以最安全的方式就是提前定义好所需要的映射,这点跟关系型数据库殊途同归了,先定义好字段,然后再使用,别整什么幺蛾子。
索引
就是数据库!
索引是映射类型的容器, elasticsearch中的索引是一个非常大的文档集合。索引存储了映射类型的字段和其他设置。然后它们被存储到了各个分片上了。我们来研究下分片是如何工作的。
物理设计:节点和分片如何工作
一个集群至少有一 个节点,而一个节点就是一个elasricsearch进程 ,节点可以有多个索引默认的,如果你创建索引,那么索引将会有个5个分片( primary shard ,又称主分片)构成的,每一个主分片会有一个副本( replica shard ,又称复制分片）
上图是一个有3个节点的集群,可以看到主分片和对应的复制分片都不会在同一个节点内,这样有利于某个节点挂掉了,数据也不至于丢失。实际上, 一个分片是一个Lucene索引, 一个包含倒排索引的文件目录,倒排索引的结构使得elasticsearch在不扫描全部文档的情况下,就能告诉你哪些文档包含特定的关键字。
倒排索引
倒排索引详解：https://www.cnblogs.com/zlslch/p/6440114.html
elasticsearch使用的是一种称为倒排索引的结构,采用Lucene倒排索作为底层。这种结构适用于快速的全文搜索，一个索引由文档中所有不重复的列表构成,对于每一个词,都有一个包含它的文档列表。 例如,现在有两个文档，每个文档包含如下内容:
Study every day， good good up to forever # 文档1包含的内容
To forever, study every day，good good up # 文档2包含的内容
为为创建倒排索引,我们首先要将每个文档拆分成独立的词(或称为词条或者tokens) ,然后创建一一个包含所有不重复的词条的排序列表,然后列出每个词条出现在哪个文档:
| term | doc_1 | doc_2 |
|---|---|---|
| Study | √ | x |
| To | x | x |
| every | √ | √ |
| forever | √ | √ |
| day | √ | √ |
| study | x | √ |
| good | √ | √ |
| every | √ | √ |
| to | √ | x |
| up | √ | √ |
现在，我们试图搜索 to forever，只需要查看包含每个词条的文档
| term | doc_1 | doc_2 |
|---|---|---|
| to | √ | x |
| forever | √ | √ |
| total | 2 | 1 |
两个文档都匹配,但是第一个文档比第二个匹配程度更高。如果没有别的条件,现在,这两个包含关键字的文档都将返回。
再来看一个示例,比如我们通过博客标签来搜索博客文章。那么倒排索引列表就是这样的一个结构:
| 博客文章(原始数据) | 博客文章(原始数据) | 索引列表(倒排索引) | 索引列表(倒排索引) |
|---|---|---|---|
| 博客文章ID | 标签 | 标签 | 博客文章ID |
| 1 | python | python | 1，2，3 |
| 2 | python | linux | 3，4 |
| 3 | linux，python | ||
| 4 | linux |
如果要搜索含有python标签的文章,那相对于查找所有原始数据而言，查找倒排索引后的数据将会快的多。只需要查看标签这一栏,然后获取相关的文章ID即可。完全过滤掉无关的所有数据,提高效率!
elasticsearch的索引和Lucene的索引对比
在elasticsearch中，索引(库)这个词被频繁使用,这就是术语的使用。在elasticsearch中 ,索引被分为多个分片,每份分片是一个Lucene的索引。因为一个elasticsearch索引是由多个Lucene索引组成的。别问为什么,谁让elasticsearch使用Lucene作为底层呢!如无特指，说起索引都是指elasticsearch的索引。
接下来的一切操作都在kibana中Dev Tools下的Console里完成。基础操作!
什么是IK分词器 ?
分词:即把一段中文或者别的划分成一个个的关键字,我们在搜索时候会把自己的信息进行分词,会把数据库中或者索引库中的数据进行分词,然后进行一个匹配操作,默认的中文分词是将每个字看成一个词,比如“我爱狂神”会被分为"我",“爱”,“狂”,“神” ,这显然是不符合要求的,所以我们需要安装中文分词器ik来解决这个问题。
如果要使用中文,建议使用ik分词器!
IK提供了两个分词算法: ik_ smart和ik_ max_ word,其中ik_ smart为最少切分, ik_ max_ _word为最细粒度划分!
什么是IK分词器：
ik分词器下载：https://github.com/medcl/elasticsearch-analysis-ik/releases/tag/v7.12.1
下载完，在elasticsearch 的plugins目录下建一个ik文件夹，将压缩包的内容解压到ik文件夹中，重启ES，可以看到ik分词器被加载了！
kibana 中测试：
ik_smart（最少切分）
//_analyze：分词器
GET _analyze
{
"analyzer": "ik_smart",
"text": "我是社会主义接班人"
}
//结果
{
"tokens" : [
{
"token" : "我",
"start_offset" : 0,
"end_offset" : 1,
"type" : "CN_CHAR",
"position" : 0
},
{
"token" : "是",
"start_offset" : 1,
"end_offset" : 2,
"type" : "CN_CHAR",
"position" : 1
},
{
"token" : "社会主义",
"start_offset" : 2,
"end_offset" : 6,
"type" : "CN_WORD",
"position" : 2
},
{
"token" : "接班人",
"start_offset" : 6,
"end_offset" : 9,
"type" : "CN_WORD",
"position" : 3
}
]
}
ik_max_word（最细粒度划分）
GET _analyze
{
"analyzer": "ik_max_word",
"text": "我是社会主义接班人"
}
//结果
{
"tokens" : [
{
"token" : "我",
"start_offset" : 0,
"end_offset" : 1,
"type" : "CN_CHAR",
"position" : 0
},
{
"token" : "是",
"start_offset" : 1,
"end_offset" : 2,
"type" : "CN_CHAR",
"position" : 1
},
{
"token" : "社会主义",
"start_offset" : 2,
"end_offset" : 6,
"type" : "CN_WORD",
"position" : 2
},
{
"token" : "社会",
"start_offset" : 2,
"end_offset" : 4,
"type" : "CN_WORD",
"position" : 3
},
{
"token" : "主义",
"start_offset" : 4,
"end_offset" : 6,
"type" : "CN_WORD",
"position" : 4
},
{
"token" : "接班人",
"start_offset" : 6,
"end_offset" : 9,
"type" : "CN_WORD",
"position" : 5
},
{
"token" : "接班",
"start_offset" : 6,
"end_offset" : 8,
"type" : "CN_WORD",
"position" : 6
},
{
"token" : "人",
"start_offset" : 8,
"end_offset" : 9,
"type" : "CN_CHAR",
"position" : 7
}
]
}
ik分词器增加自定义配置
在elasticsearch-7.12.1\plugins\ik\config目录下增加自定义的dic文件，然后配置文件中加载自定义dic文件，重启即可！
加自定义词典前
GET _analyze
{
"analyzer": "ik_smart",
"text": "喜欢狂神说Java"
}
{
"tokens" : [
{
"token" : "喜欢",
"start_offset" : 0,
"end_offset" : 2,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "狂",
"start_offset" : 2,
"end_offset" : 3,
"type" : "CN_CHAR",
"position" : 1
},
{
"token" : "神",
"start_offset" : 3,
"end_offset" : 4,
"type" : "CN_CHAR",
"position" : 2
},
{
"token" : "说",
"start_offset" : 4,
"end_offset" : 5,
"type" : "CN_CHAR",
"position" : 3
},
{
"token" : "java",
"start_offset" : 5,
"end_offset" : 9,
"type" : "ENGLISH",
"position" : 4
}
]
}
加自定义词典后
GET _analyze
{
"analyzer": "ik_smart",
"text": "喜欢狂神说Java"
}
{
"tokens" : [
{
"token" : "喜欢",
"start_offset" : 0,
"end_offset" : 2,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "狂神说",
"start_offset" : 2,
"end_offset" : 5,
"type" : "CN_WORD",
"position" : 1
},
{
"token" : "java",
"start_offset" : 5,
"end_offset" : 9,
"type" : "ENGLISH",
"position" : 2
}
]
}
可以发现狂神说变成一个词了！！！
| method | url地址 | 描述 |
|---|---|---|
| PUT | localhost:9200/索引名称/类型名称/文档id | 创建文档(指定文档id) |
| POST | localhost:9200/索引名称/类型名称 | 创建文档（随机文档id） |
| POST | localhost:9200/索引名称/类型名称/文档id/_update | 修改文档 |
| DELETE | localhost:9200/索引名称/类型名称/文档id | 删除文档 |
| GET | localhost:9200/索引名称/类型名称/文档id | 通过文档id查询文档 |
| POST | localhost:9200/索引名称/类型名称/_search | 查询所有的数据 |
PUT /索引名/类型名(高版本都不写了，都是_doc)/文档id
ES的类型：
GET /索引名
PUT /索引名/_doc/文档名
ES会猜是什么类型的，有可能猜错
GET _cat/health 获取健康信息
GET _cat/indices?v 获取所有信息
PUT /test1/type1/1 未设置的属性，会被覆盖为空
POST /test3/_doc/1 未设置的属性，会被覆盖为空
POST /test3/_doc/1/_update
常用 POST /test3/_doc/1/_update，这种不会被覆盖：
DELETE 索引名
GET /kuangshen/_doc/_search?q=name:狂神
GET /kuangshen/_doc/_search
两种简单查询，结果一样！name是text类型，进行了分词，所以查狂神，法外狂徒张三也能被查出来
复杂查询
也可以写成这种形式
GET /kuangshen/_doc/_search
{
"query":{
"match":{
"name":"狂神"
}
},
"_source":{
"includes":["name","age"]
}
}
source中不包含哪种属性
must:必须
相当于and
should：应该
相当于or
es的查询都会进行分词，如果查name：“狂神”，会把所有的都查出来
must_not：不必须
相当于 不等于not
term查询是直接通过倒排索引指定的词条进程精确查找的
搜索前，term不会对搜索词进行分词拆解，term的搜索词必须在文档集合中，否则查不到！！
而match会先对搜索词进行分词拆分，分词只要在文档集合中有就查出来，匹配程度越大，sorce越大
详细使用参考：https://www.cnblogs.com/chong-zuo3322/p/14031602.html
"pre_tags":"<p style='color:red'>" #前缀
"post_tags":"</p>" #后缀
标准的会被分词
keyword不会被分词
创建springboot项目，导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
查看maven的es版本是不是你下载的版本
<properties>
<java.version>1.8</java.version>
<elasticsearch.version>7.12.1</elasticsearch.version>
</properties>
新建一个es配置类，注入RestHighLevelClient 客户端
@Configuration
public class ElasticSearchClientConfig {
@Bean
public RestHighLevelClient restHighLevelClient(){
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost("127.0.0.1",9200,"http"))
);
return client;
}
}
和索引请求相关的API有5种，常用的有3种：添加，删除，判断是否存在
@SpringBootTest
class SpringbootEsApplicationTests {
@Autowired
@Qualifier("restHighLevelClient")
private RestHighLevelClient client;
@Test
void testCreateIndex() throws IOException {
//创建索引请求
CreateIndexRequest request = new CreateIndexRequest("kuang_index");
//获取索引客户端对象
IndicesClient indices = client.indices();
//索引客户端执行创建索引请求
CreateIndexResponse createIndexResponse = indices.create(request, RequestOptions.DEFAULT);
System.out.println(createIndexResponse);
}
@Test
void testExistIndex() throws IOException {
//创建获取索引请求
GetIndexRequest request = new GetIndexRequest("kuang_index");
//客户端执行请求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
System.out.println("索引是否存在："+exists);
}
@Test
void testDeleteIndex() throws IOException {
//创建删除索引请求
DeleteIndexRequest request = new DeleteIndexRequest("kuang_index");
AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
System.out.println("是否删除成功："+response.isAcknowledged());
}
}
文档的增删改查！
//测试添加文档
@Test
void testAddDocument() throws IOException {
User user = new User("张三", 18);
//创建一个请求
IndexRequest request = new IndexRequest("kuang_index");
//设置id，也可不设置，系统随机设置
request.id("1");
//设置超时时间
request.timeout("1s");
//将数据用json字符串形式放入请求中
request.source(JSON.toJSONString(user), XContentType.JSON);
//执行请求
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
System.out.println("添加文档："+response.toString());
System.out.println("添加文档："+response.status());
//结果
//添加文档：IndexResponse[index=kuang_index,type=_doc,id=1,version=1,result=created,seqNo=0,primaryTerm=1,shards={"total":2,"successful":1,"failed":0}]
//添加文档：CREATED
}
//测试删除文档
@Test
void testDeleteDocument() throws IOException {
DeleteRequest request = new DeleteRequest("kuang_index", "1");
request.timeout("1s");
DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
System.out.println(response.status());
}
//测试修改文档
@Test
void testUpdateDocument() throws IOException {
UpdateRequest request = new UpdateRequest("kuang_index", "1");
request.timeout("1s");
//只修改name，age被置0
//只修改age，name正常
//request.doc(JSON.toJSONString(new User("王五")),XContentType.JSON);
request.doc(JSON.toJSONString(new User(10)),XContentType.JSON);
UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
System.out.println(response.status());
}
//测试获取文档
@Test
void testEGETDocument() throws IOException {
GetRequest request = new GetRequest("kuang_index","1");
boolean exists = client.exists(request, RequestOptions.DEFAULT);
System.out.println("文档是否存在："+exists);
GetResponse response = client.get(request, RequestOptions.DEFAULT);
System.out.println(response); //一个hits
System.out.println(response.getSourceAsString());//hits中的数据
//{"_index":"kuang_index","_type":"_doc","_id":"1","_version":1,"_seq_no":0,"_primary_term":1,"found":true,"_source":{"age":18,"name":"张三"}}
//{"age":18,"name":"张三"}
}
批量插入
//测试批量插入
@Test
void testBulkAddDocument() throws IOException {
List list = new ArrayList();
list.add(new User("狂神1",7));
list.add(new User("狂神2",8));
list.add(new User("狂神3",9));
list.add(new User("狂神4",10));
list.add(new User("狂神5",11));
//创建批处理请求
BulkRequest request = new BulkRequest();
request.timeout("1s");
for (int i = 0; i < list.size(); i++) {
//向批处理请求中添加创建文档请求
request.add(new IndexRequest("kuang_index")
.id(""+(i+1))
.source(JSON.toJSONString(list.get(i)),XContentType.JSON)
);
}
//执行批处理请求
BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
System.out.println("是否失败："+response.hasFailures());
}
条件查询
//测试条件查询
@Test
void testSearchDocument() throws IOException {
//创建查询请求
SearchRequest request = new SearchRequest("kuang_index");
//构建搜索条件
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//高亮
sourceBuilder.highlighter();
//排序
sourceBuilder.sort("age", SortOrder.DESC);
//分页
sourceBuilder.from(1);
sourceBuilder.size(3);
//精确查询
//TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "狂神2");
//普通查询，会分词
MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("name", "狂神");
sourceBuilder.query(matchQueryBuilder);
//设置超时时间
sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
//搜索条件放入请求中
request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
System.out.println("测试条件查询："+JSON.toJSONString(response));
for (SearchHit documentFields:response.getHits().getHits()) {
System.out.println(documentFields.getSourceAsString());
}
}
创建springboot项目，导入依赖，修改elasticsearch版本
<properties>
<java.version>1.8</java.version>
<elasticsearch.version>7.12.1</elasticsearch.version>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.jsoup/jsoup -->
<!--jsoup解析网页 tika解析电影-->
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.10.2</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.62</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
导入静态资源
链接：https://pan.baidu.com/s/1M5uWdYsCZyzIAOcgcRkA_A
提取码：qk8p
测试
@Controller
public class IndexController {
@RequestMapping({"/","/index"})
public String index() {
return "index";
}
}
启动项目，访问测试：http://localhost:9090/
爬取数据：获取请求返回的页面信息，筛选出我们想要的数据，jsoup 包可以实现
jsoup可以解析网页，不可以解析媒体
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.10.2</version>
</dependency>
创建实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Content {
private String name;
private String price;
private String img;
//扩展属性
}
写一个工具类，解析网页，将需要的数据封装成list集合
public class HTMLParseUtil {
public static void main(String[] args) throws Exception {
HTMLParseUtil.parse("java").forEach(System.out::println);
}
/**
* 爬取数据存入list中
* @param keyword 关键字
* @return
* @throws Exception
*/
public static List<Content> parse(String keyword) throws Exception {
// 请求url
String url="https://search.jd.com/search?keyword="+keyword;
// 1.解析网页(jsoup 解析返回的对象是浏览器Document对象)
Document document = Jsoup.parse(new URL(url), 50000);
// 使用document可以使用在js对document的所有操作
// 2.获取元素（通过id）,id自己查网页
Element element = document.getElementById("J_goodsList");
// 3.获取J_goodsList ul 每一个
Elements elements = element.getElementsByTag("li");
// 4.获取li下的 img、price、name
// list存储所有li下的内容
List<Content> list=new ArrayList<>();
for (Element li:elements) {
String img = li.getElementsByTag("img").eq(0).attr("data-lazy-img");
String price = li.getElementsByClass("p-price").eq(0).text();
String name = li.getElementsByClass("p-name").eq(0).text();
Content content = new Content();
content.setName(name);
content.setPrice(price);
content.setImg(img);
list.add(content);
}
return list;
}
}
开发者模式下看
抓取的数据交给 elasticsearch 即可用于 es 实现搜索
添加 elasticsearch 配置类
@Configuration
public class ElasticSearchClientConfig {
@Bean
public RestHighLevelClient restHighLevelClient(){
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost("127.0.0.1",9200,"http"))
);
return client;
}
}
在 elasticsearch 后台管理页面创建一个空索引 jd_goods
创建业务service
@Service
public class ContentService {
@Autowired
private RestHighLevelClient restHighLevelClient;
/**
* 将解析的数据批量插入es数据库中
* @param keyword 关键字
* @return
* @throws Exception
*/
public Boolean parseContent(String keyword) throws Exception {
List<Content> contents = HTMLParseUtil.parse(keyword);
//批量插入请求
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.timeout("2m");
for (int i = 0; i < contents.size(); i++) {
bulkRequest.add(new IndexRequest("jd_goods")
.source(JSON.toJSONString(contents.get(i)),XContentType.JSON));
}
BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
//返回是否成功
return !bulk.hasFailures();
}
/**
* 从es数据库中搜索
* @param keyword 关键字
* @param pageNo 第几页
* @param pageSize 几个
* @return
* @throws IOException
*/
public List<Map<String,Object>> searchPage(String keyword, int pageNo, int pageSize) throws IOException {
if (pageNo<=1){
pageNo=1;
}
//创建查询请求
SearchRequest searchRequest = new SearchRequest("jd_goods");
//构建搜索条件
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//分页
sourceBuilder.from(pageNo);
sourceBuilder.size(pageSize);
//构建精确查询
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", keyword);
sourceBuilder.query(termQueryBuilder );
sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
// 执行搜索
searchRequest.source(sourceBuilder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
// 解析结果
List<Map<String,Object>> list = new ArrayList<>();
for (SearchHit documentFields:searchResponse.getHits().getHits()) {
list.add(documentFields.getSourceAsMap());
}
return list;
}
}
@RestController
public class ContentController {
@Autowired
private ContentService contentService;
// 先从京东抓取数据并存入es中
@GetMapping("/parse/{keyword}")
public Boolean parse(@PathVariable("keyword") String keywords) throws Exception {
return contentService.parseContent(keywords);
}
// 在es中搜索数据返回结果
@GetMapping("/search/{keyword}/{pageNo}/{pageSize}")
public List<Map<String, Object>> search(@PathVariable("keyword") String keyword,
@PathVariable("pageNo") int pageNo,
@PathVariable("pageSize") int pageSize) throws IOException {
return contentService.searchPage(keyword, pageNo, pageSize);
}
}
测试成功后，现拿到了数据，还差前端页面展示，使用 Vue
导入vue和axios的js
修改index.html
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="utf-8"/>
<title>狂神说Java-ES仿京东实战</title>
<link rel="stylesheet" th:href="@{/css/style.css}"/>
<script th:src="@{/js/jquery.min.js}"></script>
</head>
<body class="pg">
<div class="page" id="app">
<div id="mallPage" class=" mallist tmall- page-not-market ">
<!-- 头部搜索 -->
<div id="header" class=" header-list-app">
<div class="headerLayout">
<div class="headerCon ">
<!-- Logo-->
<h1 id="mallLogo">
<img th:src="@{/images/jdlogo.png}" alt="">
</h1>
<div class="header-extra">
<!--搜索-->
<div id="mallSearch" class="mall-search">
<form name="searchTop" class="mallSearch-form clearfix">
<fieldset>
<legend>天猫搜索</legend>
<div class="mallSearch-input clearfix">
<div class="s-combobox" id="s-combobox-685">
<div class="s-combobox-input-wrap">
<input v-model="keyword" type="text" autocomplete="off" value="dd" id="mq"
class="s-combobox-input" aria-haspopup="true">
</div>
</div>
<button @click.prevent="searchKey" type="submit" id="searchbtn">搜索</button>
</div>
</fieldset>
</form>
<ul class="relKeyTop">
<li><a>狂神说Java</a></li>
<li><a>狂神说前端</a></li>
<li><a>狂神说Linux</a></li>
<li><a>狂神说大数据</a></li>
<li><a>狂神聊理财</a></li>
</ul>
</div>
</div>
</div>
</div>
</div>
<!-- 商品详情页面 -->
<div id="content">
<div class="main">
<!-- 品牌分类 -->
<form class="navAttrsForm">
<div class="attrs j_NavAttrs" style="display:block">
<div class="brandAttr j_nav_brand">
<div class="j_Brand attr">
<div class="attrKey">
品牌
</div>
<div class="attrValues">
<ul class="av-collapse row-2">
<li><a href="#"> 狂神说 </a></li>
<li><a href="#"> Java </a></li>
</ul>
</div>
</div>
</div>
</div>
</form>
<!-- 排序规则 -->
<div class="filter clearfix">
<a class="fSort fSort-cur">综合<i class="f-ico-arrow-d"></i></a>
<a class="fSort">人气<i class="f-ico-arrow-d"></i></a>
<a class="fSort">新品<i class="f-ico-arrow-d"></i></a>
<a class="fSort">销量<i class="f-ico-arrow-d"></i></a>
<a class="fSort">价格<i class="f-ico-triangle-mt"></i><i class="f-ico-triangle-mb"></i></a>
</div>
<!-- 商品详情 -->
<div class="view grid-nosku">
<div class="product" v-for="result in results">
<div class="product-iWrap">
<!--商品封面-->
<div class="productImg-wrap">
<a class="productImg">
<img :src="result.img">
</a>
</div>
<!--价格-->
<p class="productPrice">
<em>{{result.price}}</em>
</p>
<!--标题-->
<p class="productTitle">
<a v-html="result.name"> </a>
</p>
<!-- 店铺名 -->
<div class="productShop">
<span>店铺： 狂神说Java </span>
</div>
<!-- 成交信息 -->
<p class="productStatus">
<span>月成交<em>999笔</em></span>
<span>评价 <a>3</a></span>
</p>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
<script th:src="@{/js/vue.min.js}"></script>
<script th:src="@{/js/axios.min.js}"></script>
<script>
new Vue({
el: "#app",
data: {
keyword: '',
results: []
},
methods: {
searchKey(){
let keyword=this.keyword;
axios.get("search/"+keyword+"/1/10").then(response=>{
this.results=response.data;
})
}
}
});
</script>
</body>
</html>
修改 service业务层方法
/**
* 高亮查询
* @param keyword
* @param pageNo
* @param pageSize
* @return
* @throws IOException
*/
public List<Map<String,Object>> highlightSearch(String keyword, int pageNo, int pageSize) throws IOException {
if (pageNo<=1){
pageNo=1;
}
SearchRequest searchRequest = new SearchRequest("jd_goods");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//分页
sourceBuilder.from(pageNo);
sourceBuilder.size(pageSize);
//===========================================================================
//高亮
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.field("name");
highlightBuilder.preTags("<span style='color:red;'>");
highlightBuilder.postTags("</span>");
//highlightBuilder.requireFieldMatch(false);
sourceBuilder.highlighter(highlightBuilder);
//===========================================================================
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", keyword);
sourceBuilder.query(termQueryBuilder);
sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
searchRequest.source(sourceBuilder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
//解析结果
List<Map<String,Object>> list = new ArrayList<>();
for (SearchHit documentFields:searchResponse.getHits().getHits()) {
System.out.println("===============================");
//没有高亮的结果
Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();
System.out.println(sourceAsMap.get("name"));
//高亮字段
Map<String, HighlightField> highlightFields = documentFields.getHighlightFields();
HighlightField name = highlightFields.get("name");
//替换旧的结果
if (name!=null){
Text[] fragments = name.fragments();
StringBuilder new_name = new StringBuilder();
for (Text t:fragments) {
new_name.append(t);
}
sourceAsMap.put("name",new_name.toString());
System.out.println(sourceAsMap.get("name"));
}
list.add(sourceAsMap);
}
return list;
}
controller 将接受方法修改为高亮业务
// 在es中搜索数据返回结果
@GetMapping("/search/{keyword}/{pageNo}/{pageSize}")
public List<Map<String, Object>> search(@PathVariable("keyword") String keyword,
@PathVariable("pageNo") int pageNo,
@PathVariable("pageSize") int pageSize) throws IOException {
return contentService.highlightSearch(keyword, pageNo, pageSize);
}
修改 index.html 页面，使其可以解析高亮标签
<!--标题-->
<p class="productTitle">
<a v-html="result.title"></a>
</p>
