springboot集成elasticsearch7.17.3

已于 2022-12-25 20:26:36 修改
阅读量3.4k 收藏 14
点赞数 2
文章标签： spring boot elasticsearch java
于 2022-12-24 00:02:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrzhuangr/article/details/128425473
版权

文章目录

环境：
jdk1.8
springboot: 2.7.0

spring elastisearch官方文档

一、依赖配置

1、引入es依赖

        <!-- spring data es -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
                <!-- https://mvnrepository.com/artifact/jakarta.json/jakarta.json-api -->
        <dependency>
            <groupId>jakarta.json</groupId>
            <artifactId>jakarta.json-api</artifactId>
            <version>2.0.1</version>
        </dependency>

2、配置文件application.yaml

spring:
  elasticsearch:
    uris: http://1.13.152.218:9200
    username:
    password:
    connection-timeout: 10s
  jackson:
    date-format: "yyyy-MM-dd HH:mm:ss"

二、使用Repository对es增删改查

1、定义实体类 Book

package com.zhuang.es.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.DateFormat;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

import java.util.Date;
import java.util.List;
import java.util.Map;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Document(indexName="books")
public class Book {
    @Id
    private Long id;

    @Field(type = FieldType.Text)
    private String name;

    @Field(type = FieldType.Text)
    private String summary;

    @Field(type = FieldType.Double)
    private Double price;

    @Field(type = FieldType.Text)
    private String parent;

    private List<Long> list;

    private Map<Long, String> map;

    @Field(type = FieldType.Date, format = DateFormat.custom, pattern = "yyyy-MM-dd HH:mm:ss")
    private Date create;
}

2、注解：

@Document

作用：标识要持久化到Elasticsearch的域对象， 如定义索引名
@Document(indexName="books")

@Id

作用：定义标识符 -> 文档id
@Id private Long id;

@Field

作用：对持久化到Elasticsearch域的属性设置， 比如设置对应es中字段的属性类型

type属性类型:

1、如果没有定义属性的type或者type = FieldType.Auto ，会动态映射 type，会在第一次插入数据时动态设置属性类型。如 private String name; 或 如 @Field(type = FieldType.Auto) private String name;

2、如果显示定义了type的类型，那么在项目启动的时候，就会在es中创建定义的类型
如 @Field(type = FieldType.Text) private String name; 那么name属性在es中的属性类型为text

format日期格式：

1.使用自带的日期格式：format
如 @Field(type = FieldType.Date, format = DateFormat.date_hour_minute_second) private Date create DateFormat是枚举类型;
2.自定义时间类型：pattern
设置format = DateFormat.custom或 format = DateFormat.none,
如： @Field(type = FieldType.Date, format = DateFormat.custom, pattern = "yyyy-MM-dd HH:mm:ss") private Date create;

3、创建接口 BookRepository

继承 ElasticsearchRepository<T, ID>， T为映射的实体类， ID为标记的id类型

package com.zhuang.es.service;

import com.zhuang.es.entity.Book;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

public interface BookRepository extends ElasticsearchRepository<Book, Long> {
}

4、创建 BookController

注入BookRepository bean，调用封装好的增删改查接口

package com.zhuang.es.controller;

import com.zhuang.es.entity.Book;
import com.zhuang.es.service.BookRepository;
import com.zhuang.es.vo.BookVo;
import com.zhuang.es.vo.ResponseVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;
import java.util.Optional;

/**
 * @program: mybatis-plus
 * @description:
 * @author: mrzhuang
 * @create: 2022-12-23 21:14
 **/

@RestController
@RequestMapping("/book")
public class BookController {

    @Resource
    BookRepository bookRepository;

    /**
     * 查询全部
     *
     * @return /
     */
    @GetMapping("/findAll")
    public ResponseVo<Iterable<Book>> findAll() {
        Iterable<Book> books = bookRepository.findAll();
        return new ResponseVo<>(books);
    }

