Springboot 整合ElasticSearch 常用的插入查询，模糊查询，范围查询

深碍√TFBOYSˉ_ 2023-03-13 06:39 331阅读 0赞

# **前言** #

本来该篇教程就应该写到  
Springboot 整合 ElasticSearch 入门教学必看 [https://blog.csdn.net/qq\_35387940/article/details/104840473][https_blog.csdn.net_qq_35387940_article_details_104840473]

里面的，但是由于考虑篇幅太长了，所以有了该篇教程。

## **那么该篇的内容有什么呢？**  ##

上篇简单提到一句， elasticsearch  提供了elasticsearchTemplate 和ElasticsearchRepository ，这两样里面都提供了非常多的各种各样的操作数据的方法。

那么该篇就是主要教大家使用 ElasticsearchRepository ，

完成我们日常需要使用的：

**1. 单数据插入**

**2.批量数据插入**

**3.单个查询**

**4.查询所有**

**5.删除**

**6.条件查询（范围查询，精确查询，模糊查询）**

ElasticsearchRepository 其实就跟JPA的使用是一样的，而且里面包含的方法非常非常多，我简单做了个图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70][] 分享，不仅是为了他人，更是为了自己。

# **正文** #

不废话我们开始进入实践教程，

这次我们采取 小狗作为例子。

新建实体类，Dog.java：

import lombok.Data;
    import org.springframework.data.elasticsearch.annotations.Document;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/3/12
     * @Description :
     **/
    @Data
    @Document(indexName = "pets", type = "dog")
    public class Dog {
    
        private String id;
    
        private String name;
    
        private Integer age;
    
        private String color;
    }

然后是对接数据层，也就是该篇的使用核心ElasticsearchRepository ， 新建DogRepository.java：

import com.example.elastucsearchdemo.pojo.Dog;
    import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
    import org.springframework.stereotype.Repository;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/3/13
     * @Description :
     **/
    @Repository
    public interface DogRepository extends ElasticsearchRepository<Dog, String> {
    
    }

然后是service和 impl，

新建DogService.java ：

import com.example.elastucsearchdemo.pojo.Dog;
    import java.util.List;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/5/12
     * @Description :
     **/
    public interface DogService {
        /**
         * 删除
         * @param id
         * @return
         */
         boolean deleteDog(String id) ;
    
        /**
         * 插入
         * @param dog
         * @return
         */
         Dog saveDog(Dog dog) ;
    
    
        /**
         * 批量插入
         * @param dogsList
         * @return
         */
         Boolean saveDogAll(List<Dog> dogsList) ;
    
    
        /**
         * 查询所有小狗
         * @return
         */
         List<Dog> findAllDog() ;
    
        /**
         * 查询一只小狗
         * @return
         */
        Dog findOneDog(String id) ;
    
    
    }

新建DogServiceImpl.impl：

import com.example.elastucsearchdemo.pojo.Dog;
    import com.example.elastucsearchdemo.repository.DogRepository;
    import com.example.elastucsearchdemo.service.DogService;
    import org.elasticsearch.index.query.QueryBuilder;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Optional;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/5/12
     * @Description :
     **/
    @Service
    public class DogServiceImpl implements DogService {
        @Autowired
        private DogRepository repository;
    
        public boolean deleteDog(String id) {
            try {
                repository.deleteById(id);
            } catch (Exception ex) {
                ex.printStackTrace();
                return false;
            }
            return true;
        }
    
    
        public Dog saveDog(Dog dog) {
    
            try {
                Dog save = repository.save(dog);
                System.out.println("结果："+save.toString());
                return save;
            } catch (Exception ex) {
                ex.printStackTrace();
                return null;
            }
    
        }
    
    
        public Boolean saveDogAll(List<Dog> dogsList) {
    
            try {
              repository.saveAll(dogsList);
            } catch (Exception ex) {
                ex.printStackTrace();
                return false;
            }
            return true;
        }
    
    
    
    
        /**
         * 查询所有小狗
         * @return
         */
        public List<Dog> findAllDog() {
            List<Dog> list = new ArrayList<>();
            try {
                Iterable<Dog> aIterable = repository.findAll();
                for (Dog Dog : aIterable) {
                    list.add(Dog);
                }
            } catch (Exception ex) {
                ex.printStackTrace();
                return null;
            }
            return list;
        }
    
        /**
         * 查询所有小狗
         * @return
         */
        public Dog findOneDog(String id) {
            Optional<Dog> resu = repository.findById(id);
    
            return  repository.findById(id).get();
        }
    
    
    }

接着我们来写个简单的接口验证一下这些常规crud.

新建DogController.java：

### **单条数据插入：** ###

