java开发中elasticsearch 的简单使用

elasticsearch 是什么？

如果你还不知道elasticsearch 。可以看看其他的文章分享。

或者直达官网：

elasticsearch 官网

名词术语

要想使用elasticsearch 先要搞清楚elasticsearch 中的各个名词

本文主要介绍使用想了解请

elasticsearch 介绍

创建索引

官方给定的是这样的

PUT /my_index
{
    "settings": { ... any settings ... },
    "mappings": {
        "type_one": { ... any mappings ... },
        "type_two": { ... any mappings ... },
        ...
    }
}

如果是linux可以使用curl 来进行创建

我使用的是windows 的postman

发送put请求给 localhost:9200/索引名

附带json

{
  "mappings": {
      "properties": {
            "books":{
        "properties": {
            "title":{"type":"keyword"},
            "name":{"type":"keyword"}
        }
        
    }
      }
    }
}

这样就好了

发送get请求到 localhost:9200/索引名就能看到你刚刚创建索引的详细情况

删除一个索引

用以下的请求来删除索引:

DELETE /my_index

你也可以这样删除多个索引：

DELETE /index_one,index_two
DELETE /index_*

你甚至可以这样删除

全部

索引：

DELETE /_all
DELETE /*

多索引删除

1.在单个索引删除的基础上行使用逗号分隔多个需要删除的索引即可

DELETE product,springboot,customer

2.返回示例

{
	"acknowledged": true
}

查看索引

get 索引名

索引不存在就会返回404

查看所有索引

可以通过内置_cat命令查看所有索引信息

GET _cat/indices

添加文章

有了索引就可以添加文章了

添加文章是发送post请求到 localhost:9200/索引名/_doc/添加的id

如果不带添加id 系统会随机生成一个id

根据自己索引的映射附带对应的参数

{
   "title":"test",
   "name":"zzp3"
}

添加完成之后会返回一个添加id

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-69f1Wnxy-

然后可以发送get请求到 localhost:9200/索引名/_doc/JH7R63oBB1aDXzS50FRN [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NcIPHzE6-1627525218450)

批量查询

发送get请求 localhost:9200/索引名/_mget

带上请求体

{
   "ids":["1","RuWrl3UByGJWB5WucKtP"]
}

查询所有

get    localhost:9200/索引名/_search

文档更新

普通更新

注意，文档更新一次，version 就会自增 1。

可以直接更新整个文档：

PUT 索引名/_doc/RuWrl3UByGJWB5WucKtP
{
  "title":"666"
}

这种方式，更新的文档会覆盖掉原文档。

大多数时候，我们只是想更新文档字段，这个可以通过脚本来实现。

POST 索引名/_update/1
{
  "script": {
    "lang": "painless",
    "source":"ctx._source.title=params.title",
    "params": {
      "title":"666666"
    }
  }
}

更新的请求格式：POST {index}/_update/{id}

在脚本中，lang 表示脚本语言，painless 是 es 内置的一种脚本语言。source 表示具体执行的脚本，ctx 是一个上下文对象，通过 ctx 可以访问到
_source
、
_title
等。

也可以向文档中添加字段：

POST blog/_update/1
{
  "script": {
    "lang": "painless",
    "source":"ctx._source.tags=[\"java\",\"php\"]"
  }
}

删除单个文档

DELETE 索引名/_doc/1

按条件删除

POST 索引名/_delete_by_query
{
	"query": {
		"match": {
			"price": 3999
		}
	}
}

映射

有了索引库，等于有了数据库中的database
接下来就需要建索引库(index)中的映射，类似于数据库(database)中的表结构(table)
创建数据库表需要设置字段名称，类型，长度，约束等；索引库也一样，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做映射(mapping)
如果不指定映射将会默认按照给定的类型自动添加对应映射

创建时映射

可以在创建索引时指定映射
- 其中mappings.properties为固定结构，指定创建映射属性

PUT index
{
  "mappings" : {
      "properties" : {
        "id" : {
          "type" : "long"
        },
        "title" : {
          "type" : "text"
        }
      }
  }
}

映射修改

可以对已经存在的索引添加映射
需要使用 PUT /_mapping
修改时只需要指定properties即可，不需要指定mappings

PUT index/_mapping
{
  "properties" : {
    "id" : {
      "type" : "long"
    },
    "title" : {
      "type" : "text"
    }
  }
}
复制代码

查看映射

1.查看索引完全信息，内容包含映射信息

GET index

2.指定查询索引信息

GET index/_mapping

通过上面的学习和使用已经大概了解和使用了elasticsearch了

那么通过java来使用下吧

JavaApi集成查询

1、新建maven项目

添加相关依赖

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
  </dependency>
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.74</version>
  </dependency>
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.18</version>
  </dependency>

  <!-- es服务依赖 -->
  <dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>7.8.0</version>
  </dependency>
  <!-- es客户端依赖 -->
  <dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.8.0</version>
  </dependency>
</dependencies>

2、新建索引操作类

/**
 * @author zzp
 * @create 2021-07-28-15:14
 */
public class ElasticsearchIndexTest {

    /**
     * 连接客户端
     */
    private RestHighLevelClient client;

    /**
     * 初始化客户端
     * before 是指定在test方法运行前运行
     */
    @Before
    public void init(){
        HttpHost serverHost = new HttpHost("localhost",9200);
        client = new RestHighLevelClient(RestClient.builder(serverHost));
    }

