esspark写入es es写入数据

一、前言

使用ES构建搜索引擎时需要经常对文档进行操作，除了简单的单条文档操作，有时还需要进行批量操作。我们这章主要学习ES文档的增删改的操作，由于涉及到的代码量会比较多，所以分为3篇文章分别说明文档的这个三个操作。那么我们对文档操作的学习除了在kibana客户端之外，还会涉及到java的highLevelClient相应的操作代码。那么话不多说，我们直接开始下面的学习、

二、写入文档

2.1、单条写入文档

在ES中写入文档的请求的类型是POST，其请求形式如下：

POST /${index_name}/_doc/${_id}
{
    #写入的文档数据
}

上面的_id就是ES中的文档_id,这种请求方式是用户直接定义_id值，不使用ES自动生成的_id，请求的数据体即为写入的文档数据，格式是JSON格式。例如，在目标索引中写如下面的数据：

POST /hotel/_doc/001
{
    "name":"miss酒店1",   
    "city":"厦门",
    "price":"1145.14"
}

ES返回的结果如下：

由以上结果可知，向hotel索引中写入文档成功。另外，ES在返回结果中还会显示文档的版本，这里因为文档刚刚建立，所以当前值为1.

当然，用户也可以不指定文档_id,该_id值将由ES自动生成，其请求形式如下：

POST /${index_name}/_doc
{
    #写入的文档数据
}

例如，写入上面的文档时不指定文档_id,请求的DSL如下：

在Java高级REST客户端中，单条写入文档需要创建IndexRequest对象并设置对应的索引和_id字段名称，执行时调用客户端的Index()方法并把IndexRequest对象传入即可。index()方法返回IndexResponse对象，通过该对象可以获取当前请求的索引名称、文档_id和版本等。下面的代码演示了向索引中添加单条文档的方法：

首先我们需要一个Hotel实体类,

package com.mbw.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Hotel {
	private String id;    //对应文档_id
	private String index; //对应索引名称
	private Float score;  //对应文档得分
	private Long version; //对应文档的版本号
	private String title; //对应索引中的title
	private String city;  //对应索引中的city
	private Double price; //对应索引中的price
}

这个实体类和前面文章讲解ES客户端那篇是一致的，包括HighLevelClient的建立等代码，这里就不做赘述了，详情大家可以回头看ES客户端的文章 然后我们建立一个ESCreateDocService,并且注入HighLevelClient:

@Service
@Slf4j
public class EsCreateDocService {
    @Autowired
	private RestHighLevelClient client;
}

那么对于单条插入文档，在Java高级REST客户端中，需要创建IndexRequest对象并设置对应的索引和_id字段名称，然后将dataMap(大家可以想像成需要创建输入的数据体)设置进IndexRequest,接着执行时调用客户端的index()方法并把IndexRequest对象传入即可，index()方法返回IndexResponse对象，通过该对象可以获取当前请求的索引名称，文档_id和版本等。下面的代码演示了向索引中添加单条文档的方法。

public Map<String, Object> singleIndexDoc(Map<String, Object> dataMap, String indexName, String indexId) throws IOException {
		IndexRequest indexRequest = new IndexRequest(indexName).id(indexId).source(dataMap);
		IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);//执行写入
		String index = indexResponse.getIndex(); //获取索引名
		String id = indexResponse.getId();  //获取文档ID
		long version = indexResponse.getVersion();  //获取文档版本
		HashMap<String, Object> resultMap = new HashMap<>();
		resultMap.put("index", index);
		resultMap.put("id", id);
		resultMap.put("version", version);
		return resultMap;
	}

然后我们创建一个controller，调用service层的方法即可，那这里之所以输入的参数传hotel，是为了不让前台输入复杂的map类型的json串，将这个json转map的操作交给后台进行。大家当然也可以将传参直接改为service层那样的传参，只不过由于参数涉及到Map,那么只能传json,表单是传不了Map类型的，所以大家一定要把service的三个参数全部放进一个类里，然后通过@RequestBody包装。

