ElasticSearch - ElasticsearchTemplate方法 - 《JAVA》

term查询
match查询
模糊查询
范围查询及排序
字符串查询
布尔查询

// 如果不通过脚本操作，可以先创建索引库
elasticsearchTemplate.createIndex(Goods.class)；
// 如果不通过脚本操作，指定映射
elasticsearchTemplate.putMapping(Goods.class);
//批量添加数据
elasticsearchTemplate.bulkIndex(queries);

matchAll查询

#应用场景：当查询列表的页面初始化时，没有任何查询条件
脚本查询
#GET 索引库名称/_search，默认展示10条数据
GET goods/_search
{
    "query": {
      "match_all": {}
  }
}
#GET 索引库名称/_search 
GET goods/_doc/_search
{
        "query": {
      "match_all": {}
  },
  "from": 0,#从哪一条开始
  "size": 100#显示多少条
}

代码实现

   /*
    * 匹配全部查询
    * */
    @Test
    public void matchAllTest(){
        //构建查询条件
        //使用的是matchAll查询条件: QueryBuilders.matchAllQuery()
        SearchQuery query = new NativeSearchQuery(QueryBuilders.matchAllQuery());
        /**
         * 分页条件: setPageable,需要的参数-Pageable,
         *Pageable打开有四个实现方法——AbstractPageRequest,PageRequest,QPageRequest,Unpaged.
         *前三个方法都需要两个参数 - int page,int size ;
         *当我们要进行分页查询时, 调用setPageable方法时,需要准备int page,int size参数即可.
        */
        PageRequest pageRequest = PageRequest.of(0, 20);
        query.setPageable(pageRequest);
        //执行查询,获取运行结果
        List<Goods> goods = elasticsearchTemplate.queryForList(query, Goods.class);
        for (Goods good : goods) {
            System.out.println(good);
        }
    }

term查询


#应用场景：不想对搜索关键字进行分词，搜索的结果更加精确。
GET goods/_search
{
  "query": {
    "term": {
      "title": {
        "value": "老人手机"
      }
    }
  }
}

代码实现

  /*
    * term查询
    * */
    @Test
    public void termTest(){
        //构造查询条件
        NativeSearchQuery query = new NativeSearchQuery(QueryBuilders.termQuery("title", "老人手机"));
        query.setPageable(PageRequest.of(0,20));
        //执行查询
        List<Goods> goods = elasticsearchTemplate.queryForList(query, Goods.class);
        for (Goods good : goods) {
            System.out.println(good);
        }
        /**
         *执行搜索可以发现结果为空，为何？
         * term搜索是将**搜索关键字的整个内容作为
         * 词条去倒排索引中进行词条的等值匹配**。
         * 如果倒排索引中并没有分出"老人手机"这个词，
         * 就搜索不到。我们可以通过ES提供的接口看看某字符串按某分词器分出的效果：
         * */
    }

match查询

#脚本查询
GET goods/_search
{
    "query": {
      "match": {
        "title": "老人手机"
    }
  }
}

代码查询

    /*
    * match查询
    * */
    @Test
    public void matchTest() {
        //构造查询条件
        NativeSearchQuery query = new NativeSearchQuery(QueryBuilders.matchQuery("title", "老人手机").operator(Operator.AND));
        query.setPageable(PageRequest.of(0, 20));
        //执行查询
        List<Goods> goods = elasticsearchTemplate.queryForList(query, Goods.class);
        for (Goods good : goods) {
            System.out.println(good);
        }
    }

模糊查询


# 模糊匹配索引库中以华开头的词条，注意不要在华前面使用通配符，否则就和mysql数据库一样，索引失效了
GET goods/_search
{
  "query": {
    "wildcard": {
      "title": {
        "value": "华*"
      }
    }
  }
}

代码实现

    /*
    * wildcard查询
    * */
    @Test
    public void wildcardTest(){
        //构建查询条件
        NativeSearchQuery query = new NativeSearchQuery(QueryBuilders.wildcardQuery("title", "华*"));
        query.setPageable(PageRequest.of(0,20));
        //执行查询
        AggregatedPage<Goods> goods =elasticsearchTemplate.queryForPage(query, Goods.class);
        //获取总页数
        int totalPages = goods.getTotalPages();
        System.out.println(totalPages);
        //当前页
        int number = goods.getNumber()+1;
        System.out.println(number);
        //每页显示数
        int numberOfElements = goods.getNumberOfElements();
        System.out.println(numberOfElements);
        //总条数
        long totalElements = goods.getTotalElements();
        System.out.println(totalElements);
        //文档数据
        List<Goods> content = goods.getContent();
        for (Goods goods1 : content) {
            System.out.println(goods1);
        }
    }

范围查询及排序

# 价格大于等于2000，小于等于3000
# gte: >=   lte:<=   gt:>   lt:<
GET goods/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 2000,
        "lte": 3000
      }
    }
  }
}
#排序
GET goods/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 2000,
        "lte": 3000
      }
    }
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

代码实现

   /*
    * range查询
    * */
    @Test
    public void rangeTest(){
        //构造查询条件
        NativeSearchQuery query = new NativeSearchQuery(QueryBuilders.rangeQuery("price").gte(2000).lte(3000));
        //设置分页字段
        query.setPageable(PageRequest.of(0,20));
        //设置排序字段
        query.addSort(new Sort(Sort.Direction.DESC,"price"));
        //执行查询
        AggregatedPage<Goods> goods = elasticsearchTemplate.queryForPage(query, Goods.class);
        //总页数
        System.out.println(goods.getTotalPages());
        //当前页
        System.out.println(goods.getNumber()+1);
        //每页显示数
        System.out.println(goods.getNumberOfElements());
        //总条数
        System.out.println(goods.getTotalElements());
        //文档数据
        List<Goods> content = goods.getContent();
        for (Goods goods1 : content) {
            System.out.println(goods1);
        }
    }

字符串查询

#不指定字段： 全文搜索
GET goods/_search
{
  "query": {
    "query_string": {
      "query": "华为手机"
    }
  }
}

#指定字段
GET goods/_search
{
    "query": {
      "query_string": {
        "fields"： ["title","brand"],
        "query": "华为手机"
    }
  }
}

代码实现

  /*
    *字符串查询
    * */
    @Test
    public void stringTest(){
        //构造查询条件
        NativeSearchQuery query = new NativeSearchQuery(QueryBuilders.queryStringQuery("华为手机").field("title").field("brand"));
        //设置分页
        query.setPageable(PageRequest.of(0,20));
        //设置排序
        query.addSort(new Sort(Sort.Direction.DESC,"price"));
        // 执行查询，获取查询结果
        AggregatedPage<Goods> page = elasticsearchTemplate.queryForPage(query, Goods.class);

        // 总页数
        System.out.println("总页数 = " + page.getTotalPages());

        // 当前页
        System.out.println("当前页 = " + (page.getNumber() + 1));

        // 每页显示数
        System.out.println("每页显示数 = " + page.getNumberOfElements());

        // 总条数
        System.out.println("总条数 = " + page.getTotalElements());

        // 文档数据
        List<Goods> goodsList = page.getContent();

        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }

布尔查询

语法

must(and):条件必须成立
must_not(not): 条件必须不成立 ，必须和must或filter连接起来使用
should(or):条件可以成立
filter: 条件必须成立，性能比must高（不会计算得分）

#查询品牌为华为，并且title包含手机的手机
GET goods/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
            "brand": {
              "value": "华为"
            }
          }
        },
        {
          "match": {
            "title": "手机"
          }
        }
      ]
    }
  }

}

//构建查询条件