    /**
     * 销毁客户端
     * 在test方法执行后执行
     */
    @After
    public void destroy(){
        if (Objects.isNull(client)){
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 创建索引：有则报错，无则新建
     */
    @Test
    public void testCreate() throws IOException {
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("javatest");
        CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse.toString());
    }
    /**
     * 查询索引信息
     */
    @Test
    public void testQuery() throws IOException {
        GetIndexRequest request = new GetIndexRequest("javatest");
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        // 获取别名
        System.out.println(response.getAliases().toString());
        // 获取默认设置
        System.out.println(response.getDefaultSettings().toString());
        // 获取索引信息
        System.out.println(response.getIndices().toString());
        // 获取映射信息
        System.out.println(response.getMappings().toString());
    }


    /**
     * 删除索引
     */
    @Test
    public void testDelete() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("javatest");
        AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }
    
}

文档操作

/**
 * @author zzp
 * @create 2021-07-28-15:38
 * 文档操作
 */
public class ElasticsearchDocTest {
    /**
     * 连接客户端
     */
    private RestHighLevelClient client;

    /**
     * 初始化客户端
     */
    @Before
    public void init(){
        HttpHost serverHost = new HttpHost("localhost",9200);
        client = new RestHighLevelClient(RestClient.builder(serverHost));
    }

    /**
     * 销毁客户端
     */
    @After
    public void destroy(){
        if (Objects.isNull(client)){
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 创建文档
     */
    @Test
    public void testCreate() throws IOException {
        IndexRequest request = new IndexRequest();
        // 指定索引
        request.index("java");
        // 指定id
        request.id("1001");
        // 存储数据
        //这里是自定义的一个类 具体看自己mapping中的映射来
        EsUser user = new EsUser("zhangsan", 30, "男");
        // 指定source内容
        request.source(user.toJsonString(), XContentType.JSON);
        // 请求
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        PrintUtil.buttyPrint(response);
    }

    /**
     * 修改文档
     */
    @Test
    public void testUpdate() throws IOException {
        UpdateRequest request = new UpdateRequest();
        // 指定索引
        request.index("java");
        // 指定id
        request.id("1001");

        // 更新内容
        EsUser user = new EsUser("ES", 18, "女");
        request.doc(user.toJsonString(), XContentType.JSON);

        // ES请求
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        PrintUtil.buttyPrint(response);
    }

    /**
     * 文档查询
     */
    @Test
    public void testQuery() throws IOException {
        GetRequest request = new GetRequest().index("java").id("1001");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        PrintUtil.buttyPrint(response.getSource());
    }

    /**
     * 删除文档
     */
    @Test
    public void testDelete() throws IOException {
        DeleteRequest request = new DeleteRequest().index("java").id("1001");
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        PrintUtil.buttyPrint(response);
    }

    /**
     * 批量操作，针对于增删改
     */
    @Test
    public void testBatch() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        // 先删除
        bulkRequest.add(new DeleteRequest().index("java").id("1001"));
        // 再添加
        EsUser user = new EsUser("EsJava", 18, "男");
        bulkRequest.add(new IndexRequest().index("java").id("1002").source(user.toJsonString(), XContentType.JSON));

        BulkResponse responses = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(responses);
    }

    /**
     * match查询
     */
    @Test
    public void testAdvanceMatchQuery() throws IOException {
        SearchRequest request = new SearchRequest("java");

        // 查询条件构造
        SearchSourceBuilder builder = new SearchSourceBuilder();

        // 匹配查询
        /// QueryBuilders提供命令中的查询匹配关系
        /// 查询所有
        /// QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        /// 单个查询
        /// QueryBuilder queryBuilder = QueryBuilders.matchQuery("age", 18);
        /// 短语匹配查询
        QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery("name", "EsJava");
        builder.query(queryBuilder);

        request.source(builder);
        SearchResponse responses = client.search(request, RequestOptions.DEFAULT);
        System.out.println(responses.getHits());
    }

    /**
     * bool查询
     */
    @Test
    public void testAdvanceBoolQuery() throws IOException {
        SearchRequest request = new SearchRequest("java");

        // 查询条件构造
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        // must
        queryBuilder.must(QueryBuilders.matchQuery("age", 18));
        // mustNot
        queryBuilder.mustNot(QueryBuilders.matchQuery("sex", "女"));
        // should
        queryBuilder.should(QueryBuilders.matchQuery("name", "zhangsan"));

        builder.query(queryBuilder);
        request.source(builder);
        SearchResponse responses = client.search(request, RequestOptions.DEFAULT);
        System.out.println(responses.getHits());
    }

    /**
     * 分页查询
     */
    @Test
    public void testAdvancePageQuery() throws IOException {
        SearchRequest request = new SearchRequest("java");

        // 查询条件构
        SearchSourceBuilder builder = new SearchSourceBuilder();
        MatchAllQueryBuilder queryBuilder = QueryBuilders.matchAllQuery();

        // query <==> select
        builder.query(queryBuilder);

        // 分页查询
        builder.from(0);
        builder.size(2);

        // 指定排序
        builder.sort("age", SortOrder.ASC);

        request.source(builder);
        SearchResponse responses = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit searchHit : responses.getHits()) {
            System.out.println(searchHit.getSourceAsString());
        }
    }

    /**
     * 高亮查询
     */
    @Test
    public void testAdvanceHighLightQuery() throws IOException {
        SearchRequest request = new SearchRequest("java");

        // 查询条件构
        SearchSourceBuilder builder = new SearchSourceBuilder();
        // 注意高亮全部查询时无意义
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("name", "java");
        builder.query(queryBuilder);

        // 高亮搜搜，和查询同级
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.preTags("<font color='red'>");
        highlightBuilder.postTags("</font>");
        highlightBuilder.field("name");

        builder.highlighter(highlightBuilder);
        request.source(builder);
        SearchResponse responses = client.search(request, RequestOptions.DEFAULT);
        for (SearchHit searchHit : responses.getHits()) {
            System.out.println(searchHit.getHighlightFields());
        }
    }


}

原文链接：https://blog.csdn.net/qq_26387051/article/details/119205179