@RestController
@Slf4j
public class ESCreateController {
    @PostMapping("/create/doc")
	public FoundationResponse<Map<String, Object>> getResult(@RequestBody Hotel hotel) {
		if (hotel == null || CharSequenceUtil.isBlank(hotel.getIndex())) {
			return FoundationResponse.error(100, "参数错误");
		}
		HashMap<String, Object> dataMap = new HashMap<>();
		dataMap.put("title", hotel.getTitle());
		dataMap.put("city", hotel.getCity());
		dataMap.put("price", hotel.getPrice());
		try {
			Map<String, Object> resultMap = esCreateDocService.singleIndexDoc(dataMap, hotel.getIndex(), hotel.getId());
			return FoundationResponse.success(resultMap);
		} catch (IOException e) {
			log.warn("创建文档发生异常，原因为:{}", e.getMessage());
			return FoundationResponse.error(100, e.getMessage());
		} catch (Exception e) {
			log.error("服务发生异常，原因为:{}", e.getMessage());
			return FoundationResponse.error(100, e.getMessage());
		}
	}
}

接着到postman里验证一下：

那么这里还需要拓展一个命令，它同样也可以创建文档：

POST /${index_name}/_create/${_id}
{
    #写入的文档数据
}

乍一看这个更像创建文档的命令，确实，它可以创建文档，但是它相较于_doc的创建有一种限制，比如我现在使用_doc创建一条_id已存在的记录：

POST /hotel_5/_doc/019
{
    "name":"miss酒店1",   
    "city":"厦门",
    "price":"1145.14"
}

执行后结果如下图所示，发现创建成功，但是创建不如说成是修改，也就是_doc不仅仅可以创建新的文档，它可以在_id已存在的文档基础上进行修改

但是如果换成_create呢？

POST /hotel_5/_create/019
{
    "name":"miss酒店1",   
    "city":"厦门",
    "price":"1145.14"
}

执行结果如下图：发现版本冲突，也就是版本已经大于1了，说明这个文档已经存在了，那么_create命令就会失败，这是和_doc命令的区别！

2.2、批量写入文档

在ES中批量写入文档的请求类型是POST，其请求类型如下：

POST /_bulk    //批量请求
{"index":{"_index":"${index_name}","_id":"${_id}"}}  //指定批量写入的请求
{...}
{"index":{"_index":"${index_name}","_id":"${_id}"}}  //设定写入的文档内容
{...}
{"index":{"_index":"${index_name}","_id":"${_id}"}}
{...}

请求体的第一行表示写入的第一条文档对应的元数据，其中，Index_name表示写入的目标索引，即写入的是哪个索引的哪个文档，第2行表示数据体，第3行表示写入的第二条文档对应的元数据，第4行表示数据体。以此类推，在一次请求里可以写入对条数据。记住，批量操作每一行代表的格式是固定的，不能不如你第一行的内容加个换行符，这样会报错，并且批量操作不允许存在换行符。下面将向hotel_order索引中批量写入3条酒店入住记录数据。

POST /_bulk
{"index":{"_index":"hotel_order","_id":"001"}}
{"username":"Mike JorDan"}
{"index":{"_index":"hotel_order","_id":"002"}}
{"username":"Tom JorDan"}
{"index":{"_index":"hotel_order","_id":"003"}}
{"username":"Kobi JorDan"}

如果你再插入的时候不指定_id,那么同前面的新增文档，_id由ES自动生成。

在实际使用过程中需要批量写入的文档比较多，有时甚至上千条或者上万条，这时如果使用Kibana的请求页面就很不方便了，一般使用Linux系统中的curl命令或者postman（Body选择binary）进行数据的批量写入。它们均支持上传文件，用户可以将批量写入的JSON数据保存到文件中，然后使用curl命令进行提交,这里我们以postman为例。

首先通过ES客户端需要进行授权，那么同之前学习Spring Security类似，我们可以通过postman中的Authorization中的Basic Auth进行授权登陆：

然后点击Body中的binary上传需要批量写入的数据的JSON文件，例如本例的bulk_doc.json:

文件内容如下：

{"index":{"_index":"hotel_order","_id":"001"}}
{"username":"Mike JorDan"}
{"index":{"_index":"hotel_order","_id":"002"}}
{"username":"Tom JorDan"}
{"index":{"_index":"hotel_order","_id":"003"}}
{"username":"Kobi JorDan"}

