🍻 正在加载今日诗词....
字数统计: 2.1k字   |   阅读时长≈ 9分

ElasticSearch7.x学习笔记

一、简介和下载

1、windows es下载安装

**Elasticsearch(ES)**是一个基于Lucene库的搜索引擎。它提供了一个分布式、支持多租户的全文搜索引擎，具有HTTP Web接口和无模式JSON文档。Elasticsearch是用Java开发的，并在Apache许可证下作为开源软件发布。Elasticsearch可以用于搜索各种文档。它提供可扩展的搜索，具有接近实时的搜索，并支持多租户。

Elasticsearch下载地址

这里我选择了7.10.2，并使用迅雷下载，速度还可以

解压后目录结构

1
2
3
4
5
6
7
8
9
bin #启动文件
config:
	log4j2 #日志配置文件
	jvm.options #java虚拟机相关配置
	elasticsearch.yml #elasticsearch的配置文件 默认9200端口
lib #相关jar包
logs #日志
modules #功能模块
plugins #插件

进入bin目录双击elasticsearch.bat，然后访问http://127.0.0.1:9200/,成功出现以下json信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
  "name": "SHAWN",
  "cluster_name": "elasticsearch",
  "cluster_uuid": "jsUcSDzlQ_W7ikv3MOWrBw",
  "version": {
    "number": "7.10.2",
    "build_flavor": "default",
    "build_type": "zip",
    "build_hash": "747e1cc71def077253878a59143c1f785afa92b9",
    "build_date": "2021-01-13T00:42:12.435326Z",
    "build_snapshot": false,
    "lucene_version": "8.7.0",
    "minimum_wire_compatibility_version": "6.8.0",
    "minimum_index_compatibility_version": "6.0.0-beta1"
  },
  "tagline": "You Know, for Search"
}

2、可视化插件

  1. github地址：https://github.com/mobz/elasticsearch-head，按操作运行项目；若出现跨域问题进行配置
1
2
http.cors.enabled: true
http.cors.allow-origin: "*"
  1. google商店搜索ElasticSearch Head，安装插件

3、Kibana 下载与安装

ELK是三个开源软件的缩写，分别表示：Elasticsearch , Logstash, Kibana , 它们都是开源软件。新增了一个FileBeat，它是一个轻量级的日志收集处理工具(Agent)，Filebeat占用资源少，适合于在各个服务器上搜集日志后传输给Logstash，官方也推荐此工具。
Elasticsearch是个开源分布式搜索引擎，提供搜集、分析、存储数据三大功能。它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。
Logstash 主要是用来日志的搜集、分析、过滤日志的工具，支持大量的数据获取方式。一般工作方式为c/s架构，client端安装在需要收集日志的主机上，server端负责将收到的各节点日志进行过滤、修改等操作在一并发往elasticsearch上去。
Kibana 也是一个开源和免费的工具，Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好Web 界面，可以帮助汇总、分析和搜索重要数据日志。

Kibana 下载地址

注意要和ES版本一致

解压打开bin/kibana.bat浏览器http://localhost:5601/

汉化，在config/kibana.yml下

1
i18n.locale: "zh-CN"

二、核心概念

  1. 索引
  2. 字段类型(mapping)
  3. 文档(documents)（倒排索引）

三、IK分词器

分词：即把一段中文或者别的划分成一个个的关键字，我们在搜索时候会把自己的信息进行分词，会把数据库中或者索引库中的数据进行分词，然后进行一个匹配操作，默认的中文分词是将每个字看成一个词，比
如果要使用中文，建议使用ik分词器！

下载安装地址

下载完成后放入es plugins中（注意版本匹配），之后重启es

ik_smart最少切分，ik_max_word最细粒度划分，穷尽词库可能

1
2
3
4
5
6
7
8
9
10
11
12
// 在Kibana 控制台进行访问
GET _analyze
{
  "analyzer": "ik_smart",
  "text": "中国共产党"
}

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "中国共产党"
}

ik分词器增加自己目录

在插件目录下config/IKAnalyzer.cfg.xml进行配置

四、ES基础测试

1.创建一个索引

1
2
3
4
5
6
# put /索引名/~类型名~/文档id
PUT /test1/type1/1
{
  "name": "shawn",
  "age": "18"
}
  • 字符串类型
    text、keyword
  • 数值类型
    long，integer，short，byte，double，float，half float，scaled float
  • 日期类型
    date
  • te布尔值类型
    boolean
  • 二进制类型
    binary

2.映射，默认是_doc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
PUT /test2
{
  "mappings": {
    "properties":{
      "name":{
        "type":"text"
      },
      "address":{
        "type":"text"
      },
      "age":{
        "type":"integer"
      }
    }
  }
}

3.更新(有值就更新)

1
2
3
4
5
POST /test1/type1/1/_update
{
  "name": "shawn",
  "age": "20"
}

4、简单查询

1
GET /test1/_search?q=name:shawn

5、复杂操作搜索

select（排序，分页，高亮，模糊查询，精准查询！）,里面可以有很多查询操作，和mysql类似

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
GET test1/_search
{
  "query": {
    "bool":{
      "must": [
        {
          "match": {
            "name": "shawn"
          }
        },
        {
          "match": {
            "age": "18"
          }
        }
        
      ]
    }
  },
  "_source": ["name","age"],
  "from": 0,
  "size": 1,
  "highlight": {
    "pre_tags":"<p class='key' style='color:red'>",
	"post_tags":"</p>",
    "fields": {
      "name": {}
    }
  }
}

text类型可以被分词 keyword不能被分词

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

五、springboot整合es

1、引入maven依赖

