投稿
  1. 半码博客首页
  2. 后端开发

五.全文检索ElasticSearch经典入门-ElasticSearch Java实战

小半 • • 后端开发 • 阅读 72

导读：本篇文章讲解 五.全文检索ElasticSearch经典入门-ElasticSearch Java实战，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

前言

今天开始我们学习如何使用Java来操作ES，这里会讲两种操作方式，一是使用ES提供的jar包来操作，二是使用SpringBootData来操作，第二种方式是企业里面使用的较多的方式了。

Java 操作ES

环境集成

创建一个普通的Java工程，首先我们需要导入ES的jar包

<dependency>
   <groupId>org.elasticsearch.client</groupId>
    <artifactId>transport</artifactId>
    <version>6.8.6</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>compile</scope>
</dependency>

然后创建ES的客户端

public class ESClientUtil {

    public static TransportClient getClient(){
        TransportClient client = null;
        Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
        try {
            client = new PreBuiltTransportClient(settings).addTransportAddress(
            new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        return client;
    }

}

添加文档

编写测试类 ，往指定的索引库中添加文档

@Test
public void testAdd() {
  //获取客户端对象
  TransportClient client = ESClientUtil.getClient();

  //创建索引
  IndexRequestBuilder indexRequestBuilder = client.prepareIndex("orders", "_doc", "1");
  Map<String,Object> data = new HashMap<>();
  data.put("id",1);
  data.put("title","买了一个鼠标");
  data.put("count",1);
  data.put("amount",100.00);
  data.put("status",1);
  //获取结果
  IndexResponse indexResponse = indexRequestBuilder.setSource(data).get();
  //打印给过
  System.out.println(indexResponse);
  client.close();
}

打印结果如下 ：

IndexResponse[index=orders,type=_doc,id=1,version=18,result=updated,seqNo=19,primaryTerm=3,shards={“total”:2,“successful”:1,“failed”:0}]

获取一个文档

@Test
public void testGet() {
	//获取客户端对象
	TransportClient client = ESClientUtil.getClient();
	//获取文档
	GetResponse response = client.prepareGet("orders", "_doc", "1").get();
	//打印结果
	System.out.println(response);
}

打印结果如下：{amount=100.0, count=1, id=1, title=买了一个鼠标, status=1}

更新一个文档

@Test

public void testUpdate(){
    //获取客户端对象
    TransportClient client = ESClientUtil.getClient();

    //修改索引
    UpdateRequestBuilder updateRequestBuilder = client.prepareUpdate("orders", "_doc", "1");
    Map<String,Object> data = new HashMap<>();
    data.put("id",1);
    data.put("title","买了一个鼠标");
    data.put("count",2);
    data.put("amount",100.00);
    //data.put("status",1);
    //获取结果设置修改内容
    UpdateResponse updateResponse = updateRequestBuilder.setDoc(data).get();

    System.out.println(updateResponse);
    client.close();
}

打印结果如下：UpdateResponse[index=orders,type=_doc,id=1,version=19,seqNo=20,primaryTerm=3,result=updated,shards=ShardInfo{total=2, successful=1, failures=[]}]

注意：这种修改方式是不会影响到未修改的字段的，比如上面注释掉status字段，status字段不会被修改。也就是说这种方式是局部修改。

删除一个文档

 @Test
 public void testDelete() {
      //获取客户端对象
      TransportClient client = ESClientUtil.getClient();
      //执行删除
      DeleteResponse response = client.prepareDelete("orders", "_doc", "1").get();
      //打印结果
      System.out.println(response);
  }

打印结果：DeleteResponse[index=orders,type=_doc,id=1,version=20,result=deleted,shards=ShardInfo{total=2, successful=1, failures=[]}]

批量操作

同时提交多个操作

@Test
public void testBuilkAdd(){
   //获取客户端对象
   TransportClient client = ESClientUtil.getClient();

   BulkRequestBuilder bulkRequestBuilder = client.prepareBulk();

   Map<String,Object> data1 = new HashMap<>();
   data1.put("id",1);
   data1.put("title","买了一个鼠标");
   data1.put("count",2);
   data1.put("amount",100.00);

   //添加操作
   bulkRequestBuilder.add(client.prepareIndex("orders", "_doc", "1").setSource(data1));

   Map<String,Object> data2 = new HashMap<>();
   data2.put("id",2);
   data2.put("title","买了一个鼠标");
   data2.put("count",2);
   data2.put("amount",100.00);
   //添加操作
   bulkRequestBuilder.add(client.prepareIndex("orders", "_doc", "2").setSource(data2));

   Map<String,Object> data3 = new HashMap<>();
   data3.put("id",2);
   data3.put("title","买了一个鼠标");
   data3.put("count",2);
   data3.put("amount",200.00);

   //修改操作
   bulkRequestBuilder.add(client.prepareUpdate("orders", "_doc", "2").setDoc(data3));


   BulkResponse bulkItemResponses = bulkRequestBuilder.get();
   Iterator<BulkItemResponse> iterator = bulkItemResponses.iterator();
   while(iterator.hasNext()){
       BulkItemResponse next = iterator.next();
       System.out.println(next.getResponse());
   }
   client.close();
 }

打印结果
IndexResponse[index=orders,type=_doc,id=1,version=1,result=created,seqNo=22,primaryTerm=3,shards={“total”:2,“successful”:1,“failed”:0}]
IndexResponse[index=orders,type=_doc,id=2,version=4,result=updated,seqNo=3,primaryTerm=3,shards={“total”:2,“successful”:1,“failed”:0}]
UpdateResponse[index=orders,type=_doc,id=2,version=5,seqNo=4,primaryTerm=3,result=updated,shards=ShardInfo{total=2, successful=1, failures=[]}]

DSL查询

案例：查询订单标题中包含：鼠标，价格在10-2000之间，状态为1，按照价格正排序

@Test
    public void testSearch(){
        //获取客户端对象
        TransportClient client = ESClientUtil.getClient();

        SearchRequestBuilder searchRequestBuilder = client.prepareSearch("orders");
        //设置分页
        searchRequestBuilder.setFrom(0);
        searchRequestBuilder.setSize(10);
        searchRequestBuilder.addSort("amount", SortOrder.ASC);

        //查询条件
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //dsl查询
        List<QueryBuilder> must = boolQueryBuilder.must();
        must.add(QueryBuilders.matchQuery("title" , "鼠标"));

        //dsl过滤
        List<QueryBuilder> filter = boolQueryBuilder.filter();
        filter.add(QueryBuilders.rangeQuery("amount").lte(2000).gte(10));
        filter.add(QueryBuilders.termQuery("status",1));

        searchRequestBuilder.setQuery(boolQueryBuilder);

        SearchResponse searchResponse = searchRequestBuilder.get();

        SearchHits hits = searchResponse.getHits();

        System.out.println("条数："+hits.getTotalHits());
        for (SearchHit hit : hits.getHits()) {
            System.out.println(hit.getSourceAsMap());

        }

        client.close();
    }

SpringBootData操作ES

环境集成

第一步：导入SpringBoot提整合ES的依赖 spring-boot-starter-data-elasticsearch

<!--SpringBoot-->
<parent>
   <groupId> org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>2.2.5.RELEASE</version>
</parent>

<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-test</artifactId>
	 </dependency>
	  <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
</dependencies>

第二步：然后需要在yml中对ES进行配置 , 如果是集群配置增加uri即可，单个配置如下：

spring:
  elasticsearch:
    rest:
      uris:
        - http://localhost:9200

第三步：编写启动类

@SpringBootApplication
public class SearchStart {

    public static void main(String[] args) {
        SpringApplication.run(SearchStart.class);
    }
}

创建Document对象

第三步：编写Document对象 ，该对象是对存储到ES中的数据的封装，同时文档映射也是通过它来实现


//标记该对象是ES的文档对象
//indexName 索引库
//type 类型
@Document(indexName = "orders",type = "_doc")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrderDoc {

    //标记为文档ID，该ID的值会作为document的id值
    @Id
    private Long id;
    /**
     * 标题需要分词，指定为text;并使用IK分词器
     * 一般需要作为关键字搜索的字段都要指定为text，因为需要分词且创建索引
     */
    @Field(type = FieldType.Text,analyzer = "ik_max_word",searchAnalyzer = "ik_max_word")
    //@Field(type = FieldType.Keyword)
    private String title;

    /**
     * 指定为integer类型
     */
    @Field(type = FieldType.Integer)
    private int count;
    /**
     * 状态指定为 integer类型
     */
    @Field(type = FieldType.Integer)
    private int status;

    /**
     * 金额
     */
    @Field(type = FieldType.Double)
    private BigDecimal amount;

}

创建Repository

第四步：SpringBootData提供了ElasticsearchRepository 来操作ES，该接口中包含了针对ES的CRUD方法，我们编写接口集成它即可使用

@Repository
public interface OrderRepository extends ElasticsearchRepository<OrderDoc,Long> {
}

注意：这里的泛型是当前Repository所要管理的实体类，也就是OrderDoc，Long是实体类ID的类型

创建索引和映射

编写一个基于SpringBoot的测试类如下：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SearchStart.class)
public class OrderESTest {
	//操作ES的template模板
    @Autowired
    private ElasticsearchRestTemplate template;
    
