kibana、java、springBoot操作elasticsearch

kibana窗口操作elasticsearch

1、分页查询  where limit offset,count
GET /es2/book/_search
{
  "from": 0,
  "size": 2
}
2、排序   order by price (desc|asc) , xxx desc
GET /es2/book/_search
{
  "sort": [{
      "price": {
        "order": "desc"
      }
  }]
}
3、查询指定字段 select name,price from 
GET /es2/book/_search
{
  "_source": ["name","price"]
}

4、关键字查询  (重要) term查询 where 列名=值
GET /es2/book/_search
{
  "query": {
    "term": {
      "name": {
        "value": "零"
      }
    }
  }
}


5、范围查询  where price >20 and price < 100
GET /es2/book/_search
{
  "query": {
    "range": {
      "price": {
        "gt": 50,
        "lte": 150
      }
    }
  }
}

6、多ID查询  where id in(1,2)
GET /es2/book/_search
{
  "query": {
    "ids": {
      "values": ["4","5"]
    }
  }
}
7、bool查询  must(and)  should(or) 
GET /es2/book/_search
{
  "query": {
     "bool": {
       "must": [
         {
           "term": {
             "name": {
               "value": "三"
             }
           }
         },{
           "range": {
             "price": {
               "gte": 100,
               "lte": 200
             }
           }
         }
       ]
     }
  }
}

8、多字段查询
GET /es2/book/_search
{
  "query": {
    "multi_match": {
      "query": "三",
      "fields": ["name","author"]
    }
  }
}
9、高亮查询
关键字变成红色
GET /es2/book/_search
{
  "query": {
    "term": {
      "name": {
        "value": "三"
      }
    }
  },
  "highlight": {
    "fields": {
      "name": {}
    }
  }
}

java操作elasticsearch

工具类代码

public class ESUtils {

public static TransportClient getClient(){
    try {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY)
                .addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.137"), 9300));
        return transportClient;
    }catch (Exception e){
        e.printStackTrace();
    }
    return null;
}

}

java代码

增

public void testInsert()throws Exception{
        //1.获取连接
        TransportClient client = ESUtils.getClient();

  //{"name":"xx","author":"xx","price":""}
     //2.准备数据
     XContentBuilder builder = XContentFactory.jsonBuilder().startObject()
             .field("name", "金瓶梅").field("author", "兰陵晓晓声")
             .field("price", 250).endObject();

   //3.执行添加操作
    IndexResponse response = client.prepareIndex("es2", "book","10")
            .setSource(builder).get();

  //4.打印响应结果
   System.out.println("结果:"+response.status());
 }

删

public void testDelete()throws Exception{
        //1.获取连接
        TransportClient client = ESUtils.getClient();

   //2.执行删除操作
    DeleteResponse response = client.prepareDelete("es2", "book", "10").get();

   //3.打印响应结果
   System.out.println("结果:"+response.status());
   }

改

public void testUpdate()throws Exception{
        //1.获取连接
        TransportClient client = ESUtils.getClient();

   //{"name":"xx","author":"xx","price":""}
    //2.准备数据
    XContentBuilder builder = XContentFactory.jsonBuilder().startObject()
            .field("price", 300).endObject();

   //3.执行修改操作
   UpdateResponse response = client.prepareUpdate("es2", "book", "10")
           .setDoc(builder).get();

   //4.打印响应结果
   System.out.println("结果:"+response.status());
}

查

 1.1查全部
public void testQuery(){
        //1.获取连接
        TransportClient client = ESUtils.getClient();

  //2.提供query查询策略
   MatchAllQueryBuilder builder = QueryBuilders.matchAllQuery();  //查询所有

   //3.执行查询操作
   SearchResponse response = client.prepareSearch("es2").setTypes("book")
           .setQuery(builder).get();

   //4.获取总条数
   System.out.println("总条数: "+response.getHits().totalHits);   //分页依然获取总条数

   //5.获取每一个文档数据
   SearchHits hits = response.getHits();  //SearchHits 集合
   for(SearchHit h:hits){                 //SearchHit 集合中遍历获取的对象
       //getSourceAsMap() 获取文档转换成一个map
       Map<String, Object> map = h.getSourceAsMap();
       System.out.println(map);
   }
}

1.2条件查询
public void testTermQuery(){
        //1.获取连接
        TransportClient client = ESUtils.getClient();

  //2.提供query查询策略
   TermQueryBuilder builder = QueryBuilders.termQuery("name", "西游");

   //3.执行查询操作
   SearchResponse response = client.prepareSearch("es2").setTypes("book")
           .setQuery(builder).setFrom(0).setSize(2).get();

   //4.获取总条数
   System.out.println("总条数: "+response.getHits().totalHits);   //分页依然获取总条数

   //5.获取每一个文档数据
   SearchHits hits = response.getHits();  //SearchHits 集合
   for(SearchHit h:hits){                 //SearchHit 集合中遍历获取的对象
       //getSourceAsMap() 获取文档转换成一个map
       Map<String, Object> map = h.getSourceAsMap();
       System.out.println(map);
   }
}

