ElasticSearch7.6.x Idea操作

ElasticSearc集成Spring Boot(1)

导入依赖

<!--导入es-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

指定es的版本与自己本地安装的版本一致

    <properties>
        <!--自定义版本，和自己本地的版本一致-->
        <elasticsearch.version>7.6.2</elasticsearch.version>
        <java.version>1.8</java.version>
    </properties>

ElasticSearConfig

package com.esapi.config;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置ElasticSear配置文件
 */
@Configuration
public class ElasticSearConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200)
                ));
        return client;
    }
}

关于索引APl基本操作

package com.esapi;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
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.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
class EsApiApplicationTests {
  @Autowired
  private  RestHighLevelClient restHighLevelClient;

    //测试索引创建
    @Test
    void contextLoads() throws IOException {
      //创建索引请求
      CreateIndexRequest request = new CreateIndexRequest("yuan_index");
      //客户端执行请求，indices()，获得请求响应
      CreateIndexResponse indexCreate = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
      System.out.println(indexCreate);
    }

    //测试获取索引
    @Test
   void contextLoads2() throws IOException {
      GetIndexRequest request = new GetIndexRequest("yuan_index");
      //判断索引是否存在
      boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    //测试删除索引
    @Test
    void contextLoads3() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("yuan_index");
        //删除
        AcknowledgedResponse delete = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete);

    }
}

关于文档基本操作

依赖

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

User

package com.esapi.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
@Component
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String name;
    private int age;
}

测试

package com.esapi;
import com.alibaba.fastjson.JSON;
import com.esapi.pojo.User;
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.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.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

/**
 * 文档基本操作
 */
@SpringBootTest
class Test {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    //测试索引创建
    @org.junit.jupiter.api.Test
    void contextLoads() throws IOException {
        //创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("yuan_index");
        //客户端执行请求，indices()，获得请求响应
        CreateIndexResponse indexCreate = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(indexCreate);
    }

     //测试添加文档
    @org.junit.jupiter.api.Test
    public void test1() throws IOException {
       //创建对象
        User user = new User("yuan", 2);
        //创建请求
        IndexRequest request = new IndexRequest("yuan_index");
        //设置规则  put/yuan_index/_doc/1
        request.id("1");//设置id为1
        //request.timeout(TimeValue.timeValueSeconds(1));//设置过期时间
        request.timeout("1s");//设置过期时间
        //将数据转成json放入请求
        request.source(JSON.toJSONString(user), XContentType.JSON);
        //客户端发送请求，获得响应的数据
        IndexResponse index = restHighLevelClient.index(request, RequestOptions.DEFAULT);
        System.out.println(index);
        System.out.println(index.status());//返回对应的状态  CREATED
    }

    //获取文档，判断文档是否存在 get/index/_doc/1
    @org.junit.jupiter.api.Test
    public void test2() throws IOException {
        GetRequest getReqest = new GetRequest("yuan_index", "1");//索引名称yuan_index  id编号 1
        boolean exists = restHighLevelClient.exists(getReqest, RequestOptions.DEFAULT);  //判断是否存在
        System.out.println(exists);
    }

    //获取文档的一些信息
    @org.junit.jupiter.api.Test
    public void test3() throws IOException {
        GetRequest getReqest = new GetRequest("yuan_index", "1");//索引名称yuan_index  id编号 1
        GetResponse documentFields = restHighLevelClient.get(getReqest, RequestOptions.DEFAULT);//获取文档的信息
        System.out.println(documentFields.getSourceAsString());//大于文档内容
        System.out.println(documentFields);//返回的全部内容和命令式一样的
    }

    //跟新文档记录
    @org.junit.jupiter.api.Test
    public void test4() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest("yuan_index", "1");
        updateRequest.timeout("1s");//设置过期时间为1s
        User user = new User("哈哈哈", 100);
        //将数据转成json放入请求  XContentType指定类型为josn
        updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
        //客户端发送请求，获得响应的数据
        UpdateResponse update = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(update.status());//查看响应的状态
    }
    //删除文档记录
    @org.junit.jupiter.api.Test
    public void test5() throws IOException {
        DeleteRequest requst = new DeleteRequest("yuan_index", "1");
        requst.timeout("1s");
        DeleteResponse delete = restHighLevelClient.delete(requst, RequestOptions.DEFAULT);
        System.out.println(delete.status());
    }
    //批量插入
    @org.junit.jupiter.api.Test
    public void test6() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();//批量插入请求
        bulkRequest.timeout("10s");//设置过期时间为10s
        ArrayList<User> user = new ArrayList<>();
        user.add(new User("哈哈哈",17));
        user.add(new User("呵呵呵",16));
        user.add(new User("嘻嘻嘻",14));
        user.add(new User("啦啦啦",23));
        //批量请求处理
        for (int i = 0; i <user.size() ; i++) {
            //批量更新和批量删除，就在这里修改对应的请求就可以了
            bulkRequest.add(new IndexRequest("yuan_index")
                    .id(""+(1+i))//如果不设置id会有默认的随机id
                    .source(JSON.toJSONString(user.get(i)),XContentType.JSON)
            );
        }
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulkResponse.hasFailures());//是否失败，返回false代表成功!
    }