    @Autowired
    private OrderRepository orderRepository;

    @Test
    public void test(){
   		//创建索引
        template.createIndex(CourseDoc.class);
        //创建映射
        template.putMapping(CourseDoc.class);
    }
}

这里我注入了一个 ElasticsearchRestTemplate 工具类，通过它的 createIndex 可以创建索引库，SpringBoot指定解析 CourseDoc上的@Document注解中的index来确定索引库的名字。创建映射也是同样的道理。

基础CRUD

在SpringBoot中对ES的Crud显得极其简单，直接调用repository内置方法即可完成

@Test
    public void testAdd(){
        orderRepository.save(new OrderDoc(1L,"买了一个表",1,1,new BigDecimal("200")));
    }

    @Test
    public void testGet(){
        Optional<OrderDoc> optional = orderRepository.findById(1l);
        System.out.println(optional.get());
    }

    @Test
    public void testDelete(){
        orderRepository.deleteById(1L);
    }

注意：这里并没有update方法，因为save对象的时候如果ID已经存在，就会执行update操作。repository中还有很多的方法可以使用，你可以自己去调试。

DSL查询

在SpringBoot中我们通过 NativeSearchQueryBuilder 来构建查询条件，调用repository.search来执行查询。
案例：查询标题中包含鼠标 ，状态为1，金额在10-2000之间，按照金额倒排，查询第2页数据，每页10条