@PostMapping("addDogTest")
        public void addTest() {
            //插入一只小狗
            Dog dog = new Dog();
            dog.setId("100111");
            dog.setName("TestDog");
            dog.setAge(3);
            dog.setColor("black");
            dogService.saveDog(dog);
        }

调用该接口，可以看到数据成插入：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1][]

### **批量数据插入：** ###

@PostMapping("addListTest")
        public void addTest() {
    
            //插入所有小狗
            List<Dog> dogsList = new ArrayList<>();
            for (int i = 0; i < 5; i++) {
                Dog dogPes = new Dog();
                dogPes.setId(UUID.randomUUID().toString().replace("-", ""));
                dogPes.setName("Alaska-"+getNonceStr(4));
                dogPes.setAge(new Random().nextInt(100));
                dogPes.setColor("red");
                dogsList.add(dogPes);
            }
            dogService.saveDogAll(dogsList);
        }

调用该接口，可以看到数据成插入：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2][]

### **删除：** ###

我们就把这个id为62668f83be6440b493d761dfc2703683的进行删除，

![20200512164827605.png][]

@GetMapping("deleteOne")
        public void deleteOne() {
            dogService.deleteDog("62668f83be6440b493d761dfc2703683");
            
        }

调用下这个接口，可以看到数据已经删掉：

![20200512165203798.png][]

### ** 查找单条数据：** ###

@GetMapping("findTest")
        public void find() {
            //根据ID 查找一只小狗
            Dog oneDog = dogService.findOneDog("91713fd657ee4a059811bfb7df7456d0");
            System.out.println(oneDog.toString());
    
        }

调用下该接口，可以看到数据成功获取：

![20200512165441380.png][]

### **查找所有数据：** ###

@GetMapping("findAll")
        public void find() {
    
            //查找所有小狗
            List<Dog> allDog = dogService.findAllDog();
            System.out.println(allDog.toString());
        }

调用下该接口，可以看到数据成功获取：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3][]

### **修改 ：** ###

可以看到service里面其实没有修改方法，如果用过JPA的小伙伴应该不能理解，因为这里的修改其实可以通过插入（保存）实现，也就是根据id去修改。

可以看到我们最早插入的数据，id为 100111：

![20200512165854539.png][]

我们把里面的age，和name 都修改下，通过插入去修改：

@PostMapping("updateDogTest")
        public void updateDogTest() {
            //插入一只小狗
            Dog dog = new Dog();
            dog.setId("100111");
            dog.setName("update");
            dog.setAge(2);
            dog.setColor("black");
            dogService.saveDog(dog);
        }

调用下该接口，可以看到数据修改成功：

![20200512170141576.png][]

接下来是着重讲下查询，

### **精确查询：** ###

查找 name（字符串）作为字段，值为Alaska-km6u 的数据。

@Autowired
        DogRepository repository;  //为了方便讲解，就直接先这样使用
        @GetMapping("queryTest")
        public void queryTest() {
            QueryBuilder qb0 = QueryBuilders.termQuery("name"+".keyword", "Alaska-km6u");
            QueryBuilder qb = QueryBuilders.boolQuery().must(qb0);
            List<Dog> list=new ArrayList<>();
            Iterable<Dog> aIterable = repository.search(qb);
            for (Dog Dog : aIterable) {
                list.add(Dog);
            }
            System.out.println(list.toString());
        }

调用下该接口：

![20200512171425915.png][]

注意，如果你是要精确查找一条数据，那么就是**termQuery** 。

但是如果你的数据里面不止一只小狗满足条件名字叫Alaska-km6u ，那就需要使用 **termsQuery**。

### **范围查询：** ###

**rangeQuery**

假如我们要查询 age在 12-20岁之间的小狗，

那么就是：

// 闭区间
            QueryBuilder qb1 = QueryBuilders.rangeQuery("age").from("12").to("20");
    
            QueryBuilder qb = QueryBuilders.boolQuery().must(qb1);
            List<Dog> list=new ArrayList<>();
            Iterable<Dog> aIterable = repository.search(qb);
            for (Dog Dog : aIterable) {
                list.add(Dog);
            }
            System.out.println(list.toString());

开区间：

//开区间
                QueryBuilder qb1 = QueryBuilders.rangeQuery("age").from("12", false).to("20", false);

假如需要查询 age小于5岁的小狗，

那么就是：

//小于
            QueryBuilder qb1 = QueryBuilders.rangeQuery("age").lt("5");

如果是要小于等于5：

//小于等于
            QueryBuilder qb1 = QueryBuilders.rangeQuery("age").lte("5");

假如需要查询age大于10岁的小狗，

那么就是：

//大于
            QueryBuilder qb1 = QueryBuilders.rangeQuery("age").gt("10");

如果是要大于等于10：

//大于
            QueryBuilder qb1 = QueryBuilders.rangeQuery("age").gte("10");