1.3高亮查询
public Map selectHighLight(int page, int limit,String content){
        System.out.println("content = " + content);
        Map map = new HashMap();
        AbstractQueryBuilder builder = null;
        //获取链接
        TransportClient client = ESUtils.getClient();
        //查询全部
        if(content != null && !"".equals(content)){
            //条件查询
            builder = QueryBuilders.termQuery("content", content);
        }else {
            //查询全部
            builder = QueryBuilders.matchAllQuery();
        }
        //高亮查询
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("content");
        //执行查询
        SearchResponse response = client.prepareSearch("es3").setTypes("poetry").setFrom((page - 1) * limit)
                .setSize(limit).setQuery(builder).highlighter(highlightBuilder).get();
        //获取数据
        SearchHits hits = response.getHits();
        List<Map<String,Object>> list = new ArrayList<>();
        for(SearchHit hit : hits){
            String id = hit.getId();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            sourceAsMap.put("id",id);
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField c = highlightFields.get("content");
            System.out.println("c = " + c);
            if(c!=null){
                String s = c.fragments()[0].toString();
                sourceAsMap.put("content",s);
                System.out.println("sourceAsMap = " + sourceAsMap);
            }
            list.add(sourceAsMap);
        }
        map.put("code",0);
        map.put("msg","");
        map.put("count",hits.getTotalHits());
        map.put("data",list);
        return map;
    }

springBoot操作elasticsearch

添加依赖

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
 </dependency>

普通查询和自定义查询

建一个repository包新建一个接口

package com.baizhi.repository;

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

import java.util.List;

public interface BookRepository extends ElasticsearchRepository<Book,Long> {

  //条件查询 and  根据姓名和价格查询
   public List<Book> findByNameAndPrice(String name,Double price);

   public List<Book> findByPriceBetween(Double s1,Double s2);
}

@Autowired
    private BookRepository bookRepository;

   @Test
   public void test1(){
       Book book = new Book();
       book.setId(1L);
       book.setName("三国演义");
       book.setAuthor("罗贯中");
       book.setPrice(200.0);
       bookRepository.save(book);  //添加修改
   }

   @Test
   public void test2(){
       Book book = new Book();
       book.setId(1L);
       bookRepository.delete(book);  //删除
   }

   @Test
   public void test3(){
       Optional<Book> optional = bookRepository.findById(1L); //根据id查询
       Book book = optional.get();
       System.out.println(book);
   }

   @Test
   public void test4(){
       Iterable<Book> list = bookRepository.findAll();
       for (Book book : list) {
           System.out.println(book);
       }
   }

   @Test
   public void test5(){
       List<Book> list = bookRepository.findByNameAndPrice("西游", 100.0);//根据name和price查询
       System.out.println(list);
   }

   @Test
   public void test6(){
       List<Book> list = bookRepository.findByPriceBetween(100.0,150.0);
       System.out.println(list);
   }

可自己定义方法进行查询

自定义复杂查询（高亮查询）

在repository包下写一个接口

package com.baizhi.repository;

import com.baizhi.entity.Book;

import java.util.List;

public interface CustomBookRepository {

  //分页、条件、高亮
   public List<Book> select(int page,int limit,String c);

}

在repository包下建一个impl包创建一个实现类

package com.baizhi.repository.impl;

import com.baizhi.entity.Book;
import com.baizhi.repository.CustomBookRepository;
import org.elasticsearch.action.search.SearchResponse;
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.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.SearchResultMapper;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Repository //作用：将当前类对象交给spring工厂创建对象
public class CustomBookRepositoryImpl implements CustomBookRepository {

   //elasticsearchTemplate springboot-data-elasticsearch依赖中的一个工具类
   //当依赖提供的方法 extends ElasticsearchRepository 和自定义简单查询方法无法满足需求时，可以使用工具类的操作
   @Autowired
   private ElasticsearchTemplate  elasticsearchTemplate;

   @Override
   public List<Book> select(int page, int limit, String c) {
       //查询策略
       TermQueryBuilder builder = QueryBuilders.termQuery("name", c);
       //高亮
       HighlightBuilder.Field builder1 = new HighlightBuilder.Field("*");


   //综合查询方案
     NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
             .withQuery(builder)
             .withHighlightFields(builder1)
             .withPageable(PageRequest.of(page - 1, limit)) //page的0代表第一页
             .build();

System.out.println(searchQuery);

//queryForPage方法被执行后，自动调用SearchResultMapper接口对象中mapResults方法
//我们在该方法中进一步封装查询结果
AggregatedPage<Book> books = elasticsearchTemplate.queryForPage(searchQuery,
                                                      Book.class,
                                                      new SearchResultMapper() {
@Override
public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse,
                                  Class<T> aClass,
                                  Pageable pageable) {

SearchHits hits = searchResponse.getHits();
List<Book> list = new ArrayList<>();
for (SearchHit hit : hits) {
  Book book = new Book();
  //获取未高亮的查询文档
  Map<String, Object> sourceAsMap = hit.getSourceAsMap();
  //获取高亮的查询文档
  Map<String, HighlightField> highlightFields = hit.getHighlightFields();

  HighlightField name = highlightFields.get("name");
  if (name != null) {
      String s = name.fragments()[0].toString();
      sourceAsMap.put("name", s);
  }
  //从map中获取数据，存储到实体类对象中的对应属性中
  book.setId(Long.parseLong(sourceAsMap.get("id").toString()));
  book.setName(sourceAsMap.get("name").toString());
  book.setAuthor(sourceAsMap.get("author").toString());
  book.setPrice(Double.parseDouble(sourceAsMap.get("price").toString()));
  //将对象添加到list集合中
  list.add(book);
}
return new AggregatedPageImpl<T>((List<T>) list);
}
});

return books.getContent();  //getContent() 获取我们传递给它的list对象
 }
}

然后使用高亮查询调用这个方法就行