    /**
     * 向es中增加book
     *
     * @param book /
     * @return /
     */
    @PostMapping("/add")
    public ResponseVo<Book> addBook(@RequestBody Book book) {
        Book save = bookRepository.save(book);
        return new ResponseVo<>(save);
    }

    /**
     * 根据id查询
     *
     * @param id /
     * @return /
     */
    @GetMapping("/findById")
    public ResponseVo<Optional<Book>> findById(@RequestParam("id") Long id) {
        Optional<Book> bookOptional = bookRepository.findById(id);
        return new ResponseVo<>(bookOptional);

    }

    /**
     * 通过传入实体删除
     *
     * @param book /
     * @return /
     */
    @PostMapping("/delete")
    public ResponseVo<Boolean> delete(@RequestBody Book book) {
        bookRepository.delete(book);
        return new ResponseVo<>(true);
    }

    /**
     * 通过id删除
     *
     * @param id /
     * @return /
     */
    @GetMapping("/deleteById")
    public ResponseVo<Boolean> delete(@RequestParam("id") Long id) {
        bookRepository.deleteById(id);
        return new ResponseVo<>(true);
    }

  /**
     * 更新某个属性值(如：name)
     * @param bookVo /
     */
    @PostMapping("/update")
    public ResponseVo<Book> update(@RequestBody BookVo bookVo) {
        //获取需要更新的文档id
        Long id = bookVo.getId();
        Optional<Book> option = bookRepository.findById(id);
        if (option.isPresent()) {
            Book book = option.get();
            if (StringUtils.isNotEmpty(bookVo.getName())) {
                book.setName(bookVo.getName());
            }
            Book save = bookRepository.save(book);
            return new ResponseVo<>(book);
        }
        return new ResponseVo<>(CodeEnum.FAILUIRE.code, "更新失败！");
    }

    /**
     * 统计数量
     *
     * @return /
     */
    @GetMapping("/count")
    public ResponseVo<Long> count() {
        long count = bookRepository.count();
        return new ResponseVo<>(count);
    }

    /**
     * 查看id是否存在
     * @param id /
     * @return /
     */
    @GetMapping("/existsById")
    public ResponseVo<Boolean> update(@RequestParam("id") Long id) {
        boolean exists = bookRepository.existsById(id);
        return new ResponseVo<>(exists);
    }

    /**
     * 根据name和price查询
     * @param name /
     * @param price /
     * @return /
     */
    @GetMapping("/findByNameAndPrice")
    public ResponseVo<List<Book>> findByNameAndPrice(@RequestParam("name") String name, @RequestParam("price") Double price) {
        List<Book> books = bookRepository.findByNameAndPrice(name, price);
        return new ResponseVo<>(books);
    }

    /**
     * 根据summary和parent查询
     * @param summary /
     * @param parent /
     * @return /
     */
    @GetMapping("/findBySummaryAndParent")
    public ResponseVo<List<Book>> findBySummaryAndParent(@RequestParam("summary") String summary, @RequestParam("parent") String parent) {
        List<Book> books = bookRepository.findBySummaryAndParent(summary, parent);
        return new ResponseVo<>(books);
    }
    

}

5、Es创建查询机制

通常，Elasticsearch 的查询创建机制按照查询方法中的描述工作。

以下是 Elasticsearch 查询方法转换成的简短示例：
增加方法： List<Book> findByNameAndPrice(String name, Double price);
上面的方法名会被翻译成下面的 Elasticsearch json 查询：

{
    "query": {
        "bool" : {
            "must" : [
                { "query_string" : { "query" : "?", "fields" : [ "name" ] } },
                { "query_string" : { "query" : "?", "fields" : [ "price" ] } }
            ]
        }
    }
}

package com.zhuang.es.service;

import com.zhuang.es.entity.Book;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

import java.util.List;

public interface BookRepository extends ElasticsearchRepository<Book, Long> {
    List<Book> findByNameAndPrice(String name, Double price);
}

