springboot中使用ElasticSearch的详细教程

新建项目

新建一个springboot项目springboot_es用于本次与elasticsearch的整合，如下图

引入依赖

修改我们的pom.xml，加入spring-boot-starter-data-elasticsearch

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-data-elasticsearch</artifactid>
</dependency>

编写配置文件

由于elasticsearch从7.x版本开始淡化transportclient甚至于在8.x版本中遗弃，所以spring data elasticsearch推荐我们使用rest客户端resthinglevelclient（端口号使用9200）以及接口elasticsearchrespositoy。

resthighlevelclient 更强大，更灵活，但是不能友好的操作对象
elasticsearchrepository 对象操作友好

首先我们编写配置文件如下

/**
 * elasticsearch rest client config
 * @author christy
 * @date 2021/4/29 19:40
 **/
@configuration
public class elasticsearchrestclientconfig extends abstractelasticsearchconfiguration{
    
  	@override
    @bean
    public resthighlevelclient elasticsearchclient() {
        final clientconfiguration clientconfiguration = clientconfiguration.builder()
                .connectedto("192.168.8.101:9200")
                .build();
        return restclients.create(clientconfiguration).rest();
    }

}

springboot操作es

resthighlevelclient方式

有了上面的rest client，我们就可以在其他的地方注入该客户端对elasticsearch进行操作。我们新建一个测试文件，使用客户端对elasticsearch进行基本的操作

1.注入restclient

/**
 * elasticsearch rest client操作
 *
 * resthighlevelclient 更强大，更灵活，但是不能友好的操作对象
 * elasticsearchrepository 对象操作友好
 *
 * 我们使用rest client 主要测试文档的操作
 * @author christy
 * @date 2021/4/29 19:51
 **/
@springboottest
public class testrestclient {
    // 复杂查询使用：比如高亮查询
    @autowired
    private resthighlevelclient resthighlevelclient;
}

2.插入一条文档

/**
 * 新增一条文档
 * @author christy
 * @date 2021/4/29 20:17
 */
@test
public void testadd() throws ioexception {
    /**
      * 向es中的索引christy下的type类型中添加一天文档
      */
    indexrequest indexrequest = new indexrequest("christy","user","11");
    indexrequest.source("{\"name\":\"齐天大圣孙悟空\",\"age\":685,\"bir\":\"1685-01-01\",\"introduce\":\"花果山水帘洞美猴王齐天大圣孙悟空是也！\"," +
                        "\"address\":\"花果山\"}", xcontenttype.json);
    indexresponse indexresponse = resthighlevelclient.index(indexrequest, requestoptions.default);
    system.out.println(indexresponse.status());
}

我们可以看到文档插入成功，我们去kibana中查询该条文档

完全没有问题的。

3.删除一条文档

/**
 * 删除一条文档
 * @author christy
 * @date 2021/4/29 20:18
 */
@test
public void deletedoc() throws ioexception {
    // 我们把特朗普删除了
    deleterequest deleterequest = new deleterequest("christy","user","rybng3kbrz-sn-2f3viu");
    deleteresponse deleteresponse = resthighlevelclient.delete(deleterequest, requestoptions.default);
    system.out.println(deleteresponse.status());
  }
}

4.更新一条文档

/**
 * 更新一条文档
 * @author christy
 * @date 2021/4/29 20:19
 */
@test
public void updatedoc() throws ioexception {
    updaterequest updaterequest = new updaterequest("christy","user","p4atg3kbrz-sn-2fmfjj");
    updaterequest.doc("{\"name\":\"调皮捣蛋的hardy\"}",xcontenttype.json);
    updateresponse updateresponse = resthighlevelclient.update(updaterequest, requestoptions.default);
    system.out.println(updateresponse.status());
}

5.批量更新文档

/**
 * 批量更新
 * @author christy
 * @date 2021/4/29 20:42
 */
