ElasticSearch 实用学习笔记（从入门到精通）

最新推荐文章于 2024-04-28 15:25:11 发布

2401_84413531

最新推荐文章于 2024-04-28 15:25:11 发布

阅读量901

点赞数 12

分类专栏：程序员文章标签： elasticsearch 学习笔记

本文链接：https://blog.csdn.net/2401_84413531/article/details/137881279

版权

程序员专栏收录该内容

306 篇文章 0 订阅

订阅专栏

“_id” : “1”,

“_version” : 2,

“result” : “updated”,

“_shards” : {

“total” : 2,

“successful” : 1,

“failed” : 0

“_seq_no” : 1,

“_primary_term” : 1

}

新的方法 POST 命令更新

POST /test/_doc/1/_update

{

“doc”: {

“name”:“张三”

}

// 结果

{

“_index” : “test”,

“_type” : “_doc”,

“_id” : “1”,

“_version” : 3,

“_seq_no” : 2,

“_primary_term” : 1,

“found” : true,

“_source” : {

“name” : “张三”,

“age” : 18,

“gender” : “male”

}

6.4 删除索引

删除索引！！！

DELETE test

通过 delete 命令实现删除，根据你的请求来判断删除的是索引还是文档

七、关于文档的操作

========================================================================

7.1 基本操作（复习巩固）

添加数据（添加多条记录）

PUT /gorit/user/1

{

“name”: “CodingGorit”,

“age”: 23,

“desc”: “一个独立的个人开发者”,

“tags”: [“Python”,“Java”,“JavaScript”]

}

PUT /gorit/user/2

{

“name”: “龙”,

“age”: 20,

“desc”: “全栈工程师”,

“tags”: [“Python”,“JavaScript”]

}

结果：

#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).

{

“_index” : “gorit”,

“_type” : “user”,

“_id” : “1”,

“_version” : 1,

“result” : “created”,

“_shards” : {

“total” : 2,

“successful” : 1,

“failed” : 0

“_seq_no” : 0,

“_primary_term” : 1

}

获取数据

GET /gorit/user/_search # 查询所有数据

GET /gorit/user/1 # 查询单个数据

更新数据 PUT

PUT /gorit/user/3

{

“name”: “李四222”,

“age”: 20,

“desc”: “Java开发工程师”,

“tags”: [“Python”,“Java”]

}

PUT 更新字段不完整，数据会被滞空

post _update ，推荐使用这种方式！

修改方式和 PUT 一样会使数据滞空

POST /gorit/user/1

{

“doc”: {

“name”: “coco”

}

修改数据不会滞空, 效率更加高效

POST /gorit/user/1/_update

{

“doc”: {

“name”: “coco”

}

简单的搜索！

查询一条记录

GET /gorit/user/1

查询所有

GET /gorit/user/_search

条件查询 [精确匹配] ，如果我们没有个这个属性设置字段，它会背默认设置为 keyword，这个 keyword 字段就是使用全匹配来匹配的，如果是 text 类型，模糊查询就会起效果

GET /gorit/user/_search?q=name:coco

7.2 复杂的查询搜索：select（排序、分页、高亮、模糊查询、精确查询）！

过滤加指定字段查询

GET /gorit/user/_search

{

“query”: {

“match”: {

“name”: “李四”

}

“_source”: [“name”,“desc”]

}

7.3 排序

GET /gorit/user/_search

{

“query”: {

“match”: {

“name”: “gorit”

}

“sort”: [

{

“age”: {

“order”: “desc”

}

]

}

7.4 分页查询

使用字段 from 和 size 进行分页查询，方式和 limit pageSize 是一模一样的

from 从第几页开始
返回多少条数据

GET /gorit/user/_search

{

“query”: {

“match”: {

“name”: “李四”

}

“sort”: [

{

“age”: {

“order”: “desc”

}

“from”: 0,

“size”: 1

}

7.5 filiter 区间查询

根据年龄的范围大小查询

GET /gorit/user/_search

{

“query”: {

“bool”: {

“must”: [

{

“match”: {

“name”: “gorit”

}

“filter”: [

{

“range”: {

“age”: {

“gte”: 1,

“lte”: 25

}

]

}

gt 大于
gte 大于等于
lt 小于
lte 小于等于

7.6 布尔值查询

must (and), 所有的条件都要符合 where id=1 and name = xxx

布尔查询

GET /gorit/user/_search

{

“query”: {

“bool”: {

“must”: [

{

“match”: {

“name”: “gorit”

}

},{

“match”: {

“age”: “16”

}

]

}

7.7 匹配多个条件

同时匹配即可

多个条件用空格隔开，只要满足一个即可被查出，这个时候可以根据分值判断

GET /gorit/user/_search

{

“query”: {

“match”: {

“tags”: “Java Python”

}

7.7 精确查询

term 查询是直接通过倒排索引指定的词条进程精确的查找的！

关于分词

term，直接精确查询
match：会使用分词器解析！！（先分析文档，然后通过分析的文档进行查询！！！）

两个类型 text keyword

结论：

text 可分
keyword 不可再分

7.8 高亮查询

高亮查询, 搜索的结果，可以高亮显示, 也能添加自定义高亮条件

GET /gorit/user/_search

{

“query”: {

“match”: {

“name”: “Gorit”

}

“highlight”: {

“pre_tags”: “

”,

“post_tags”: “”,

“fields”: {

“name”: {}

}

响应结果

#! Deprecation: [types removal] Specifying types in search requests is deprecated.

{

“took” : 2,

“timed_out” : false,

“_shards” : {

“total” : 1,

“successful” : 1,

“skipped” : 0,

“failed” : 0

“hits” : {

“total” : {

“value” : 1,

“relation” : “eq”

“max_score” : 1.6375021,

“hits” : [

{

“_index” : “gorit”,

“_type” : “user”,

“_id” : “6”,

“_score” : 1.6375021,

“_source” : {

“name” : “Gorit”,

“age” : 16,

“desc” : “运维工程师”,

“tags” : [

“Linux”,

“c++”,

“python”

]

“highlight” : {

“name” : [

“

Gorit

”

]

}

]

}

这些 MySQL 也可以做，只是 MySQL 效率更低

匹配
按照条件匹配
精确匹配
区间范围匹配
匹配字段过滤
多条件查询
高亮查询
倒排索引

八、集成 SpringBoot

==============================================================================

找官方文档

具体测试

创建索引
判断索引是否存在
删除索引
创建文档
操作文档

// 坐标依赖

org.springframework.boot

spring-boot-starter-data-elasticsearch

// 核心代码

package cn.gorit;

import cn.gorit.pojo.User;

import com.alibaba.fastjson.JSON;

import javafx.scene.control.IndexRange;

import org.apache.lucene.util.QueryBuilder;

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;

import org.elasticsearch.action.bulk.BulkRequest;

import org.elasticsearch.action.bulk.BulkResponse;

import org.elasticsearch.action.delete.DeleteRequest;

import org.elasticsearch.action.delete.DeleteResponse;

import org.elasticsearch.action.get.GetRequest;

import org.elasticsearch.action.get.GetResponse;

import org.elasticsearch.action.index.IndexRequest;

import org.elasticsearch.action.index.IndexResponse;

import org.elasticsearch.action.search.SearchRequest;

import org.elasticsearch.action.search.SearchResponse;

import org.elasticsearch.action.support.master.AcknowledgedRequest;

import org.elasticsearch.action.support.master.AcknowledgedResponse;

import org.elasticsearch.action.update.UpdateRequest;

import org.elasticsearch.action.update.UpdateResponse;

import org.elasticsearch.client.RequestOptions;

import org.elasticsearch.client.RestHighLevelClient;

import org.elasticsearch.client.indices.CreateIndexRequest;

import org.elasticsearch.client.indices.CreateIndexResponse;

import org.elasticsearch.client.indices.GetIndexRequest;

import org.elasticsearch.common.unit.TimeValue;

import org.elasticsearch.common.xcontent.XContent;

import org.elasticsearch.common.xcontent.XContentType;

import org.elasticsearch.index.query.MatchAllQueryBuilder;

import org.elasticsearch.index.query.QueryBuilders;

import org.elasticsearch.index.query.TermQueryBuilder;

import org.elasticsearch.search.SearchHit;

import org.elasticsearch.search.builder.SearchSourceBuilder;

import org.elasticsearch.search.fetch.subphase.FetchSourceContext;

import org.json.JSONObject;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.http.codec.cbor.Jackson2CborDecoder;

import java.io.IOException;

import java.util.ArrayList;

import java.util.concurrent.TimeUnit;

/**

es 7.6.2 API 测试

@SpringBootTest

class DemoApplicationTests {

// 名称匹配

@Autowired

@Qualifier(“restHighLevelClient”)

private RestHighLevelClient client;

@Test

void contextLoads() {

}

// 索引的创建

@Test

void testCreateIndex() throws IOException {

// 1. 创建索引请求等价于 PUT /gorit_index

CreateIndexRequest request = new CreateIndexRequest(“gorit_index”);

// 2. 执行创建请求 IndicesClient, 请求后获得响应

CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);

System.out.println(response);

}

// 测试获取索引，判断其是否存在

@Test

void testGetIndexExist() throws IOException {

GetIndexRequest request = new GetIndexRequest(“gorit_index”);

boolean exist = client.indices().exists(request,RequestOptions.DEFAULT);

System.out.println(exist);

}

// 删除索引

@Test

void testDeleteIndex() throws IOException {

DeleteIndexRequest request = new DeleteIndexRequest(“gorit_index”);

// 删除

AcknowledgedResponse delete = client.indices().delete(request,RequestOptions.DEFAULT);

System.out.println(delete.isAcknowledged());

}

// 添加文档

@Test

void testAddDocument() throws IOException {

// 创建对象

User u = new User(“Gorit”,3);

// 创建请求

IndexRequest request = new IndexRequest(“gorit_index”);

// 规则 PUT /gorit_index/_doc/1

request.id(“1”);

request.timeout(TimeValue.timeValueSeconds(3));

request.timeout(“1s”);

// 将数据放入请求 json

IndexRequest source = request.source(JSON.toJSONString(u), XContentType.JSON);

// 客户端发送请求

IndexResponse response = client.index(request, RequestOptions.DEFAULT);

System.out.println(response.toString());

System.out.println(response.status());// 返回对应的状态 CREATED

}

// 获取文档，判断存在 get /index/_doc/1

@Test

void testIsExists() throws IOException {

GetRequest getRequest = new GetRequest(“gorit_index”, “1”);

// 不获取返回的 _source 的上下文了

getRequest.fetchSourceContext(new FetchSourceContext(false));

getRequest.storedFields(“none”);

boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);

System.out.println(exists);

}

// 获取文档信息

@Test

void testGetDocument() throws IOException {

GetRequest getRequest = new GetRequest(“gorit_index”, “1”);

GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);

// 打印文档的内容

System.out.println(getResponse.getSourceAsString());

System.out.println(getResponse); // 返回全部的内容和命令是一样的

}

// 更新文档信息

@Test

void testUpdateDocument() throws IOException {

UpdateRequest updateRequest = new UpdateRequest(“gorit_index”, “1”);

updateRequest.timeout(“1s”);

User user = new User(“CodingGoirt”, 18);

updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);

UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);

// 打印文档的内容

System.out.println(updateResponse.status());

System.out.println(updateResponse); // 返回全部的内容和命令是一样的

}

// 删除文档记录

@Test

void testDeleteDocument() throws IOException {

DeleteRequest deleteRequest = new DeleteRequest(“gorit_index”, “1”);

deleteRequest.timeout(“1s”);

DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);

// 打印文档的内容

System.out.println(deleteResponse.status());

System.out.println(deleteResponse); // 返回全部的内容和命令是一样的

}

// 特殊的，真的项目。批量插入数据

@Test

void testBulkRequest() throws IOException {

BulkRequest bulkRequest = new BulkRequest();

bulkRequest.timeout(“10s”);

ArrayList userList = new ArrayList<>();

userList.add(new User(“张三1”,1));

userList.add(new User(“张三2”,2));

userList.add(new User(“张三3”,3));

userList.add(new User(“张三4”,4));

userList.add(new User(“张三5”,5));

userList.add(new User(“张三6”,6));

userList.add(new User(“张三7”,7));

// 批处理请求

for (int i=0;i<userList.size();i++) {

// 批量更新，批量删除，就在这里修改为对应的请求即可

bulkRequest.add(new IndexRequest(“gorit_index”)

.id(“”+(i+1))

.source(JSON.toJSONString(userList.get(i)),XContentType.JSON));

}

BulkResponse bulkItemResponses = client.bulk(bulkRequest, RequestOptions.DEFAULT);

System.out.println(bulkItemResponses.hasFailures()); // 是否失败

System.out.println(bulkItemResponses.status());

}

// 查询

// SearchRequest 搜索请求

// SearchSourceBuilder条件构造

// HighlightBuilder 构建高亮

// TermQueryBuilder 精确查询

// MatchAllQueryBuilder

// xxx QueryBuilder

@Test

void testSearch() throws IOException {

SearchRequest searchRequest = new SearchRequest(“gorit_index”);

// 构建搜索的条件

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

/**

查询条件使用 QueryBuilders 工具类来实现
QueryBuilders.termQuery 精确
QueryBuilders.matchAllQueryBuilder() 匹配所有

TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“name”, “gorit1”);//精确查询

// MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();

sourceBuilder.query(termQueryBuilder);

// 分页

sourceBuilder.from();

sourceBuilder.size();

sourceBuilder.highlighter(); // 设置高亮

sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

// 构建搜索

searchRequest.source(sourceBuilder);

SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

System.out.println(JSON.toJSONString(searchResponse.getHits()));

System.out.println(“==========================================”);

for (SearchHit documentFields: searchResponse.getHits().getHits()) {

System.out.println(documentFields.getSourceAsMap());

}

九、实战

===================================================================

项目依赖

org.jsoup

jsoup

1.10.2

com.alibaba

fastjson

1.2.68

org.springframework.boot

spring-boot-starter-data-elasticsearch

org.springframework.boot

spring-boot-starter-thymeleaf

org.springframework.boot

spring-boot-starter-web

org.springframework.boot

spring-boot-devtools

runtime

true

org.springframework.boot

spring-boot-configuration-processor

true

org.projectlombok

lombok

true

org.springframework.boot

spring-boot-starter-test

test

org.junit.vintage

junit-vintage-engine

爬虫

配置文件

package cn.gorit.config;

import org.apache.http.HttpHost;

import org.elasticsearch.client.RestClient;

import org.elasticsearch.client.RestHighLevelClient;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/**

Spring 步骤
1. 找对象
1. 放到 spring 中使用
1. 分析源码
@Classname ElasticSearchConfig
@Description TODO
@Date 2020/10/21 17:20
@Created by CodingGorit
@Version 1.0

@Configuration // xml -bean

public class ElasticSearchConfig {

@Bean

public RestHighLevelClient restHighLevelClient() {

RestHighLevelClient client = new RestHighLevelClient(

RestClient.builder(

new HttpHost(“localhost”, 9200, “http”)

)

);

return client;

}

爬取京东搜索的内容

config 配置类

package cn.gorit.util;

import cn.gorit.pojo.Content;

import org.jsoup.Jsoup;

import org.jsoup.nodes.Document;

import org.jsoup.nodes.Element;

import org.jsoup.select.Elements;

import org.springframework.stereotype.Component;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

/**

@Classname HtmlParseUtil
@Description TODO
@Date 2020/10/21 23:17
@Created by CodingGorit
@Version 1.0

@Component

public class HtmlParseUtil {

// public static void main(String[] args) throws Exception {

// new HtmlParseUtil().parseJD(“英语”).forEach(System.out::println);

// }

public List parseJD(String keyword) throws Exception {

// 请求 url

// 联网，不能获取 ajax 数据

String url = “https://search.jd.com/Search?keyword=wd&enc=utf-8”;

// 解析网页 (返回的 Document 对象）

Document document = Jsoup.parse(new URL(url.replace(“wd”,keyword)),30000);

// 获取所有节点标签

Element element = document.getElementById(“J_goodsList”);

// 获取所有的 li 元素

Elements elements = element.getElementsByTag(“li”);

// 获取元素中的内容

List goodsList = new ArrayList<>();

for (Element e: elements) {

String img = e.getElementsByTag(“img”).eq(0).attr(“data-lazy-img”);

String price = e.getElementsByClass(“p-price”).eq(0).text();

String title = e.getElementsByClass(“p-name”).eq(0).text();

goodsList.add(new Content(title,img,price));

// System.out.println(img);

// System.out.println(price);

// System.out.println(title);

}

return goodsList;

}

Service 方法

package cn.gorit.service;

import cn.gorit.pojo.Content;

import cn.gorit.util.HtmlParseUtil;

import com.alibaba.fastjson.JSON;

import org.elasticsearch.action.bulk.BulkRequest;

import org.elasticsearch.action.bulk.BulkResponse;

import org.elasticsearch.action.index.IndexRequest;

import org.elasticsearch.action.search.SearchRequest;

import org.elasticsearch.action.search.SearchResponse;

import org.elasticsearch.client.RequestOptions;

import org.elasticsearch.client.RestHighLevelClient;

import org.elasticsearch.common.text.Text;

import org.elasticsearch.common.unit.TimeValue;

import org.elasticsearch.common.xcontent.XContentType;

import org.elasticsearch.index.query.QueryBuilders;

import org.elasticsearch.index.query.TermQueryBuilder;

import org.elasticsearch.search.SearchHit;

import org.elasticsearch.search.builder.SearchSourceBuilder;

import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;

import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.concurrent.TimeUnit;

/**

@Classname ContentService
@Description TODO
@Date 2020/10/22 18:44
@Created by CodingGorit
@Version 1.0

@Service

public class ContentService {

@Autowired

private RestHighLevelClient restHighLevelClient;

// 不能直接使用，只要 Spring 容器

public static void main(String[] args) throws Exception {

new ContentService().parseContent(“java”);

}

// 1. 解析数据放入 es 索引中

public Boolean parseContent (String keywords) throws Exception {

// 获取查询到的列表的信息

List contents = new HtmlParseUtil().parseJD(keywords);

// 把查询到的数据放入 es 中

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 bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

return !bulkResponse.hasFailures();

}

// 2. 获取这些数据，实现基本的搜索功能

public List<Map<String,Object>> searchPagehighLight (String keyword, int pageNo,int pageSize) throws IOException {

if (pageNo <= 1)

pageNo = 1;

// 条件清晰

SearchRequest searchRequest = new SearchRequest(“jd_goods”);

SearchSourceBuilder builder = new SearchSourceBuilder();

builder.from(pageNo);

builder.size(pageSize);

// 精准匹配

TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“title”,keyword);

builder.query(termQueryBuilder);

builder.timeout(new TimeValue(60, TimeUnit.SECONDS));

// 高亮

HighlightBuilder highlightBuilder = new HighlightBuilder();

highlightBuilder.field(“title”);

highlightBuilder.requireFieldMatch(false);

highlightBuilder.preTags(“”);

highlightBuilder.postTags(“”);

builder.highlighter(highlightBuilder);

// 执行搜索

searchRequest.source(builder);

SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

// 解析结果

ArrayList<Map<String,Object>> list= new ArrayList<>();

for (SearchHit hit: searchResponse.getHits().getHits()) {

// 解析高亮的字段

Map<String, HighlightField> highlightFields = hit.getHighlightFields();

HighlightField title = highlightFields.get(“title”);

Map<String,Object> sourceAsMap = hit.getSourceAsMap();// 原来的结果

// 解析高亮字段，将原来的字段换成我们高亮的字段即可

if (title != null) {

Text[] fragments = title.fragments();

StringBuilder nTitle = new StringBuilder();

for (Text text:fragments) {

nTitle.append(text);

}

sourceAsMap.put(“title”,nTitle);

}

list.add(hit.getSourceAsMap()); // 高亮的字段替换为原来的内容即可

}

return list;

}

// 2. 获取这些数据，实现基本的搜索功能

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 builder = new SearchSourceBuilder();

builder.from(pageNo);

builder.size(pageSize);

// 精准匹配

TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“title”,keyword);

builder.query(termQueryBuilder);

builder.timeout(new TimeValue(60, TimeUnit.SECONDS));

// 执行搜索

searchRequest.source(builder);

SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

// 解析结果

ArrayList<Map<String,Object>> list= new ArrayList<>();

for (SearchHit hit: searchResponse.getHits().getHits()) {

list.add(hit.getSourceAsMap()); // 高亮的字段替换为原来的内容即可

}

return list;

}

Controller

package cn.gorit.controller;

import cn.gorit.pojo.Content;

import cn.gorit.service.ContentService;
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

俗话说，好学者临池学书，不过网络时代，对于大多数的我们来说，我倒是觉得学习意识的觉醒很重要，这是开始学习的转折点，比如看到对自己方向发展有用的信息，先收藏一波是一波，比如如果你觉得我这篇文章ok，先点赞收藏一波。这样，等真的沉下心来学习，不至于被找资料分散了心神。慢慢来，先从点赞收藏做起，加油吧！

另外，给大家安排了一波学习面试资料：

以上就是本文的全部内容，希望对大家的面试有所帮助，祝大家早日升职加薪迎娶白富美走上人生巅峰！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
st = new SearchRequest(“jd_goods”);

SearchSourceBuilder builder = new SearchSourceBuilder();

builder.from(pageNo);

builder.size(pageSize);

// 精准匹配

TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“title”,keyword);

builder.query(termQueryBuilder);

builder.timeout(new TimeValue(60, TimeUnit.SECONDS));

// 执行搜索

searchRequest.source(builder);

SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

// 解析结果

ArrayList<Map<String,Object>> list= new ArrayList<>();

for (SearchHit hit: searchResponse.getHits().getHits()) {

list.add(hit.getSourceAsMap()); // 高亮的字段替换为原来的内容即可

}

return list;

}

Controller

package cn.gorit.controller;

import cn.gorit.pojo.Content;

import cn.gorit.service.ContentService;
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-idyc4HkS-1713345806444)]

[外链图片转存中…(img-LzhkHibI-1713345806444)]

[外链图片转存中…(img-2cmqvdaq-1713345806444)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

另外，给大家安排了一波学习面试资料：

[外链图片转存中…(img-1ynuHUXF-1713345806445)]

[外链图片转存中…(img-IekH6ran-1713345806445)]

以上就是本文的全部内容，希望对大家的面试有所帮助，祝大家早日升职加薪迎娶白富美走上人生巅峰！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

2401_84413531

关注

12
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

ElasticSearch 实用学习笔记 （从入门到精通）

6.4 删除索引

7.1 基本操作 （复习巩固）

PUT 更新字段不完整，数据会被滞空

修改方式和 PUT 一样会使数据滞空

修改数据不会滞空, 效率更加高效

查询一条记录

查询所有

条件查询 [精确匹配] ，如果我们没有个这个属性设置字段，它会背默认设置为 keyword，这个 keyword 字段就是使用全匹配来匹配的，如果是 text 类型，模糊查询就会起效果

7.2 复杂的查询搜索：select（排序、分页、高亮、模糊查询、精确查询）！

7.3 排序

7.4 分页查询

7.5 filiter 区间查询

根据年龄的范围大小查询

7.6 布尔值查询

布尔查询

7.7 匹配多个条件

多个条件用空格隔开，只要满足一个即可被查出，这个时候可以根据分值判断

7.7 精确查询

7.8 高亮查询

高亮查询, 搜索的结果，可以高亮显示, 也能添加自定义高亮条件

”,

响应结果

Gorit

爬虫

最后

最后

ElasticSearch 实用学习笔记（从入门到精通）

7.1 基本操作（复习巩固）