controller层中调用

    @PostMapping("/findByNameAndPrice")
    public ResponseVo<List<Book>> findByNameAndPrice(@RequestParam("name") String name, @RequestParam("price") Double price){
        List<Book> books = bookRepository.findByNameAndPrice(name, price);
        return new ResponseVo<>(books);
    }

6、查询创建机制关键词

And
关键词样本
AndfindByNameAndPrice

Es 查询字符串：

"bool" : {
"must" : [
{ "query_string" : { "query" : "?", "fields" : [ "name" ] } },
{ "query_string" : { "query" : "?", "fields" : [ "price" ] } }
]
}
}}
Or
关键词样本
OrfindByNameOrPrice

Es 查询字符串：

{ "query" : {
"bool" : {
"should" : [
{ "query_string" : { "query" : "?", "fields" : [ "name" ] } },
{ "query_string" : { "query" : "?", "fields" : [ "price" ] } }
]
}
}}
Is
关键词样本
IsfindByName

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "?", "fields" : [ "name" ] } }
]
}
}}
Not
关键词样本
NotfindByNameNot

Es 查询字符串：

{ "query" : {
  "bool" : {
  "must_not" : [
{ "query_string" : { "query" : "?", "fields" : [ "name" ] } }
]
}
}}
Between
关键词样本
BetweenfindByPriceBetween

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : ?, "to" : ?, "include_lower" : true, "include_upper" : true } } }
]
}
}}
LessThan
关键词样本
LessThanfindByPriceLessThan

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : false } } }
]
}
}}
LessThanEqual
关键词样本
LessThanEqualfindByPriceLessThanEqual

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true } } }
]
}
}}
GreaterThan
关键词样本
GreaterThanfindByPriceGreaterThan

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : false, "include_upper" : true } } }
]
}
}}
GreaterThanEqual
关键词样本
GreaterThanEqualfindByPriceGreaterThan

Es查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true } } }
]
}
}}
Before
关键词样本
BeforefindByPriceBefore

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true } } }
]
}
}}
After
关键词样本
AfterfindByPriceAfter

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true } } }
]
}
}}
Like
关键词样本
LikefindByNameLike

Es查询字符串

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "?*", "fields" : [ "name" ] }, "analyze_wildcard": true }
]
}
}}
StartingWith
关键词样本
StartingWithfindByNameStartingWith

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "?*", "fields" : [ "name" ] }, "analyze_wildcard": true }
]
}
}}
EndingWith
关键词样本
EndingWithfindByNameEndingWith

Es查询字符串

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "*?", "fields" : [ "name" ] }, "analyze_wildcard": true }
]
}
}}
Contanins/Containing
关键词样本
Contains/ContainingfindByNameContaining

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "*?*", "fields" : [ "name" ] }, "analyze_wildcard": true }
]
}
}}
In（当注释为 FieldType.Keyword 时)
关键词样本
In（当注释为 FieldType.Keyword 时）findByNameIn(Collectionnames)

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"bool" : {"must" : [
{"terms" : {"name" : ["?","?"]}}
]
}
}
]
}
}}
In
关键词样本
InfindByNameIn(Collectionnames)

Es 查询字符串：

{ "query": {"bool": {"must": [{"query_string":{"query": "\"?\" \"?\"", "fields": ["name"]}}]}}}
Notln（当注释为 FieldType.Keyword 时）
关键词样本
NotIn（当注释为 FieldType.Keyword 时）indByNameNotIn(Collectionnames)

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{"bool" : {"must_not" : [
{"terms" : {"name" : ["?","?"]}}
]
}
}
]
}
}}
Notln
关键词样本
NotInfindByNameNotIn(Collectionnames)

Es 查询字符串：

{"query": {"bool": {"must": [{"query_string": {"query": "NOT(\"?\" \"?\")", "fields": ["name"]}}]}}}
关键词 | 样本
--- | ----
True|findByAvailableTrue

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "true", "fields" : [ "available" ] } }
]
}
}}
False
关键词样本
FalsefindByAvailableFalse

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "false", "fields" : [ "available" ] } }
]
}
}}
OrderBy
关键词样本
OrderByfindByAvailableTrueOrderByNameDesc