范围查询暂时就介绍这些， 上面都是基于单条件进行的查询，其实多条件同时查询也是很常见。

### **组合查询（多条件）：** ###

例如 我需要查询的数据是，age在10到13之间（闭区间），而且因为小狗同名比较多，我需要设置名字不能为 “Halo”的；

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4][]

must： 必须符合的条件

mustNot： 必须不符合的条件

其实还有should： 也就是 OR 的作用

如果想同时符合几个条件，那么就是：

![20200513091212605.png][]

### **模糊查询：** ###

模糊查询这里我推荐使用 **wildcardQuery**，因为支持通配符匹配   
如：查询name 带有 2Ha的数据，支持通配符，所以我们传入  \*2Ha\* ：

特别注意的一点 wildcardQuery后面的参数，一定要是小写匹配，所以可以看到代码里使用了toLowerCase()；  
而且使用的时候尽量避免\*开头，这样能有效节省匹配时间

@GetMapping("findTestLike")
        public List<Dog> findTestLike() {
            QueryBuilder qb1 = QueryBuilders.wildcardQuery("name", "2Ha*".toLowerCase());
    
            List<Dog> list = new ArrayList<>();
            Iterable<Dog> aIterable = repository.search(qb1);
            for (Dog Dog : aIterable) {
                list.add(Dog);
            }
    
            return list;
        }

调用下该接口，可以看到数据成功获取 ：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 5][]

ps：

遇到需要搜索中文的，注意了，如果是想搜索中文，达成类似mysql上面like，那么我们就不需要es自动分词了，那么我们就得指定 type为 keyword ：  
![20210809112328180.png][]

如果是模糊匹配单个字符，可以使用 ？   ，如：

![20200513105605486.png][]

查询结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 6][]

如果不使用通配符的 模糊查询，简单点的可以使用**queryStringQuery** ：

@GetMapping("findTestLike")
        public List<Dog> findTestLike() {
            QueryBuilder qb1 =  QueryBuilders.queryStringQuery("胡").field("name");
            List<Dog> list = new ArrayList<>();
            Iterable<Dog> aIterable = repository.search(qb1);
            for (Dog Dog : aIterable) {
                list.add(Dog);
            }
    
            return list;
        }

查询结果，也是左右模糊匹配的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 7][]

QueryBuilder qb1 =  QueryBuilders.queryStringQuery("yellow").field("color");

查询结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 8][]

如果想查询对多个字段进行模糊查询，怎么弄？

就像：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 9][]

如果是使用通配符进行的查询，可以写成这样：

![20200513101011510.png][]

这样写好像有点奇葩，但是这样才是检索起来数据最全的而且不用考虑分词的，因为有通配符存在。

当然对于多个字段的匹配检索，也是有对应方法的 **multiMatchQuery**,这样 :

QueryBuilder qb1 = QueryBuilders.multiMatchQuery("yellow","name","color","id");
            List<Dog> list = new ArrayList<>();
            Iterable<Dog> aIterable = repository.search(qb1);
            for (Dog Dog : aIterable) {
                list.add(Dog);
            }
    
            return list;

好的，该篇ElasticSearch的一些常规方法使用就介绍到这吧（还有更多其他的搜索方法，想了解的可以自己去学习下。）。

[https_blog.csdn.net_qq_35387940_article_details_104840473]: https://blog.csdn.net/qq_35387940/article/details/104840473
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70]: /images/20230312/8b31e48cbc734aed9c483c1e4b14b5d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1]: /images/20230312/f9a1881c5048462987914d9c6caf6d58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2]: /images/20230312/5e66e90929624dcc9746e70da814355c.png
[20200512164827605.png]: /images/20230312/5effbea7b7e14d509aa204ac32c5e4ae.png
[20200512165203798.png]: /images/20230312/53cd70a2983548de83d7458b2a456e28.png
[20200512165441380.png]: /images/20230312/ec15139c2d694cf499353a7ba92c058e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3]: /images/20230312/cbb3dfc026de49abb76d4c8b558d59fd.png
[20200512165854539.png]: /images/20230312/33abfd895cd84419b5c61821089330e4.png
[20200512170141576.png]: /images/20230312/2fd8dc9b3ce44985a396f4e4c397c498.png
[20200512171425915.png]: /images/20230312/3219e1faf7824b2fa4c19829838bda0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200513091039222.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[20200513091212605.png]: https://img-blog.csdnimg.cn/20200513091212605.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200513092530162.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[20210809112328180.png]: https://img-blog.csdnimg.cn/20210809112328180.png
[20200513105605486.png]: https://img-blog.csdnimg.cn/20200513105605486.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200513105629833.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200513104103445.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2020051310421491.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200513100928487.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[20200513101011510.png]: https://img-blog.csdnimg.cn/20200513101011510.png