@test
public void bulkupdate() throws ioexception {
    bulkrequest bulkrequest = new bulkrequest();
    // 添加
    indexrequest indexrequest = new indexrequest("christy","user","13");
    indexrequest.source("{\"name\":\"天蓬元帅猪八戒\",\"age\":985,\"bir\":\"1685-01-01\",\"introduce\":\"天蓬元帅猪八戒因调戏嫦娥被贬下凡\",\"address\":\"高老庄\"}", xcontenttype.json);
    bulkrequest.add(indexrequest);

    // 删除
    deleterequest deleterequest01 = new deleterequest("christy","user","pyatg3kbrz-sn-2fmfjj");
    deleterequest deleterequest02 = new deleterequest("christy","user","uhtyghkbexavqsl4f9lj");
    deleterequest deleterequest03 = new deleterequest("christy","user","c8zcghkb5kgtrutelye_");
    bulkrequest.add(deleterequest01);
    bulkrequest.add(deleterequest02);
    bulkrequest.add(deleterequest03);

    // 修改
    updaterequest updaterequest = new updaterequest("christy","user","10");
    updaterequest.doc("{\"name\":\"炼石补天的女娲\"}",xcontenttype.json);
    bulkrequest.add(updaterequest);

    bulkresponse bulkresponse = resthighlevelclient.bulk(bulkrequest, requestoptions.default);
    bulkitemresponse[] items = bulkresponse.getitems();
    for (bulkitemresponse item : items) {
      system.out.println(item.status());
    }
}

在kibana中查询结果

6.查询文档

@test
public void testsearch() throws ioexception {
    //创建搜索对象
    searchrequest searchrequest = new searchrequest("christy");
    //搜索构建对象
    searchsourcebuilder searchsourcebuilder = new searchsourcebuilder();

    searchsourcebuilder.query(querybuilders.matchallquery())//执行查询条件
      .from(0)//起始条数
      .size(10)//每页展示记录
      .postfilter(querybuilders.matchallquery()) //过滤条件
      .sort("age", sortorder.desc);//排序

    //创建搜索请求
    searchrequest.types("user").source(searchsourcebuilder);

    searchresponse searchresponse = resthighlevelclient.search(searchrequest, requestoptions.default);

    system.out.println("符合条件的文档总数: "+searchresponse.gethits().gettotalhits());
    system.out.println("符合条件的文档最大得分: "+searchresponse.gethits().getmaxscore());
    searchhit[] hits = searchresponse.gethits().gethits();
    for (searchhit hit : hits) {
      system.out.println(hit.getsourceasmap());
    }
}

elasticsearchrepository方式

1.准备工作

elasticsearchrepository方式主要通过注解和对接口实现的方式来实现es的操作，我们在实体类上通过注解配置es索引的映射关系后，当实现了elasticsearchrepository接口的类第一次操作es进行插入文档的时候，es会自动生成所需要的一切。但是该种方式无法实现高亮查询，想要实现高亮查询只能使用resthighlevelclient

开始之前我们需要熟悉一下接口方式为我们提供的注解，以及编写一些基础的类

1.清空es数据

2.了解注解

@document: 代表一个文档记录

indexname: 用来指定索引名称

type: 用来指定索引类型

@id: 用来将对象中id和es中_id映射

@field: 用来指定es中的字段对应mapping

type: 用来指定es中存储类型

analyzer: 用来指定使用哪种分词器

3.新建实体类

/**
 * 用在类上作用:将emp的对象映射成es中一条json格式文档
 * indexname: 用来指定这个对象的转为json文档存入那个索引中 要求:es服务器中之前不能存在此索引名
 * type     : 用来指定在当前这个索引下创建的类型名称
 *
 * @author christy
 * @date 2021/4/29 21:22
 */
@data
@document(indexname = "christy",type = "user")
public class user {
    @id //用来将对象中id属性与文档中_id 一一对应
    private string id;

