ElasticSearch 实用学习笔记（从入门到精通）(1)，高级java工程师面试攻略-CSDN博客

本文链接：https://blog.csdn.net/2401_84435578/article/details/137898338

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

“_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)

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

大厂面试真题：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
rt 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)

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

[外链图片转存中…(img-IV5cxOSG-1713384027234)]

大厂面试真题：

[外链图片转存中…(img-8DYQGuHv-1713384027234)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-WyNWr5EG-1713384027235)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ElasticSearch 实用学习笔记 （从入门到精通）(1)，高级java工程师面试攻略

正文

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 实用学习笔记（从入门到精通）(1)，高级java工程师面试攻略

7.1 基本操作（复习巩固）