当前位置：首页 > news >正文

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

news 来源：原创 2024/5/3 12:53:52

前言

本来该篇教程就应该写到
Springboot 整合 ElasticSearch 入门教学必看 https://blog.csdn.net/qq_35387940/article/details/104840473

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

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

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

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

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

1. 单数据插入

2.批量数据插入

3.单个查询

4.查询所有

5.删除

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

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

正文

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

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

新建实体类，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：

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.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @Author : JCccc
 * @CreateTime : 2020/5/12
 * @Description :
 **/
@RestController
public class DogController {
    @Autowired
    DogService dogService;

    public static String getNonceStr(int length) {

        //生成随机字符串

        String str = "zxcvbnmlkjhgfdsaqwertyuiopQWERTYUIOPASDFGHJKLZXCVBNM1234567890";

        Random random = new Random();

        StringBuffer randomStr = new StringBuffer();

        // 设置生成字符串的长度，用于循环

        for (int i = 0; i < length; ++i) {
            //从62个的数字或字母中选择

            int number = random.nextInt(62);

            //将产生的数字通过length次承载到sb中

            randomStr.append(str.charAt(number));
        }

        //将承载的字符转换成字符串

        return randomStr.toString();
    }

}

单条数据插入：

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

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

批量数据插入：

    @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);
    }

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

删除：

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

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

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

查找单条数据：

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

    }

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

查找所有数据：

    @GetMapping("findAll")
    public void find() {

        //查找所有小狗
        List<Dog> allDog = dogService.findAllDog();
        System.out.println(allDog.toString());
    }

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

修改：

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

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

我们把里面的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);
    }

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

接下来是着重讲下查询，

精确查询：

查找 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());
    }

调用下该接口：

注意，如果你是要精确查找一条数据，那么就是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”的；

must：必须符合的条件

mustNot：必须不符合的条件

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

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

模糊查询：

模糊查询这里我推荐使用 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;
    }

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

ps：

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

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

查询结果：

如果不使用通配符的模糊查询，简单点的可以使用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;
    }

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

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

查询结果：

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

就像：

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

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

当然对于多个字段的匹配检索，也是有对应方法的 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的一些常规方法使用就介绍到这吧（还有更多其他的搜索方法，想了解的可以自己去学习下。）。