// 查询
// SearchRequest 搜索请求
// SearchSourceBuilder 条件构造
// HighlightBuilder 高亮
// TermQueryBuilder 精确查询
// MatchAllQueryBuilder
// xxxQueryBuilder ...
@org.junit.jupiter.api.Test
public void testSearch() throws IOException {
      // 1.创建查询请求对象
        SearchRequest searchRequest = new SearchRequest("yuan_index");
     // 2.构建搜索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
      // (1)查询条件 使用QueryBuilders工具类创建
      // 精确查询
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("age", "17");
       // 匹配查询
        // MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
       // (2)其他<可有可无>：（可以参考 SearchSourceBuilder 的字段部分）
       // 设置高亮
        searchSourceBuilder.highlighter(new HighlightBuilder());
      // 分页
      // searchSourceBuilder.from();
      // searchSourceBuilder.size();
      // (3)条件投入
      searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));//设置60秒过期
         // 3.添加条件到请求
        searchRequest.source(searchSourceBuilder);
        // 4.客户端查询请求
        SearchResponse search = restHighLevelClient.search(searchRequest,RequestOptions.DEFAULT);
       // 5.查看返回结果
        System.out.println(JSON.toJSONString(search.getHits()));
    }
}

ElasticSearc集成Spring Boot(2)

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@Component
// indexName索引名称，type类型
@Document(indexName = "schooldb")
public class Student {
    private Integer id;
    private String stuName;
    private String stuAddress;
    private Integer stuAge;
}

mapper接口

public interface StudentReponsitory extends ElasticsearchRepository<Student,Integer> {
   //可以使用方法命名查询
    //使用findBy开头 
}

继承了ElasticsearchRepository<T,ID> 指定了要操作的实体，及实体唯一标识的类型

通过继承关系可以得知ElasticsearchRepository提供了CRUD及分页的基本方法

service

@Service
@Slf4j
public class StudentService {

    @Autowired
    private StudentReponsitory studentReponsitory;

    /**
     * 根据id查询学生
     */
    public Student findStudentById(Integer id){
        return studentReponsitory.findById(id).get();
    }
}

测试类

@Test
void contextLoads() {
     Student student = studentService.findStudentById(1);
     System.out.println(student);
}

复杂查询

/**
 * SpringBoot2.4.0 分页、排序查找指定地址的学生，并且按照年龄降序
 * @return
 */
public List<Student> findStuList(){
    BoolQueryBuilder boolBuilder = new BoolQueryBuilder();
    boolBuilder.must(QueryBuilders.matchQuery("stuAddress","长沙"))
            .must(QueryBuilders.rangeQuery("stuAge").gt(0).lt(50));
    Sort.Order ordey = Sort.Order.desc("stuAge");

    //先排序在分页
    PageRequest pageRequest = PageRequest.of(0, 2, Sort.by(ordey));
    Page<Student> pages = studentReponsitory.search(boolBuilder, pageRequest);
    log.info("总页数："+pages.getTotalPages());
    log.info("总记录数："+pages.getTotalElements());
    log.info("当前页："+pages.getNumber());

    return pages.getContent();
}

PageRequest.of(page,size) , page从0开始表示第一页

@Test
public void test2() {
    List<Student> stuList = studentService.findStuList();
    for (Student student : stuList) {
        System.out.println(student);
    }
}

以下代码为SpringBoot2.6.5的版本

/**
 * 查找指定地址的学生，并且按照年龄降序
 */
public List<Student> findStuList(){
    //BoolQueryBuilder构建查询条件
    BoolQueryBuilder boolBuilder = new BoolQueryBuilder();
    boolBuilder.must(QueryBuilders.matchQuery("stuAddress","长沙"))
                .must(QueryBuilders.rangeQuery("stuAge").gt(23).lt(50));

    //SortBuilder构建排序字段和规则
    SortBuilder sortBuilder = new FieldSortBuilder("stuAge").order(SortOrder.DESC);
    NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                        .withQuery(boolBuilder)
                        .withSorts(sortBuilder)
                        .build();
    log.info(nativeSearchQuery.getQuery().toString());

    List<Student> studentList = new ArrayList<>();

    //调用模板方法实现查询
    SearchHits<Student> searchHitResult = restTemplate.search(nativeSearchQuery, Student.class);
    //转换
    searchHitResult.forEach(searchHit->{
        studentList.add(searchHit.getContent());
    });
    return studentList;
}