Es 查询字符串：

{ "query" : {
"bool" : {
"must" : [
{ "query_string" : { "query" : "true", "fields" : [ "available" ] } }
]
}
}, "sort":[{"name":{"order":"desc"}}]
}
Exists
关键词样本
ExistsfindByNameExists

Es 查询字符串：

{"query":{"bool":{"must":[{"exists":{"field":"name"}}]}}}
IsNull
关键词样本
IsNullfindByNameIsNull

Es 查询字符串：

{"query":{"bool":{"must_not":[{"exists":{"field":"name"}}]}}}
IsNotNull
关键词样本
IsNotNullfindByNameIsNotNull

Es 查询字符串：

{"query":{"bool":{"must":[{"exists":{"field":"name"}}]}}}
IsEmpty
关键词样本
IsEmptyfindByNameIsEmpty

Es 查询字符串：

{"query":{"bool":{"must":[{"bool":{"must":[{"exists":{"field":"name"}}],"must_not":[{"wildcard":{"name":{"wildcard":"*"}}}]}}]}}}
IsNotEmpty
关键词样本
IsNotEmptyfindByNameIsNotEmpty

Es 查询字符串：

{"query":{"bool":{"must":[{"wildcard":{"name":{"wildcard":"*"}}}]}}}

7、高级查询

注入 ElasticsearchOperations bean

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.query_dsl.BoolQuery;
import co.elastic.clients.elasticsearch._types.query_dsl.MatchAllQuery;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.TermQuery;
import co.elastic.clients.json.JsonData;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zhuang.es.EsApplication;
import com.zhuang.es.entity.Book;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.client.elc.NativeQuery;
import org.springframework.data.elasticsearch.client.elc.NativeQueryBuilder;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHits;

import javax.annotation.Resource;

/**
 * @program: mybatis-plus
 * @description:
 * @author: mrzhuang
 * @create: 2022-12-22 21:43
 **/

@Slf4j
@SpringBootTest(classes = EsApplication.class)
public class EsTest {
    @Resource
    ElasticsearchOperations operations;

    @Test
    public void testSearch() {
        //term查询
        TermQuery termQuery = new TermQuery.Builder().field("price").value("10.2").build();
        Query tQuery = new Query.Builder().term(termQuery).build();
        //等同于lambda表达式
        Query price2 = new Query.Builder().term(t -> t.field("price").value("10.2")).build();

        BoolQuery boolQuery = new BoolQuery.Builder()
                //filter
                .filter(q -> q.range(r -> r.field("price").gte(JsonData.of(11.0)).lt(JsonData.of(16.0))))
                //matchAll
                .must(q -> q.matchAll(new MatchAllQuery.Builder().build())).build();

        NativeQuery nativeQuery = new NativeQueryBuilder().withQuery(q -> q.bool(boolQuery))
                //查询结果按照price从小到大排序
                .withSort(Sort.by(Sort.Direction.ASC, "price"))
                //第0页开始
                .withPageable(PageRequest.of(0, 5))
                .build();
        SearchHits<Book> search = operations.search(nativeQuery, Book.class);
        search.stream().forEach(System.out::println);

    }
}

二、Es客户端elasticsearchClient

1、创建客户端配置类 ElasticSearchConfig

package com.zhuang.es.config;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.Node;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.elasticsearch.ElasticsearchProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.config.ElasticsearchConfigurationSupport;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;

import javax.annotation.Resource;

@Configuration
@Slf4j
public class ElasticSearchConfig extends ElasticsearchConfigurationSupport {
    @Resource
    private ElasticsearchProperties elasticSearchProperty;
 