    // 用在属性上 代表mapping中一个属性 一个字段 type:属性 用来指定字段类型 analyzer:指定分词器
    @field(type = fieldtype.text,analyzer = "ik_max_word")
    private string name;

    @field(type = fieldtype.integer)
    private integer age;

    @field(type = fieldtype.date)
    @jsonformat(pattern = "yyyy-mm-dd")
    private date bir;

    @field(type = fieldtype.text,analyzer = "ik_max_word")
    private string content;

    @field(type = fieldtype.text,analyzer = "ik_max_word")
    private string address;
}

4.userrepository

/**
 * @author christy
 * @date 2021/4/29 21:23
 **/
public interface 
  extends elasticsearchrepository<user,string> {
}

5.testuserrepository

/**
 * @author christy
 * @date 2021/4/29 21:51
 **/
@springboottest
public class testuserrepository {
    @autowired
    private userrepository userrepository;

}

2.保存文档

@test
public void testsaveandupdate(){
  user user = new user();
  // id初识为空，此操作为新增
  user.setid(uuid.randomuuid().tostring());
  user.setname("唐三藏");
  user.setbir(new date());
  user.setintroduce("西方世界如来佛祖大弟子金蝉子转世，十世修行的好人，得道高僧！");
  user.setaddress("大唐白马寺");
  userrepository.save(user);
}

3.修改文档

@test
public void testsaveandupdate(){
    user user = new user();
  	// 根据id修改信息
    user.setid("1666eb47-0bbf-468b-ab45-07758c741461");
    user.setname("唐三藏");
    user.setbir(new date());
    user.setintroduce("俗家姓陈,状元之后。西方世界如来佛祖大弟子金蝉子转世，十世修行的好人，得道高僧！");
    user.setaddress("大唐白马寺");
    userrepository.save(user);
}

4.删除文档

repository接口默认提供了4种删除方式，我们演示根据id进行删除

@test
public void deletedoc(){
  	userrepository.deletebyid("1666eb47-0bbf-468b-ab45-07758c741461");
}

5.检索一条记录

@test
public void testfindone(){
    optional<user> optional = userrepository.findbyid("1666eb47-0bbf-468b-ab45-07758c741461");
    system.out.println(optional.get());
}

6.查询所有

@test
public void testfindall(){
    iterable<user> all = userrepository.findall();
    all.foreach(user-> system.out.println(user));
}

7.排序

@test
public void testfindallsort(){
    iterable<user> all = userrepository.findall(sort.by(sort.order.asc("age")));
    all.foreach(user-> system.out.println(user));
}

8.分页

@test
public void testfindpage(){
    //pagerequest.of 参数1: 当前页-1
    page<user> search = userrepository.search(querybuilders.matchallquery(), pagerequest.of(1, 1));
    search.foreach(user-> system.out.println(user));
}

9.自定义查询

先给大家看一个表，是不是很晕_(¦3」∠)_

keyword	sample	elasticsearch query string
`and`	`findbynameandprice`	`{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}`
`or`	`findbynameorprice`	`{"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}`
`is`	`findbyname`	`{"bool" : {"must" : {"field" : {"name" : "?"}}}}`
`not`	`findbynamenot`	`{"bool" : {"must_not" : {"field" : {"name" : "?"}}}}`
`between`	`findbypricebetween`	`{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}`
`lessthanequal`	`findbypricelessthan`	`{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}`
`greaterthanequal`	`findbypricegreaterthan`	`{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}`
`before`	`findbypricebefore`	`{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}`
`after`	`findbypriceafter`	`{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}`
`like`	`findbynamelike`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}`
`startingwith`	`findbynamestartingwith`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}`
`endingwith`	`findbynameendingwith`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "*?","analyze_wildcard" : true}}}}}`
`contains/containing`	`findbynamecontaining`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "?","analyze_wildcard" : true}}}}}`
`in`	`findbynamein` `(collection<string>names)`	`{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}`
`notin`	`findbynamenotin` `(collection<string>names)`	`{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}}`
`near`	`findbystorenear`	`not supported yet !`
`true`	`findbyavailabletrue`	`{"bool" : {"must" : {"field" : {"available" : true}}}}`
`false`	`findbyavailablefalse`	`{"bool" : {"must" : {"field" : {"available" : false}}}}`
`orderby`	`findbyavailable` `trueorderbynamedesc`	`{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}}`

