用SpringBoot整合ES数据库基础

最新推荐文章于 2024-06-11 18:01:44 发布

脑袋不够用的小渣渣

最新推荐文章于 2024-06-11 18:01:44 发布

阅读量1k

点赞数

分类专栏：后端 ES 文章标签：大数据 java elasticsearch intellij idea 数据挖掘

本文链接：https://blog.csdn.net/weixin_45717907/article/details/113195773

版权

后端同时被 2 个专栏收录

39 篇文章 0 订阅

订阅专栏

2 篇文章 0 订阅

订阅专栏

一、SpringBoot整合ES数据库

1、配置原生的依赖。

<properties>
    <java.version>1.8</java.version>
    <!-- 自己定义es版本依赖，保证和本地- -致-->
    <elasticsearch.version>7.6.2</elasticsearch.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.75</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- JODA Time -->
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10.5</version>
    </dependency>

    <!-- ELasticsearch -->
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>transport</artifactId>
        <version>7.6.2</version>
        <exclusions>
            <exclusion>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <!-- required by elasticsearch -->
        <groupId>org.elasticsearch.plugin</groupId>
        <artifactId>transport-netty4-client</artifactId>
        <version>7.6.2</version>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <version>2.3.3.RELEASE</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

2、构建对象。

RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(
                new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http")));
//记得关闭
client.close();

3、分析对应的方法。

@Controller 控制器（注入服务）
用于标注控制层，相当于struts中的action层
@Service 服务（注入dao）
用于标注服务层，主要用来进行业务的逻辑处理
@Repository（实现dao访问）
用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组件
@Component （把普通pojo实例化到spring容器中，相当于配置文件中的）
泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。

@Data : 注解在类上, 为类提供读写属性, 此外还提供了 equals()、hashCode()、toString() 方法
@Getter/@Setter : 注解在类上, 为类提供读写属性
@ToString : 注解在类上, 为类提供 toString() 方法
@Slf4j : 注解在类上, 为类提供一个属性名为 log 的 log4j 的日志对象

@Log4j : 注解在类上, 为类提供一个属性名为 log 的 log4j 的日志对象

3、构建实体类和测试类

//User类
@Data
@Component
public class User {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

//测试程序
package com.www.es.springboot.demo;

import com.alibaba.fastjson.JSON;
import com.www.es.springboot.demo.pojo.User;
import com.www.es.springboot.demo.utils.ESconst;
import org.elasticsearch.action.DocWriteRequest;
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.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.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.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
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 java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.TimeUnit;

@SpringBootTest
class DemoApplicationTests {


    @Autowired
    private RestHighLevelClient restHighLevelClient;

    //面向对象来操作
    @Autowired
    @Qualifier("restHighLevelClient" )
    private RestHighLevelClient client;
    //测试索引的创建Request
    @Test
    void testCreateIndex() throws IOException {
        // 1、创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("index1" );
        // 2、客户端执行请求IndicesClient,请求后获得响应
        CreateIndexResponse createIndexResponse =
                client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }

    //测试获取索引
    @Test
    void testExistIndex() throws IOException {
        GetIndexRequest request = new GetIndexRequest( "index");
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }
    //测试删除索引
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("index1");
        //删尉
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());
    }
    //测试添加文档
    @Test
    void testAddDocument() throws IOException {
        User user = new User("唐三藏",25);
        //创建请求
        IndexRequest indexRequest = new IndexRequest("index");
        indexRequest.id("1");
        indexRequest.timeout(TimeValue.timeValueSeconds(1));
        indexRequest.timeout("1s");
        //将我们的数据放入请求
        indexRequest.source(JSON.toJSONString(user), XContentType.JSON);
        //客户端发送请求
        IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);
        //获取响应的结果
        System.out.println(indexResponse.toString());
        System.out.println(indexResponse.status());
    }


    //获取文档，判断是否存在get /index/doc/
    @Test
    void testIsExists() throws IOException {
        GetRequest getRequest = new GetRequest( "index", "1");
        //不获取返回的_ source 的上下文了
        //getRequest.fetchSourceContext (new FetchSourceContext(false));
        //getRequest.storedFields("_none_");
        boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println(exists);

        GetResponse getResponse = client.get(getRequest,RequestOptions.DEFAULT);
        System.out.println(getResponse .getSourceAsString()); //打印文档的内容
        System.out.println(getResponse);
    }

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

    //更新文档的信息
    @Test
    void testUpdateDocuments() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest("index", "2");
        updateRequest.timeout("1s");
        User user = new User("杀阡陌", 18);
        UpdateRequest doc = updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);
        UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(doc);
        System.out.println(updateResponse.status());
        System.out.println(updateResponse);
    }

    //删除文档信息
    @Test
    void testDeleteDocuments() throws IOException {
        DeleteRequest deleteRequest = new DeleteRequest("index", "2");
        deleteRequest.timeout("1s");
        DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(deleteResponse.status());
        System.out.println(deleteRequest);
    }

    // 特殊的，真的项目一般都会批量插入数据!
    @Test
    void testBulkRequest() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        ArrayList<User> userList = new ArrayList<>();
        userList.add(new User("木sd1",3));
        userList.add(new User("木s2",4));
        userList.add(new User("木d3",5));
        userList.add(new User("木e4",6));
        userList.add(new User("木m5",7));
        userList.add(new User("木g6",8));
        userList.add(new User("木x7",9));
        // 用下迭代器
        /*for(int i = 0 ; i < userList.size();i++){
            bulkRequest.add(
                    new IndexRequest("index")
                            .id(""+(i+1))
                            .source(JSON.toJSONString(userList.get(i)), XContentType.JSON));
        }*/

        for(Iterator<User> user = userList.iterator(); user.hasNext();){
            System.out.println(user);
            /*System.out.println(user.next().getClass().getName());
            System.out.println(user.next());*/

            bulkRequest.add(
                    new IndexRequest("index")
                            .source(JSON.toJSONString(user.next()), XContentType.JSON));
        }
        BulkResponse bulkItemResponses = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulkItemResponses.hasFailures());
    }

    // 搜索查询
    // SearchRequest搜索请求
    // SearchSourceBuiLder条件构造
    // HighlightBuiLder构建高亮
    // TermQueryBuilder精确查询
    // MatchAlLQueryBuiLder
    // xxx QueryBuilder对应我们刚才看到的命令!
    @Test
    void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest(ESconst.ES_DATA_INDEX);
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        final HighlightBuilder highlightBuilder = new HighlightBuilder();
        SearchSourceBuilder highlighter = sourceBuilder.highlighter(highlightBuilder);
        System.out.println(highlighter);
        // 查询条件，我们可以使用 QueryBuilders 工具来实现
        // QueryBuilders.termQuery精确
        // QueryBuilders.matchAllQuery()匹配所有
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("age", "3");
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        //sourceBuilder.query(termQueryBuilder);
        sourceBuilder.query(matchAllQueryBuilder);
        searchRequest.source(sourceBuilder);
        sourceBuilder.timeout(new TimeValue(120, TimeUnit.SECONDS));
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(searchResponse.getHits().getHits()));
        System.out.println("=========================");
       for(SearchHit documentFields:searchResponse.getHits().getHits()){
           System.out.println(documentFields.getSourceAsMap());
       }

    }
}

脑袋不够用的小渣渣

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
用SpringBoot整合ES数据库基础

一、SpringBoot整合ES数据库1、配置原生的依赖。<properties> <java.version>1.8</java.version>  <elasticsearch.version>7.6.2</elasticsearch.version></properties><dependencies> <
复制链接

扫一扫