我的springboot版本是2.4.2，es版本是7.10.2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.10.2</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>7.10.2</version>
</dependency>


<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.70</version>
</dependency>

2、创建配置文件

创建config/ElasticSearchConfig.java配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Configuration
public class ElasticSearchConfig {

    public  static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
        COMMON_OPTIONS = builder.build();
    }

    @Bean
    public RestHighLevelClient client() {
        return new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200)));
    }
}

3、创建实体类

创建pojo/User.java类

1
2
3
4
5
6
7
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private Integer age;
}

4、测试文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
@SpringBootTest
class DemoApplicationTests {
    
    @Autowired
    private RestHighLevelClient client;

    // 测试索引的创建
    @Test
    void testCreateIndex() throws IOException {
        // 创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("shawn_index");
        // 客户端执行请求
        CreateIndexResponse createIndexResponse =
                client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }

    // 获取索引
    @Test
    void testExistIndex() throws IOException {
        GetIndexRequest getIndexRequest = new GetIndexRequest("shawn_index");
        boolean exists = client.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    // 删除索引
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("shawn_index");
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());
    }

    // 添加文档
    @Test
    void testAddDocument() throws IOException {
        // 创建对象
        User user = new User("shawn",18);
        // 创建请求
        IndexRequest request = new IndexRequest("shawn_index");
        // 规则
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");
        // 将微码数据放入请求 json
        request.source(JSON.toJSONString(user), XContentType.JSON);
        // 客户端发送请求
        IndexResponse index = client.index(request, RequestOptions.DEFAULT);
        System.out.println(index.toString());
    }

    // 获取文档
    @Test
    void testIsExists() throws IOException {
        GetRequest getRequest = new GetRequest("shawn_index");
        // 不获取返回的source上下文
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    // 获取文档信息
    @Test
    void testGetDocument() throws IOException {
        GetRequest getRequest = new GetRequest("shawn_index","1");
        GetResponse documentFields = client.get(getRequest, RequestOptions.DEFAULT);
        // 打印文档
        System.out.println(documentFields.getSourceAsString());
    }

    // 更新文档信息
    @Test
    void testUpdateDocument() throws IOException {
        UpdateRequest request = new UpdateRequest("shawn_index", "1");
        request.timeout("1s");
        User user = new User("shawn22",22);
        request.doc(JSON.toJSONString(user),XContentType.JSON);
        UpdateResponse update = client.update(request, RequestOptions.DEFAULT);
        // 打印文档
        System.out.println(update.status());
    }

    // 删除文档信息
    @Test
    void testDeleteDocument() throws IOException {
        DeleteRequest request = new DeleteRequest("shawn_index","1");
        DeleteResponse delete = client.delete(request, RequestOptions.DEFAULT);
        // 打印文档
        System.out.println(delete.status());
    }

    //特殊的，真的项目一般都会批量插入数据！
    @Test
    void testBulkRequest() throws IOException{
        BulkRequest bulkRequest=new BulkRequest();
        bulkRequest.timeout("10s");
        ArrayList<User> userlist=new ArrayList<>();
        userlist.add(new User("shawn1",3));
        //批处理请求
        for(int i=0;i< userlist.size();i++){
            bulkRequest.add(
                new IndexRequest("shawn_index")
                        .id(""+(i+1))
                        .source(JSON.toJSONString(userlist.get(i)),XContentType.JSON));
        }
        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk.hasFailures());
    }

    // 查询
    @Test
    void testSearch() throws IOException {
        // 构建搜索条件
        SearchRequest searchRequest = new SearchRequest("shawn_index");
        // 查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 匹配所有
        // QueryBuilders.matchAllQuery();

        // termquery精确匹配
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "shawn1");
        searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        // 分页
        searchSourceBuilder.from(1);
        searchSourceBuilder.size(4);

        // // 高亮
        // HighlightBuilder highlightBuilder = new HighlightBuilder();
        // highlightBuilder.field("name");
        // // 关闭多个高亮匹配
        // highlightBuilder.requireFieldMatch(false);
        // highlightBuilder.preTags("<span style='color:red'>");
        // highlightBuilder.postTags("</span>");
        // searchSourceBuilder.highlighter(highlightBuilder);

        // 执行搜索
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        // 解析结果
        System.out.println(JSON.toJSONString(searchResponse.getHits()));
        System.out.println("=========================");
        for (SearchHit hit : searchResponse.getHits()) {
            System.out.println(hit.getSourceAsMap());
        }

        // // 如果高亮了需要解析高亮字段
        // ArrayList<Map<String, Object>> list = new ArrayList<>();
        // for (SearchHit hit : searchResponse.getHits()) {
        //     // 解析高亮
        //     Map<String, HighlightField> highlightFieldMap = hit.getHighlightFields();
        //     HighlightField highlightField = highlightFieldMap.get("name");
        //     Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        //     // 替换原来的
        //     if(highlightField!=null){
        //         Text[] fragments = highlightField.fragments();
        //         String n_highlightField = "";
        //         for (Text text : fragments) {
        //             n_highlightField += text;
        //         }
        //         sourceAsMap.put("name",n_highlightField);
        //     }
        //     list.add(sourceAsMap);
        // }
}
赏

谢谢你请我吃糖果

支付宝
-------------本文结束^-^感谢您的阅读-------------
本文作者： Shawn
发布时间： 2021-03-15
最后更新： 2021-11-18
本文标题： ElasticSearch7.x学习笔记
本文链接： https://blog.shawncoding.top/posts/803c8798.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！
知识共享许可协议

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<br/><br/><br/>心怀天下<br/>只认真生活<br/>自信微笑面对未来