 @Test
public void testSearch(){

    //查询构建器
    NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();

    //设置分页： 第2页 (0开始)， 每页10数
    builder.withPageable(PageRequest.of(1,10));
    //设置排序 : 金额倒排
    builder.withSort(SortBuilders.fieldSort("amount").order(SortOrder.DESC));

    //构建组合查询
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

    //标题包含鼠标
    boolQuery.must(QueryBuilders.matchQuery("title","鼠标"))
            //状态值查询
            .filter(QueryBuilders.termQuery("status",1))
            //金额范围查询
            .filter(QueryBuilders.rangeQuery("amount").gte(10).lte(2000));

    //添加查询条件
    builder.withQuery(boolQuery);

    //执行搜索
    Page<OrderDoc> page = orderRepository.search(builder.build());
    //获取条数
    System.out.println("总元素个数："+page.getTotalElements());
    //打印列表
    page.getContent().forEach(System.out::print);

}

这里需要根据业务需求组装查询条件，我们之前见过的查询条件都可以通过它来构建，如：
在这里插入图片描述

打印效果

条数：3
{amount=200, count=1, id=2, title=买了一个鼠标, status=1}
{amount=200, count=1, id=1, title=买了一个鼠标, status=1}
{amount=200, count=1, id=3, title=买了一个鼠标, status=1}

文章结束，如果对你有所帮助，请点赞收藏加评论

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由半码博客整理，本文链接：https://www.bmabk.com/index.php/post/10589.html

赞 (0)
小半的头像小半
0 0

相关推荐

半码博客——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！