    @Bean
    public RestClientBuilder restClientBuilder() {
        return RestClient.builder(elasticSearchProperty.getUris().stream().map(this::getElasticSearchHttpHosts).toArray(HttpHost[]::new)).
                setRequestConfigCallback(requestConfigBuilder -> {
                    //设置连接超时时间
                    requestConfigBuilder.setConnectTimeout(elasticSearchProperty.getConnectionTimeout().toMillisPart());
                    requestConfigBuilder.setSocketTimeout(elasticSearchProperty.getSocketTimeout().toMillisPart());
                    return requestConfigBuilder;
                }).setFailureListener(new RestClient.FailureListener() {
                    //某节点失败,这里可以做一些告警
                    @Override
                    public void onFailure(Node node) {
                        log.error("[ ElasticSearchClient ] >>  node :{}, host:{},  fail ", node.getName(), node.getHost());
                    }
                }).setHttpClientConfigCallback(httpClientBuilder -> {
                    // 设置[X-Elastic-Product] header
                    httpClientBuilder.disableAuthCaching().addInterceptorLast((HttpResponseInterceptor)(response, context) -> response.addHeader("X-Elastic-Product", "Elasticsearch"));

                    //设置账密
                    return getHttpAsyncClientBuilder(httpClientBuilder);
                });
    }
 
 
    /**
     * 配置es client
     */
    @Bean(value = "elasticsearchClient")
    public ElasticsearchClient elasticsearchClient(@Qualifier("restClientBuilder") RestClientBuilder restClientBuilder) {
        RestClient restClient = restClientBuilder.setDefaultHeaders(new Header[]{new BasicHeader("Content-Type", "application/json")}).build();
        ElasticsearchTransport transport = new RestClientTransport(
                restClient, new JacksonJsonpMapper());
        return new ElasticsearchClient(transport);
    }
 
    @Bean(value = "elasticsearchTemplate")
    public ElasticsearchTemplate elasticsearchTemplate(ElasticsearchClient elasticsearchClient, ElasticsearchConverter elasticsearchConverter) {
        return new ElasticsearchTemplate(elasticsearchClient, elasticsearchConverter);
    }
 
    private HttpHost getElasticSearchHttpHosts(String host) {
        host = host.replaceAll("http://", "").replaceAll("https://", "");
        return new HttpHost(host.split(":")[0], Integer.parseInt(host.split(":")[1]), "http");
    }
 
 
    private HttpAsyncClientBuilder getHttpAsyncClientBuilder(HttpAsyncClientBuilder httpClientBuilder) {
        if (StringUtils.isEmpty(elasticSearchProperty.getUsername()) || StringUtils.isEmpty(elasticSearchProperty.getPassword())) {
            return httpClientBuilder;
        }
        //设置账号密码
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(elasticSearchProperty.getUsername(), elasticSearchProperty.getPassword()));
        httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
        return httpClientBuilder;
    }
}

2、增删改查、批量操作

注入ElasticsearchClient bean

   @Resource(name = "elasticsearchClient")
   ElasticsearchClient client;

package com.zhuang;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkOperation;
import co.elastic.clients.elasticsearch.core.bulk.IndexOperation;
import co.elastic.clients.elasticsearch.core.bulk.UpdateOperation;
import co.elastic.clients.elasticsearch.indices.CreateIndexRequest;
import co.elastic.clients.elasticsearch.indices.CreateIndexResponse;
import com.zhuang.es.EsApplication;
import com.zhuang.es.entity.Book;
import com.zhuang.es.service.BookRepository;
import com.zhuang.es.vo.BookVo;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.*;

/**
 * @program: kafka
 * @description:
 * @author: mrzhuang
 * @create: 2022-12-25 13:04
 **/
@Slf4j
@SpringBootTest(classes = EsApplication.class)
public class EsClientTest {

    @Resource
    BookRepository repository;
    @Resource(name = "elasticsearchClient")
    ElasticsearchClient client;

    /**
     * 创建索引
     * @throws IOException
     */
    @Test
    void testCreateIndex() throws IOException {
        //client.indices().create(c->c.index("book"));
        CreateIndexRequest createIndexRequest= new CreateIndexRequest.Builder().index("book").build();
        CreateIndexResponse indexResponse = client.indices().create(createIndexRequest);
        log.info("[{}]索引创建[{}]！", indexResponse.index(), indexResponse.shardsAcknowledged());
    }