这个表格看起来复杂，实际上也不简单，但是确实很牛逼。我们只要按照上面的定义在接口中定义相应的方法，无须写实现就可实现我们想要的功能

举个例子，上面有个findbyname是下面这样定义的

假如我们现在有个需求需要按照名字查询用户，我们可以在userrepository中定义一个方法，如下

// 根据姓名查询
list<user> findbyname(string name);

系统提供的查询方法中findby是一个固定写法，像上面我们定义的方法findbyname，其中name是我们实体类中的属性名，这个必须对应上。也就是说这个findbyname不仅仅局限于name，还可以findbyaddress、findbyage等等；

现在就拿findbyname来讲，我们要查询名字叫唐三藏的用户

@test
public void testfindbyname(){
    list<user> userlist = userrepository.findbyname("唐三藏");
    userlist.foreach(user-> system.out.println(user));
}

其实就是框架底层直接使用下面的命令帮我们实现的查询

get /christy/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "name":"?"
          }
        }
      ]
    }
  }
}

10.高亮查询

我们上面说了，elasticsearchrepository实现不了高亮查询，想要实现高亮查询还是需要使用resthighlevelclient方式。最后我们使用rest clientl实现一次高亮查询

@test
public void testhighlightquery() throws ioexception, parseexception {
    // 创建搜索请求
    searchrequest searchrequest = new searchrequest("christy");
    // 创建搜索对象
    searchsourcebuilder searchsourcebuilder = new searchsourcebuilder();
    searchsourcebuilder.query(querybuilders.termquery("introduce", "唐僧"))    // 设置查询条件
      .from(0)    // 起始条数(当前页-1)*size的值
      .size(10)   // 每页展示条数
      .sort("age", sortorder.desc)    // 排序
      .highlighter(new highlightbuilder().field("*").requirefieldmatch(false).pretags("<span style='color:red;'>").posttags("</span>"));  // 设置高亮
    searchrequest.types("user").source(searchsourcebuilder);

    searchresponse searchresponse = resthighlevelclient.search(searchrequest, requestoptions.default);

    searchhit[] hits = searchresponse.gethits().gethits();
    list<user> userlist = new arraylist<>();
    for (searchhit hit : hits) {
      map<string, object> sourceasmap = hit.getsourceasmap();

      user user = new user();
      user.setid(hit.getid());
      user.setage(integer.parseint(sourceasmap.get("age").tostring()));
      user.setbir(new simpledateformat("yyyy-mm-dd").parse(sourceasmap.get("bir").tostring()));
      user.setintroduce(sourceasmap.get("introduce").tostring());
      user.setname(sourceasmap.get("name").tostring());
      user.setaddress(sourceasmap.get("address").tostring());

      map<string, highlightfield> highlightfields = hit.gethighlightfields();
      if(highlightfields.containskey("name")){
        user.setname(highlightfields.get("name").fragments()[0].tostring());
      }

      if(highlightfields.containskey("introduce")){
        user.setintroduce(highlightfields.get("introduce").fragments()[0].tostring());
      }

      if(highlightfields.containskey("address")){
        user.setaddress(highlightfields.get("address").fragments()[0].tostring());
      }

      userlist.add(user);
    }

    userlist.foreach(user -> system.out.println(user));
}

到此这篇关于elasticsearch在springboot中使用的详细教程的文章就介绍到这了,更多相关springboot使用elasticsearch内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！

黄山市民网：https://www.huangshanshimin.com/