请求后，发现批量上传成功：

2.3、highLevelClient批量写入文档

在Java高级REST客户端中，批量写入文档需要创建BulkRequest对象并设置对应的索引名称。对于多条预写入的文档，可构建多个IndexRequest对象并调用BulkRequest方法添加这些IndexRequest对象，执行时调用客户端的bulk()方法并把BulkRequest传入即可。bulk()方法返回BulkResponse对象，通过该对象可以获取当前请求的状态。
那么我们为了能够解耦实体类，所以需要创建一个HotelDocRequest类用来封装需要上传的属性，代码如下：

package com.mbw.pojo;

import java.util.List;
import java.util.Map;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class HotelDocRequest {
	private Hotel hotel;
	private String indexName;
	private Long indexId;
	private String docIdKey;
	private List<Hotel> hotelList;
	private List<Map<String,Object>> recordMapList;
}

然后是service层代码：

public String bulkIndexDoc(HotelDocRequest hotelDocRequest) {
		String indexName = hotelDocRequest.getIndexName();
		if (CharSequenceUtil.isBlank(indexName)) {
			throw new SearchException("索引名不能为空");
		}
		BulkRequest bulkRequest = new BulkRequest(indexName);
		List<Map<String, Object>> recordMapList = hotelDocRequest.getRecordMapList();
		for (Map<String, Object> dataMap : recordMapList) {
			//这个docIdKey代表map中值为docId对应的键值
			String docIdKey = hotelDocRequest.getDocIdKey();
			String docId = dataMap.get(docIdKey).toString();
			//这里必须每次都使用new IndexRequest(index,type),不然只会插入最后一条记录（这样插入不会覆盖已经存在的Id，也就是不能更新）
			IndexRequest indexRequest = new IndexRequest().id(docId).source(dataMap);
			//添加IndexRequest
			bulkRequest.add(indexRequest);
		}
		bulkRequest.timeout(TimeValue.timeValueSeconds(6));   //设置超时时间
		BulkResponse bulkResponse;
		try {
			bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
			if (bulkResponse.hasFailures()) {
				return "失败，原因:" + bulkResponse.buildFailureMessage();
			} else {
				return "成功";
			}
		} catch (IOException e) {
			throw new SearchException("搜索错误");
		}
	}

然后controller,在controller层我们将前端传入的hotelList转化为recordMap,这样避免了前端传入map的复杂传入，只需要写入需要上传的数据即可，类似前面的单条插入的操作：

@PostMapping("/bulk/create/doc")
	public FoundationResponse<String> bulkIndexDoc(@RequestBody HotelDocRequest hotelDocRequest){
		List<Hotel> hotelList = hotelDocRequest.getHotelList();
		if(CollUtil.isEmpty(hotelList)){
			return FoundationResponse.error(100,"无可插入的有效文档");
		}
		//这里之所以转化是因为json输入List<Map<k,v>>这个结构非常复杂，所以由后端这边做一次转化，这样前台只需要输入List<Hotel>的json
		ArrayList<Map<String, Object>> recordListMap = new ArrayList<>();
		hotelList.forEach(hotel -> {
			HashMap<String, Object> dataMap = new HashMap<>();
			//这里对比之前的插入单条文档，需要多加入一个id
			dataMap.put("id", hotel.getId());
			dataMap.put("title", hotel.getTitle());
			dataMap.put("city", hotel.getCity());
			dataMap.put("price", hotel.getPrice());
			recordListMap.add(dataMap);
		});
		hotelDocRequest.setRecordMapList(recordListMap);
		String s = esCreateDocService.bulkIndexDoc(hotelDocRequest);
		return FoundationResponse.success(s);
	}

然后重启通过postman调用该接口，body中只需要输入hotelList即可：

{
    "hotelList": [
        {
            "id": "017",
            "title": "可莉酒店1",
            "city": "上海",
            "price": 648
        },
        {
            "id": "018",
            "title": "可莉酒店2",
            "city": "上海",
            "price": 648
        }
    ],
    "docIdKey":"id",
    "indexName":"hotel"
}

发现批量写入成功。