用SpringBoot整合ES数据库基础

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
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

脑袋不够用的小渣渣

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值