    /**
     * 增加数据
     * @throws IOException
     */
    @Test
    void testInsertData() throws IOException {
        Optional<Book> book = repository.findById(1l);
        IndexRequest<Book> indexRequest = new IndexRequest.Builder<Book>().index("book").id("1").document(book.isPresent() ? book.get() : Book.builder().name("小刘").id(2l).build()).build();
        //IndexRequest source = indexRequest.index("book").id("1").source(book.isPresent() ? book.get() : Book.builder().name("小刘"));
        IndexResponse index = client.index(indexRequest);
        log.info("向索引[{}]中增加id:[{}]文档:[{}]", index.index(), index.id(), index.result());
    }
    /**
     * 删除数据
     * @throws IOException /
     */
    @Test
    void testDeleteData() throws IOException {
        //1.根据id删除
        DeleteRequest deleteRequest = new DeleteRequest.Builder().index("book").id("gAcXSIUB94FMQr43ryS6").build();
        DeleteResponse deleteResponse = client.delete(deleteRequest);
        log.info("根据id删除：{}", deleteResponse.result().jsonValue());


        //2.根据查询条件删除
        DeleteByQueryRequest deleteByQueryRequest = new DeleteByQueryRequest.Builder().index(List.of("book")).query(q -> q.term(t -> t.field("name").value("xiaoxiao"))).build();
        DeleteByQueryResponse deleteByQueryResponse = client.deleteByQuery(deleteByQueryRequest);
        log.info("根据查询条件删除：{}个", deleteByQueryResponse.total());
    }

    /**
     * 更新数据
     *
     * @throws IOException
     */
    @Test
    void testUpdateDate() throws IOException {
        //方法1：创建实体类BookVo对应的实体类的属性和名称与Book相同
        //会将Book中对应的属性值替换为需要修改的bookVo中的属性值，然后更新es相对应的属性值
        BookVo bookVo = BookVo.builder().parent("妈").build();
        UpdateRequest<Book, BookVo> update1 = new UpdateRequest.Builder<Book, BookVo>().index("book").id("1").doc(bookVo).build();

        //方法2：创建Map
        Map<String, String > map = new HashMap<>();
        map.put("parent","爸妈");
        UpdateRequest<Book, Map<String, String >> update2 = new UpdateRequest.Builder<Book, Map<String, String >>().index("book").id("1").doc(map).build();

        UpdateResponse<Book> update = client.update(update1, Book.class);
        log.info("update:{}", update.result());
    }
    /**
     * 查询数据
     * @throws IOException
     */
    @Test
    void testSearch() throws IOException {
        TermQuery termQuery = new TermQuery.Builder().field("id").value("11").build();
        Query query = new Query.Builder().term(termQuery).build();
        BoolQuery boolQuery = new BoolQuery.Builder().must(query).build();
        Query build = new Query.Builder().bool(boolQuery).build();
        SearchRequest searchRequest = new SearchRequest.Builder().query(build).index(Arrays.asList(new String[]{"book"})).build();

        SearchResponse<Book> response = client.search(searchRequest, Book.class);
        log.info("查询数据：{}", response.hits().hits().size());
    }

    /**
     * 批量增加
     * @throws IOException
     */
    @Test
    void testBulkInsert() throws IOException {
        //批量新增数据
        //第一个数据
        IndexOperation<Book> indexOperation1 = new IndexOperation.Builder<Book>().id("2").document(Book.builder().id(2l).name("小庄呀").build()).build();
        BulkOperation operation1 = new BulkOperation.Builder().index(indexOperation1).build();
        //第二个数据
        IndexOperation<Book> indexOperation2 = new IndexOperation.Builder<Book>().id("3").document(Book.builder().id(3l).name("小庄呀").build()).build();
        BulkOperation operation2 = new BulkOperation.Builder().index(indexOperation1).build();

        List<BulkOperation> operations = new ArrayList<>();
        operations.add(operation1);
        operations.add(operation2);

        BulkRequest bulkRequest = new BulkRequest.Builder().index("book").operations(operations).build();
        BulkResponse bulkResponse = client.bulk(bulkRequest);
        log.info("批量删除：{}, size：{}", !bulkResponse.errors(), bulkResponse.items().size());
    }

