在学习了elasticsearch的基本语法和基础功能之后，我们将elasticsearch和springboot进行整合，在实战中使用elasticsearch。 模拟的数据如下： 本篇博客我将对elasticsearch和springboot进行整合，整合
在学习了elasticsearch的基本语法和基础功能之后，我们将elasticsearch和springboot进行整合，在实战中使用elasticsearch。
模拟的数据如下：
本篇博客我将对elasticsearch和springboot进行整合，整合的方法一共有两种，一种是使用Java API，另一种是使用springData-ES，进行整合。
ES使用Java API进行开发，官方已经明确表示在ES 7.0版本中将弃用TransportClient客户端，且在8.0版本中完全移除它。但是它在整合ES方面还是非常的活跃，请各位谨慎使用。
一、进行开发前期的新建项目和添加依赖等准备工作
1. 构建一个springboot项目：
（1）打开IntelliJ IDEA :File-->New-->Project-->
（2）找到spring initializr-->next
（3）创建项目：
（4）选择自己想要的依赖，我们这里只选了web的启动项-->next
（5）创建完成后的项目目录如下：
2.创建所需要的包以及文件：
在项目中新建下图的包以及类，接口：
解释：
controller包用来存放控制器：
- RestfulApiController用来存放javaAPI的控制器方法；
- SpringDataController用来存放SpringData-ES的控制器方法。
entity包用来存放model类：
- Book为开发的实现类。
repository为Elasticsearch存储库（直接访问ES）：
- BookRepository用来存放Book的存储库。
service包用来存放业务类：
- SpringDataService接口；
- SpringDataService的实现类。
3.添加依赖：
（1）打开项目下的pom.xml:
（2）添加依赖：
在pom.xml中添加以下依赖，将你没有的依赖加进来就可以（我使用的springboot版本为2.1.6，elasticsearch为6.4.2）
<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.lcc.springboot</groupId>
<artifactId>elasticsearch</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>elasticsearch</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--项目启动依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--测试依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--elasticsearch依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<!--使用springdata时需要-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-commons</artifactId>
<version>2.1.9.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
前期准备工作完成，下面进入编写代码阶段。
二、使用java API进行项目整合
1.添加ESConfig，配置Elasticsearch：
在项目中新建一个ESConfig用于配置Elasticsearch，添加以下代码：
package com.lcc.springboot.elasticsearch;import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import javax.annotation.PostConstruct;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* @author 李歘歘
* ES配置文件
*/
@Configuration
public class ESConfig {
@Bean
public TransportClient client() throws UnknownHostException {
TransportAddress node = new TransportAddress(
//此处为tcp端口
InetAddress.getByName("localhost"),9300
);
//elasticsearch配置
Settings settings = Settings.builder()
.put("cluster.name","lcc")
.build();
TransportClient client = new PreBuiltTransportClient(settings);
//将地址传递给client，使其在这个地址发起请求
//在集群环境下，可以创建多个node并传递进来
client.addTransportAddress(node);
return client;
}
/**
* 防止netty的bug
*/
@PostConstruct
void init() {
System.setProperty("es.set.netty.runtime.available.processors", "false");
}
}
完成后如下图：
2.编写业务逻辑代码：
在RestfulApiController类上添加控制器注解：
@RestController在RestfulApiController类中添加以下代码实现自动注入：
/**** 自动注入
*/
@Autowired
private TransportClient client;
完成后如下图：
（1）简单的查询--根据Id查询书籍：
在项目启动类中添加以下代码：
/*** 根据Id查询书籍
* @param id
* @return
*/
@GetMapping("/get/book/novel")
@ResponseBody
public ResponseEntity get(@RequestParam(name = "id",defaultValue = "") String id){
//当传进来的id为空时返回404
if (id.isEmpty()){
return new ResponseEntity(HttpStatus.NOT_FOUND);
}
//获得传进来的值以及索引和类型等
GetResponse result = this.client.prepareGet("book","novel",id).get();
//当传进来的id不存在时返回404
if (!result.isExists()) {
return new ResponseEntity(HttpStatus.NOT_FOUND);
}
return new ResponseEntity(result.getSource(), HttpStatus.OK);
}
（2）添加书籍：
在项目启动类中添加以下代码：
/*** 添加书籍
* @param title
* @param author
* @param wordCount
* @param publishDate
* @return
*/
@PostMapping("/add/book/novel")
@ResponseBody
public ResponseEntity add(
@RequestParam(name = "title") String title,
@RequestParam(name = "author") String author,
@RequestParam(name = "word_count") int wordCount,
@RequestParam(name = "publish_date")
//限定日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
Date publishDate ) {
try {
//构建json
XContentBuilder content = XContentFactory.jsonBuilder()
.startObject()
.field("title",title)
.field("author",author)
.field("word_count",wordCount)
.field("publish_date",publishDate.getTime())
.endObject();
//将json传进去并构建
IndexResponse result = this.client.prepareIndex("book","novel")
.setSource(content)
.get();
return new ResponseEntity(result.getId(),HttpStatus.OK);
}catch (IOException e) {
e.printStackTrace();
return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
（3）删除书籍：
在项目启动类中添加以下代码：
/*** 删除书籍
* @param id
* @return
*/
@DeleteMapping("/delete/book/novel")
@ResponseBody
public ResponseEntity delete(@RequestParam(name = "id") String id) {
DeleteResponse result = this.client.prepareDelete("book","novel",id).get();
return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
}
（4）更新书籍：
在项目启动类中添加以下代码：
/*** 更新书籍
* @param id
* @param title
* @param author
* @return
*/
@PutMapping("/update/book/novel")
@ResponseBody
public ResponseEntity update(
@RequestParam(name = "id") String id,
@RequestParam(name = "title", required = false) String title,
@RequestParam(name = "author", required = false) String author ) {
UpdateRequest update = new UpdateRequest("book","novel",id);
try {
XContentBuilder builder = XContentFactory.jsonBuilder()
.startObject();
//如果title和author不为空则传进来
if (title != null) {
builder.field("title",title);
}
if (author != null) {
builder.field("author",author);
}
//builder一定要以endObject()结尾
builder.endObject();
update.doc(builder);
}catch (IOException e) {
e.printStackTrace();
return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
}
try {
//更新文档
UpdateResponse result = this.client.update(update).get();
return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
}catch (Exception e){
e.printStackTrace();
return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
（5）复合查询书籍---检索：
在项目启动类中添加以下代码：
/*** 复合查询书籍---检索
* @param author
* @param title
* @param gtWordCount
* @param ltWordCount
* @return
*/
@PostMapping("/query/book/novel")
@ResponseBody
public ResponseEntity query (
@RequestParam(name = "author", required = false) String author,
@RequestParam(name = "title", required = false) String title,
@RequestParam(name = "gt_word_count", defaultValue = "0") int gtWordCount,
@RequestParam(name = "lt_word_count", required = false ) Integer ltWordCount ){
//构建布尔查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
if (author != null){
boolQuery.must(QueryBuilders.matchQuery("author",author));
}
if (title != null){
boolQuery.must(QueryBuilders.matchQuery("title",title));
}
//构建范围查询
RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("word_count")
.from(gtWordCount);
if (ltWordCount != null && ltWordCount > 0 ) {
rangeQuery.to(ltWordCount);
}
//将rangeQuery和boolQuery用filter结合起来
boolQuery.filter(rangeQuery);
SearchRequestBuilder builder = this.client.prepareSearch("book")
.setTypes("novel")
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setQuery(boolQuery)
.setFrom(0)
.setSize(10);
System.out.println(builder);
//获取返回结果，返回结果是一个hits
SearchResponse response = builder.get();
//创建存放返回结果的list
List<Map<String, Object>> result = new ArrayList<>();
//遍历取出的hits，存入result
for (SearchHit hit : response.getHits()) {
result.add(hit.getSource());
}
return new ResponseEntity(result, HttpStatus.OK);
}
以上分别实现了增删改查的方法；
完整的代码如下：
package com.lcc.springboot.elasticsearch;import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* @author 李歘歘
*/
@SpringBootApplication
@RestController
public class ElasticsearchApplication {
/***
* 自动注入
*/
@Autowired
private TransportClient client;
/**
* 根据Id查询书籍
* @param id
* @return
*/
@GetMapping("/get/book/novel")
@ResponseBody
public ResponseEntity get(@RequestParam(name = "id",defaultValue = "") String id){
//当传进来的id为空时返回404
if (id.isEmpty()){
return new ResponseEntity(HttpStatus.NOT_FOUND);
}
//获得传进来的值以及索引和类型等
GetResponse result = this.client.prepareGet("book","novel",id).get();
//当传进来的id不存在时返回404
if (!result.isExists()) {
return new ResponseEntity(HttpStatus.NOT_FOUND);
}
return new ResponseEntity(result.getSource(), HttpStatus.OK);
}
/**
* 添加书籍
* @param title
* @param author
* @param wordCount
* @param publishDate
* @return
*/
@PostMapping("/add/book/novel")
@ResponseBody
public ResponseEntity add(
@RequestParam(name = "title") String title,
@RequestParam(name = "author") String author,
@RequestParam(name = "word_count") int wordCount,
@RequestParam(name = "publish_date")
//限定日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
Date publishDate ) {
try {
//构建json
XContentBuilder content = XContentFactory.jsonBuilder()
.startObject()
.field("title",title)
.field("author",author)
.field("word_count",wordCount)
.field("publish_date",publishDate.getTime())
.endObject();
//将json传进去并构建
IndexResponse result = this.client.prepareIndex("book","novel")
.setSource(content)
.get();
return new ResponseEntity(result.getId(),HttpStatus.OK);
}catch (IOException e) {
e.printStackTrace();
return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
/**
* 删除书籍
* @param id
* @return
*/
@DeleteMapping("/delete/book/novel")
@ResponseBody
public ResponseEntity delete(@RequestParam(name = "id") String id) {
DeleteResponse result = this.client.prepareDelete("book","novel",id).get();
return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
}
/**
* 更新书籍
* @param id
* @param title
* @param author
* @return
*/
@PutMapping("/update/book/novel")
@ResponseBody
public ResponseEntity update(
@RequestParam(name = "id") String id,
@RequestParam(name = "title", required = false) String title,
@RequestParam(name = "author", required = false) String author ) {
UpdateRequest update = new UpdateRequest("book","novel",id);
try {
XContentBuilder builder = XContentFactory.jsonBuilder()
.startObject();
//如果title和author不为空则传进来
if (title != null) {
builder.field("title",title);
}
if (author != null) {
builder.field("author",author);
}
//builder一定要以endObject()结尾
builder.endObject();
update.doc(builder);
}catch (IOException e) {
e.printStackTrace();
return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
}
try {
//更新文档
UpdateResponse result = this.client.update(update).get();
return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
}catch (Exception e){
e.printStackTrace();
return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
/**
* 复合查询书籍---检索
* @param author
* @param title
* @param gtWordCount
* @param ltWordCount
* @return
*/
@PostMapping("/query/book/novel")
@ResponseBody
public ResponseEntity query (
@RequestParam(name = "author", required = false) String author,
@RequestParam(name = "title", required = false) String title,
@RequestParam(name = "gt_word_count", defaultValue = "0") int gtWordCount,
@RequestParam(name = "lt_word_count", required = false ) Integer ltWordCount ){
//构建布尔查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
if (author != null){
boolQuery.must(QueryBuilders.matchQuery("author",author));
}
if (title != null){
boolQuery.must(QueryBuilders.matchQuery("title",title));
}
//构建范围查询
RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("word_count")
.from(gtWordCount);
if (ltWordCount != null && ltWordCount > 0 ) {
rangeQuery.to(ltWordCount);
}
//将rangeQuery和boolQuery用filter结合起来
boolQuery.filter(rangeQuery);
SearchRequestBuilder builder = this.client.prepareSearch("book")
.setTypes("novel")
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setQuery(boolQuery)
.setFrom(0)
.setSize(10);
System.out.println(builder);
//获取返回结果，返回结果是一个hits
SearchResponse response = builder.get();
//创建存放返回结果的list
List<Map<String, Object>> result = new ArrayList<>();
//遍历取出的hits，存入result
for (SearchHit hit : response.getHits()) {
result.add(hit.getSource());
}
return new ResponseEntity(result, HttpStatus.OK);
}
/**
* 启动方法
* @param args
*/
public static void main(String[] args) {
SpringApplication.run(ElasticsearchApplication.class, args);
}
}
由于java API较为简单，我们就不在service层进行开发了，只对controller进行开发。
3.代码测试：
启动项目，使用postman测试：
（1）根据Id查询书籍：
（2）添加书籍：
head中展示：
（3）删除书籍：
head中展示：
（4）更新书籍：
head展示：
（5）复合查询书籍---检索：
实例一：
实例二：
实例三：
三、springData-ES
1.在ESConfig，中添加以下代码，用于指定Elasticsearch存储库：
@EnableElasticsearchRepositories(basePackages = "com.lcc.springboot.elasticsearch.repository")如下图：
2.在创建好的实体类Book.java中编写以下：
package com.lcc.springboot.elasticsearch.entity;import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import java.util.Date;
@Document(indexName = "book",type = "novel")
public class Book {
@Id
private String id;
private String title;
private String author;
private Integer word_count;
private Date publish_date;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public Integer getWord_count() {
return word_count;
}
public void setWord_count(Integer word_count) {
this.word_count = word_count;
}
public Date getPublish_date() {
return publish_date;
}
public void setPublish_date(Date publish_date) {
this.publish_date = publish_date;
}
}
解释：
Spring Data通过注解来声明字段的映射属性，有下面的三个注解：
@Document 作用在类，标记实体类为文档对象，一般有两个属性
indexName：对应索引库名称
type：对应在索引库中的类型
shards：分片数量，默认5
replicas：副本数量，默认1
@Id 作用在成员变量，标记一个字段作为id主键
@Field 作用在成员变量，标记为文档的字段，并指定字段映射属性：
type：字段类型，是枚举：FieldType，可以是text、long、short、date、integer、object等
text：存储数据时候，会自动分词，并生成索引
keyword：存储数据时候，不会分词建立索引
Numerical：数值类型，分两类
基本数据类型：long、interger、short、byte、double、float、half_float
浮点数的高精度类型：scaled_float
需要指定一个精度因子，比如10或100。elasticsearch会把真实值乘以这个因子后存储，取出时再还原。
Date：日期类型
elasticsearch可以对日期格式化为字符串存储，但是建议我们存储为毫秒值，存储为long，节省空间。
index：是否索引，布尔类型，默认是true
store：是否存储，布尔类型，默认是false
analyzer：分词器名称，这里的ik_max_word即使用ik分词器
3.编写Controller如下，分别编写模糊查询，按照Id查询，添加，删除，更新操作：
package com.lcc.springboot.elasticsearch.controller;import com.lcc.springboot.elasticsearch.entity.Book;
import com.lcc.springboot.elasticsearch.service.SpringDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/springBoot")
public class SpringDataController {
@Autowired
private SpringDataService springDataService;
/**
* 查询包含title字段的书
* @param title
* @return
*/
@PostMapping("/book/novel/findByTitle")
public List<Book> findByTitle(@RequestParam(name = "title",required = false) String title) {
List<Book> bookList = springDataService.findByTitle(title);
return bookList;
}
/**
* 根据Id查询
* @param id
* @return
*/
@GetMapping("/book/novel/queryBookById")
public Book queryBookById(String id) {
Book book = springDataService.queryBookById(id);
return book;
}
/**
* 添加类型
* @param book
* @return
*/
@PostMapping("/add/book/novel")
public String add(Book book) {
String info = springDataService.add(book);
return info;
}
/**
* 删除
* @param id
* @return
*/
@DeleteMapping("/delete/book/novel")
public String delete(String id) {
String info = springDataService.delete(id);
return info;
}
/**
* 更新（本质上就是添加）
* @param book
* @return
*/
@PutMapping("/update/book/novel")
public String update(Book book){
String info = springDataService.update(book);
return info;
}
}
4.编写业务逻辑service层：
（1）SpringDataService:
package com.lcc.springboot.elasticsearch.service;import com.lcc.springboot.elasticsearch.entity.Book;
import java.util.List;
public interface SpringDataService {
/**
* 查询包含title字段的书
* @param title
* @return
*/
List<Book> findByTitle(String title);
/**
* 添加类型
* @param book
* @return
*/
String add(Book book);
/**
* 删除
* @param id
* @return
*/
String delete(String id);
/**
* 根据Id查询
* @param id
* @return
*/
Book queryBookById(String id);
/**
* 更新
* @param book
* @return
*/
String update(Book book);
}
（2）.SpringDataServiceImpl：
package com.lcc.springboot.elasticsearch.service.Impl;import com.lcc.springboot.elasticsearch.entity.Book;
import com.lcc.springboot.elasticsearch.repository.BookRepository;
import com.lcc.springboot.elasticsearch.service.SpringDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class SpringDataServiceImpl implements SpringDataService {
@Autowired
private BookRepository bookRepository;
/**
* 查询包含title字段的书
* @param title
* @return
*/
@Override
public List<Book> findByTitle(String title) {
/**
* 这个方法已经springdata未装，自己编写
*/
List<Book> bookList = bookRepository.findByTitle(title);
return bookList;
}
/**
* 根据Id查询
* @param id
* @return
*/
@Override
public Book queryBookById(String id) {
// Book book = bookRepository.queryBookById(id);
Book book = bookRepository.findById(id).get();
return book;
}
/**
* 添加
* @param book
* @return
*/
@Override
public String add(Book book){
/**
* 这个方法已经被springdata封装，不必自己编写
*/
bookRepository.save(book);
return "success";
}
/**
* 删除
* @param id
* @return
*/
@Override
public String delete(String id) {
Book book = new Book();
book.setId(id);
/**
* 这个方法已经被springdata封装，不必自己编写
*/
bookRepository.delete(book);
return "success";
}
/**
* 更新
* @param book
* @return
*/
@Override
public String update(Book book) {
// Book book1 = bookRepository.queryBookById(book.getId());
Book book1 = bookRepository.findById(book.getId()).get();
//当传进来的值为空时不变
if (book.getAuthor()!=null)
book1.setAuthor(book.getAuthor());
if (book.getPublish_date()!=null)
book1.setPublish_date(book.getPublish_date());
if (book.getTitle()!=null)
book1.setTitle(book.getTitle());
if (book.getWord_count()!=null)
book1.setWord_count(book.getWord_count());
bookRepository.save(book1);
return "success";
}
}
5.编写ES存储类BookRepository:
package com.lcc.springboot.elasticsearch.repository;import com.lcc.springboot.elasticsearch.entity.Book;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface BookRepository extends ElasticsearchRepository<Book, String> {
/**
* 查询包含title字段的书
* @param title
* @return
*/
List<Book> findByTitle(String title);
/**
* 根据Id查询
* @param id
* @return
*/
Book queryBookById(String id);
}
解释：
很多的方法已经被springdata封装（上述的save，delete，findById等），不必自己编写，在根据Id进行查询时应注意springboot的版本，在springboot 2.x以后，根据id查询一条数据，就不能再使用findone方法了，变成了findbyid。上述代码时使用springboot2.1.6，使用findbyid方法。若你的项目是使用springboot2.x一下使用findone(id)，即可。更多的了解请参考博客
Spring Data 的另一个强大功能，是根据方法名称自动实现功能。比如上面的findByTitle方法，它知道你是根据title查询，然后自动帮你完成，无需写实现类，只要写出接口就行。方法名称要符合一定的约定，如下：
6.代码测试：
启动项目，使用postman测试：
（1）根据Id查询：
（2）根据标题模糊查询：
（3）添加一个新的文档：
head显示：
（4）更新：
head显示：
（5）删除：
以上便是全部的elasticsearch整合springBoot实战过程，还是建议大家使用springData-ES，毕竟我们要学习最先进的东西，官方也会更重视新的东西。
在我的github上有完整的代码可以参考，如有不妥之处请留言，地址请参考：
Github地址