    /**
     * 批量更新
     * @throws IOException
     */
    @Test
    void testBulkUpdate() throws IOException {
        //批量新增数据
        //第一个数据
        UpdateOperation<Book, BookVo> updateOperation1 = new UpdateOperation.Builder<Book, BookVo>().id("2").action(b -> b.doc(BookVo.builder().name("xiaoxiao").build())).build();
        BulkOperation operation1 = new BulkOperation.Builder().update(updateOperation1).build();

        //第一个数据
        UpdateOperation<Book, BookVo> updateOperation2 = new UpdateOperation.Builder<Book, BookVo>().id("3").action(b -> b.doc(BookVo.builder().name("xiao").build())).build();
        BulkOperation operation2= new BulkOperation.Builder().update(updateOperation2).build();

        List<BulkOperation> operations = new ArrayList<>();
        operations.add(operation1);
        operations.add(operation2);

        BulkRequest bulkRequest = new BulkRequest.Builder().index("book").operations(operations).build();
        BulkResponse bulkResponse = client.bulk(bulkRequest);
        log.info("批量更新：{}, size：{}", !bulkResponse.errors(), bulkResponse.items().size());
    }
}
zhuang先森
关注
SpringBoot集成elasticsearch 7.17.3及常规应用
wohaipagui的博客
05-11 4568
elasticsearch 7.17.3下载地址： 链接：https://pan.baidu.com/s/1o30iawcZPhV6sYcd9jym9g?pwd=0nt0 提取码：0nt0 前提：需要安装elasticsearch工具 一、创建项目 1.创建个空项目 在这里插入图片描述 默认的（Developer Tools）都需要勾选，最主要的是NoSQL中选中ElasticSearch 配置编译版本 二、修改配置 1. 删除maven没用的插件 2. 修改spring版本到本地版本 3
Es集成Springboot
qq_42000887的博客
09-01 1161
ES集成springboot
SpringBoot整合ElasticSearch
尽力而为！
02-11 1783
ElasticsearchRestTemplate模板类，封装了便捷操作Elasticsearch的模板方法，包括 索引 / 映射 / CRUD 等底层操作和高级操作。该接口是框架封装的用于操作Elastsearch的高级接口。
Spring Boot整合Elasticsearch
null
04-14 1634
引入成功后，这里注意检查引入的jar包版本号，尽量保证与elasticsearch版本号一致，否则可能会出现莫名奇怪的问题。如图所示，程序引入的是7.17.15，但是我们使用的elasticsearch版本是7.17.18，所以这里做下修改。重启elasticsearch、elasticsearch-head，刷新页面，连接成功。查看elasticsearch-head，文档创建成功，能够成功查询到。运行，成功查询文档信息，打印信息如下。运行，成功创建文档，打印信息如下。运行，成功打印查询的索引信息。
ElasticSearch7.17.3简介+centos7详细安装教程+Springboot整合ES
最新发布
u011317306的博客
10-09 1693
作为 Elastic Stack 的核心，Elasticsearch 能够集中存储您的数据，实现闪电般的搜索速度、精细的相关性调整以及强大的分析能力，并且能够轻松地进行规模扩展。切换账号，重新启动es，第一次启动的时候，建议不要后台启动，直接启动方便查看日志，第一次安装会遇到各种问题，等直接启动成功后，我们可以加个-d参数，再后台启动。那么来吧，创建个新的用户，新增个chuyi的用户，然后设置密码，最后把elasticsearch的目录给他赋值上权限。跟着我的步骤一步步安装，如果你还是装不好，你来打我。
ElasticSearch集成SpringBoot
Daylight629博客
03-14 232
ElasticSearch集成SpringBoot 找官方文档！ 找到原生的依赖 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.6.2</version> </dependency&gt
安装Elaticsearch7.17.3与Kibana7.17.3
weixin_45726578的博客
05-05 1211
缺少默认配置，至少需要配置discovery.seed_hosts/discovery.seed_providers/cluster.initial_master_nodes中的一个参数.ES因为需要大量的创建索引文件，需要大量的打开系统的文件，所以我们需要解除linux系统当中打开文件最大数目的限制，不然ES启动就会抛错。不要超过30GB - https://www.elastic.co/cn/blog/a-heap-of-trouble。访问Kibana: http://localhost:5601/
Spring Boot集成ES
清雨小竹
05-31 4169
【代码】Spring Boot集成ES。
Java连接Elasticsearch（v7.17.3）
静坐听雨
03-20 966
ElasticSearch是一个基于Lucene的搜索服务器，它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。ElasticSearch是用Java开发的，因此Java API是与ElasticSearch交互的主要方式。本文将介绍如何使用Java API连接ElasticSearch7.17.3。
Elastic Stack(Elasticsearch + kibana + Logstash + FileBeat + APM) 7.17.14 版本的本地搭建
HanKiKi的开发之旅
11-12 430
Elastic Stack 7.17.14版本 本地搭建
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用）
03-03
本实例为博主原创，属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、...
《探错笔记》之Springboot集成ES报org.elasticsearch.client.transport.NoNodeAvailableException异常
御前提笔小书童
03-20 3094
问题 目前出现以下异常 org.elasticsearch.client.transport.NoNodeAvailableException: None of the configured nodes are available 的大部分原因都是因为springboot直接使用 <dependency> <groupId>org.spring...
SpringBoot集成ES
weixin_49319251的博客
12-17 1997
java代码使用ES 依赖： <!--es的包--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> ElasticsearchRepository接口： 创建一个接口，继承Elastic
Springboot 集成es
weixin_44096941的博客
07-08 204
在pom.xml文件当中 org.projectlombok lombok 1.16.20 <!--elasticsearch --> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version>5.6.8</vers
springboot集成es
lgq2016的博客
08-11 683
java操作es的api。
Elasticsearch7.17.3
09-27
Elasticsearch7.17.3是一个开源的分布式搜索和分析引擎。它可以用于实时搜索、日志分析、数据可视化等多种场景。在安装Elasticsearch7.17.3之前，你需要先安装ik分词器，你可以按照以下步骤进行安装： 1. 在es的plugins外部的映射文件下执行以下命令： ``` wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.17.3/elasticsearch-analysis-ik-7.17.3.zip unzip elasticsearch-analysis-ik-7.17.3.zip ``` 2. 如果在容器外的映射文件plugins下修改安装的ik文件权限： ``` chmod -R 777 elasticsearch-analysis-ik-7.17.3/ ``` 3. 进入es容器的/bin目录下，查看是否安装成功： ``` elasticsearch-plugin list ``` 在配置Kibana时，你可以按照以下步骤进行配置： 1. 打开kibana.yml文件，添加或修改以下内容： ``` server.port: 5601 server.host: 0.0.0.0 elasticsearch.hosts: ["http://远程访问es的Ip:9200"] xpack.monitoring.ui.container.elasticsearch.enabled: true elasticsearch.username: "elastic" elasticsearch.password: "elastic" i18n.locale: "zh-CN" ``` 关于Elasticsearch的查询方法，你可以参考下面的示例： ```java // 增加方法 List<Book> findByNameAndPrice(String name, Double price); // Elasticsearch json 查询 { "query": { "bool": { "must": [ { "query_string": { "query": "?", "fields": ["name"] } }, { "query_string": { "query": "?", "fields": ["price"] } } ] } } } package com.zhuang.es.service; import com.zhuang.es.entity.Book; import org.springframework.data.elasticsearch.repository.ElasticsearchRepository; import java.util.List; public interface BookRepository extends ElasticsearchRepository<Book, Long> { List<Book> findByNameAndPrice(String name, Double price); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值