Elasticsearch API 8.16.1

1. pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
    <groupId>co.elastic.clients</groupId>
    <artifactId>elasticsearch-java</artifactId>
    <version>8.16.1</version>
    <exclusions>
        <exclusion>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>8.16.1</version>
</dependency>
<dependency>
    <groupId>jakarta.json</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>2.1.3</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.0</version>
</dependency>

2. application.yml

elasticsearch:
  hosts: 192.168.xx.xx
  port: 9200
  scheme: http
  username: elastic
  password: xxxxaaf546512

3. 配置类

import java.util.Arrays;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import lombok.extern.slf4j.Slf4j;

/**
 * Elasticsearch 配置
 * 
 * @author 
 * @date 2024/11/28 星期四
 * @since JDK 11
 */
@Slf4j
@Configuration
public class ElasticsearchConfig {
	@Value("${elasticsearch.hosts}")
	private String hosts;

	@Value("${elasticsearch.port}")
	private int port;

	@Value("${elasticsearch.scheme:http}")
	private String scheme;

	@Value("${elasticsearch.username}")
	private String userName;

	@Value("${elasticsearch.password}")
	private String password;

	@Bean
	public ElasticsearchClient esClient() {
		log.info("初始化 ElasticsearchClient 开始.");

		try {
			HttpHost[] httpHosts = Arrays.stream(hosts.split(",")).filter(StringUtils::isNotBlank)
					.map(e -> new HttpHost(e, port, scheme)).toArray(HttpHost[]::new);
			// 设置用户名和密码
			final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
			credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName, password));

			RestClient restClient = RestClient.builder(httpHosts).setHttpClientConfigCallback(
							httpAsyncClientBuilder -> httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider))
					.build();

			ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

			ElasticsearchClient esClient = new ElasticsearchClient(transport);

			log.info("初始化 ElasticsearchClient 成功.");

			return esClient;
		} catch (Exception e) {
			log.error("初始化 ElasticsearchClient 失败:{}", e.getMessage(), e);
			return null;
		}
	}
}

4. 测试类

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.alibaba.fastjson.JSON;
import com.jeesite.common.io.IOUtils;
import com.jeesite.modules.SmsApplication;
import com.jeesite.modules.common.CommonMethods;
import com.jeesite.modules.common.Constants;
import com.jeesite.modules.sms.dao.ISmsSendRecordDao;
import com.jeesite.modules.sms.entity.SmsSendRecord;
import com.jeesite.modules.sms.entity.es.EsSmsSendRecord;
import com.jeesite.modules.sms.enums.StatusEnum;
import com.jeesite.modules.sms.vo.SmsSendRecordVo;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.SortOrder;
import co.elastic.clients.elasticsearch._types.query_dsl.BoolQuery;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
import co.elastic.clients.elasticsearch.core.BulkRequest;
import co.elastic.clients.elasticsearch.core.BulkResponse;
import co.elastic.clients.elasticsearch.core.GetResponse;
import co.elastic.clients.elasticsearch.core.IndexResponse;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.bulk.BulkResponseItem;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.elasticsearch.core.search.HitsMetadata;
import co.elastic.clients.elasticsearch.core.search.TotalHits;
import co.elastic.clients.util.NamedValue;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SmsApplication.class)
public class TestElasticsearch {

	/*
	 * 参考：https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/getting-started-java.html
	 */

	@Autowired
	private ElasticsearchClient esClient;

	/** 短信发送记录Dao */
	@Autowired
	private ISmsSendRecordDao smsSendRecordDao;

	@Before
	public void setUp() {
	}

	@Test
	public void createIndex() {
		try {
			esClient.indices().create(x -> x.index("test_index"));
			System.out.println("--- 创建索引成功 ---");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

	@Test
	public void insert() {
		try {
			// 短信发送记录
			SmsSendRecord record = new SmsSendRecord();
			record.setId(CommonMethods.getMeUUID());
			record.setSysCode("pms");
			record.setSysName("xx系统");
			record.setFunctions("合同管理");
			record.setPhone("15214587854");
			record.setSmsContent("【测试短信");
			record.setReqTime(System.currentTimeMillis());
			record.setSendTime(new Date());
			record.setSendStatus(1);
			record.setFailMsg("发送成功");
			record.setSmsCount((long) CommonMethods.calcSmsCount(record.getSmsContent(), record.getPhone()));
			record.setStatus(StatusEnum.NORMAL.getCode());
			record.setCreateDate(new Date());
			record.setUpdateDate(new Date());

			IndexResponse response = esClient.index(i -> i.index("test_index").id(record.getId()).document(record));

			System.out.println("--- 新增数据成功 ---");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

	@Test
	public void batchInsert() {
		try {
			// 短信发送记录
			SmsSendRecord record1 = new SmsSendRecord();
			record1.setId(CommonMethods.getMeUUID());
			record1.setSysCode("migrate");
			record1.setSysName("征地移民");
			record1.setFunctions("征地任务");
			record1.setPhone("13500112345");
			record1.setSmsContent("测试短信");
			record1.setReqTime(System.currentTimeMillis());
			record1.setSendTime(new Date());
			record1.setSendStatus(1);
			record1.setFailMsg("发送成功");
			record1.setSmsCount((long) CommonMethods.calcSmsCount(record1.getSmsContent(), record1.getPhone()));
			record1.setStatus(StatusEnum.NORMAL.getCode());
			record1.setCreateDate(new Date());
			record1.setUpdateDate(new Date());

			SmsSendRecord record2 = new SmsSendRecord();
			record2.setId(CommonMethods.getMeUUID());
			record2.setSysCode("largeScreen");
			record2.setSysName("xxx大屏");
			record2.setFunctions("进度");
			record2.setPhone("13500112345");
			record2.setSmsContent("测试短信");
			record2.setReqTime(System.currentTimeMillis());
			record2.setSendTime(new Date());
			record2.setSendStatus(1);
			record2.setFailMsg("发送成功");
			record2.setSmsCount((long) CommonMethods.calcSmsCount(record2.getSmsContent(), record2.getPhone()));
			record2.setStatus(StatusEnum.NORMAL.getCode());
			record2.setCreateDate(new Date());
			record2.setUpdateDate(new Date());

			BulkRequest request = BulkRequest.of(
					b -> b.index("test_index").operations(op -> op.index(i -> i.id(record1.getId()).document(record1)))
							.operations(op -> op.index(i -> i.id(record2.getId()).document(record2))));

			BulkResponse response = esClient.bulk(request);

			System.out.println("--- 批量新增数据成功 ---");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

    @Test
    public void queryTotalCount() {
        try {
            CountRequest request = CountRequest.of(x -> x.index("sms_send_record"));
            CountResponse response = esClient.count(request);
            System.out.println("总数量:" + response.count());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(esClient);
            esClient.shutdown();
        }
    }

	@Test
	public void getById() {
		try {
			// a3357195433a730d48de919d48a3c577a851  db3119c8fc6d330b4101a70a5e879243798a
			String id = "db3119c8fc6d330b4101a70a5e879243798a";

			GetResponse<EsSmsSendRecord> response = esClient.get(g -> g.index("sms_send_record").id(id), EsSmsSendRecord.class);

			if (!response.found()) {
				System.out.println("短信发送记录不存在");
				return;
			}
			EsSmsSendRecord record = response.source();

			System.out.println(JSON.toJSONString(record));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

	@Test
	public void searchAll() {
		try {
			NamedValue<SortOrder> sort = new NamedValue<>("createDate", SortOrder.Desc);

			SearchResponse<SmsSendRecord> searchResp = esClient
					.search(s -> s.index("test_index")
								  .query(q -> q.matchAll(m -> m)) // 搜索全部
								  .sort(srt -> srt.field(fld -> fld.field("sendTime").order(SortOrder.Desc)))
							, SmsSendRecord.class);

			HitsMetadata<SmsSendRecord> hits = searchResp.hits();

			long totalCounnt = hits.total() == null ? 0 : hits.total().value();

			System.out.println("totalCounnt=" + totalCounnt);

			List<SmsSendRecord> list = new ArrayList<>();

			hits.hits().forEach(h -> {
				list.add(h.source());
			});
			System.out.println(JSON.toJSONString(list));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

	@Test
	public void search() {
		try {
			SmsSendRecord params = new SmsSendRecord();
			params.setSysCode("guanyg");
			params.setSysName("管系");
			params.setFunctions("程审");
			params.setPhone("78288");
			// 发送状态（0:失败, 1:成功）
			params.setSendStatus(1);

			String createBeginDate = "2024-11-27";
			String createEndDate = "2024-11-28";

			Query query = this.generateQuery(params, createBeginDate, createEndDate);

			SearchResponse<EsSmsSendRecord> response = esClient
					.search(s -> s.index("sms_send_record")
							.query(q -> q.bool(b -> b.must(query)))
							.sort(srt -> srt.field(fld -> fld.field("sendTime").order(SortOrder.Desc)))
							, EsSmsSendRecord.class);

			TotalHits total = response.hits().total();
			long totalCount = total == null ? 0 : total.value();

			System.out.println("查询总数:" + totalCount);

			List<Hit<EsSmsSendRecord>> hits = response.hits().hits();

			List<EsSmsSendRecord> list = new ArrayList<>();

			hits.forEach(hit -> list.add(hit.source()));

			System.out.println(JSON.toJSONString(list));

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

	@Test
	public void page() {
		/* 分页查询 */
		try {
			int pageNo = 1;
			int pageSize = 2;
			int offset = (pageNo - 1) * pageSize;

			SmsSendRecord params = new SmsSendRecord();

			String createBeginDate = "";
			String createEndDate = "";

			Query query = this.generateQuery(params, createBeginDate, createEndDate);

			// 分页查询
			SearchResponse<SmsSendRecord> response = esClient.search(
					s -> s.index("sms_send_record")
						  .query(q -> q.bool(b -> b.must(query)))
						  .sort(srt -> srt.field(fld -> fld.field("sendTime").order(SortOrder.Desc)))
						  .from(offset).size(pageSize)
					, SmsSendRecord.class);

			TotalHits total = response.hits().total();
			long totalCount = total == null ? 0 : total.value();

			System.out.println("查询总数:" + totalCount);

			List<Hit<SmsSendRecord>> hits = response.hits().hits();

			List<SmsSendRecord> list = new ArrayList<>();

			hits.forEach(hit -> list.add(hit.source()));

			System.out.println(JSON.toJSONString(list));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

	@Test
	public void pgToEs() {
		/* pg数据导入数据到es */
		try {
			long startTime = System.currentTimeMillis();

			SmsSendRecord params = new SmsSendRecord();

			Long totalCount = smsSendRecordDao.queryCount(params);
			totalCount = totalCount == null ? 0L : totalCount;

			if (totalCount == 0) {
				System.out.println("短信发送记录不存在");
				return;
			}
			int pageSize = 50;
			// 总页数
			int totalPage = (int) (totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1);

			log.info("pg数据导入数据到es-开始.总数据量:{}, 总页数:{}", totalCount, totalPage);

			esClient.indices().delete(x -> x.index("sms_send_record"));

			// 当前页
			int currentPage = 1;

			while (currentPage <= totalPage) {
				// 分页查询（pgsql）
				List<SmsSendRecordVo> list = smsSendRecordDao.page(params, pageSize, (currentPage - 1) * pageSize);

				if (CollectionUtils.isEmpty(list)) {
					break;
				}
				// 导入数据到es
				this.savePgDatasToEs(list);

				currentPage = currentPage + 1;
			}
			log.info("pg数据导入数据到es-成功.总数据量:{}, 总耗时 {} 毫秒", totalCount, System.currentTimeMillis() - startTime);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(esClient);
			esClient.shutdown();
		}
	}

	/**
	 * 组装查询条件
	 *
	 * @date 2024-11-28
	 * @param params    短信发送记录
	 * @param beginDate 查询开始日期（yyyy-MM-dd）
	 * @param endDate   查询截止日期（yyyy-MM-dd）
	 * @return Query
	 * @since JDK 11
	 * @author 
	 */
	private Query generateQuery(SmsSendRecord params, String beginDate, String endDate) {
		// 多查询条件 must 可不断添加条件
		BoolQuery.Builder builder = QueryBuilders.bool();

		if (StringUtils.isNotBlank(params.getSysCode())) {
			// 模糊查询（加 .keyword 才能支持多个中文字符）
			builder.must(m -> m.wildcard(ma -> ma.field("sysCode.keyword").wildcard("*" + params.getSysCode() + "*")));
		}
		if (StringUtils.isNotBlank(params.getSysName())) {
			// 模糊查询（加 .keyword 才能支持多个中文字符）
			builder.must(m -> m.wildcard(ma -> ma.field("sysName.keyword").wildcard("*" + params.getSysName() + "*")));
		}
		if (StringUtils.isNotBlank(params.getFunctions())) {
			// 模糊查询（加 .keyword 才能支持多个中文字符）
			builder.must(
					m -> m.wildcard(ma -> ma.field("functions.keyword").wildcard("*" + params.getFunctions() + "*")));
		}
		if (StringUtils.isNotBlank(params.getPhone())) {
			// 模糊查询（加 .keyword 才能支持多个中文字符）
			builder.must(m -> m.wildcard(ma -> ma.field("phone.keyword").wildcard("*" + params.getPhone() + "*")));
		}
		if (params.getSendStatus() != null) {
			builder.must(m -> m.match(ma -> ma.field("sendStatus").query(params.getSendStatus())));
		}
		if (StringUtils.isNotBlank(beginDate)) {
			/* 查询开日期 */
			if (beginDate.length() == 10) {
				beginDate = beginDate.trim() + " 00:00:00";
			}
			/* Date 类型的字段，在 Elasticsearch 中的值是时间戳（如：1731198377322），故查询条件也需要转换成时间戳 */
			long time = 0;

			try {
				time = DateUtil.parseDate(beginDate, "yyyy-MM-dd HH:mm:ss").getTime();
			} catch (Exception e) {
			}
			final long lt = time;
			builder.must(m -> m.range(ma -> ma.number(r -> r.field("createDate").gte(Long.valueOf(lt).doubleValue()))));
		}
		if (StringUtils.isNotBlank(endDate)) {
			/* 查询截止期 */
			if (endDate.length() == 10) {
				endDate = endDate.trim() + " 23:59:59";
			}
			/* Date 类型的字段，在 Elasticsearch 中的值是时间戳（如：1731198377322），故查询条件也需要转换成时间戳 */
			long time = 0;

			try {
				time = DateUtil.parseDate(endDate, "yyyy-MM-dd HH:mm:ss").getTime();
			} catch (Exception e) {
			}
			final long lt = time;

			builder.must(m -> m.range(ma -> ma.number(r -> r.field("createDate").lte(Long.valueOf(lt).doubleValue()))));
		}
		builder.must(m -> m.match(ma -> ma.field("status").query(StatusEnum.NORMAL.getCode())));

		return builder.build()._toQuery();
	}

	/**
	 * pg数据导入数据到es
	 *
	 * @date 2024-11-29
	 * @param list pg数据
	 * @since JDK 11
	 * @author 
	 */
	private void savePgDatasToEs(List<SmsSendRecordVo> list) throws Exception {
		/* 参考：https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/indexing-bulk.html */
		if (CollectionUtils.isEmpty(list)) {
			return;
		}
		BulkRequest.Builder builder = new BulkRequest.Builder();

		for (SmsSendRecordVo recd : list) {
			EsSmsSendRecord esRecord = JsonUtils.parse(JsonUtils.toJSONBytes(recd), EsSmsSendRecord.class);

			builder.operations(op -> op
					.index(idx -> idx
							.index("sms_send_record")
							.id(esRecord.getId())
							.document(esRecord)
					)
			);
		}
		BulkResponse response = esClient.bulk(builder.build());

		if (response.errors()) {
			/* 错误 */
			for (BulkResponseItem item: response.items()) {
				if (item.error() != null) {
					log.error("pg数据导入数据到es-失败:{}", item.error().reason());
				}
			}
		}
	}
}

5. JsonUtils

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

import org.apache.commons.lang3.StringUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;

/**
 * @author 
 * @date 2022/5/29
 * @since JDK 11
 */
public final class JsonUtils {

	private JsonUtils() {
	}

	/**
	 * 根据JSON字符串解析出java对象
	 * <p>
	 * 需要提供java对象类型
	 *
	 * @param text  JSON字符串，不能为<code>NULL</code>
	 * @param clazz java对象类型
	 * @return java对象
	 */
	public static final <T> T parse(String text, Class<T> clazz) {
		return JSON.parseObject(text, clazz);
	}

	/**
	 * 根据字节数组解析出java对象
	 * <p>
	 * 需要提供java对象类型
	 *
	 * @param input 字节数组
	 * @param clazz java对象类型
	 * @return java对象
	 */
	public static final <T> T parse(byte[] input, Class<T> clazz) {
		return JSON.parseObject(input, clazz, new Feature[0]);
	}

	/**
	 * 根据java对象转换成字节数组
	 * <p>
	 * 按照默认方式转换，只输出属性和属性值信息，不加入任何其他类型信息
	 *
	 * @param object java对象
	 * @return 字节数组
	 */
	public static final byte[] toJSONBytes(Object object) {
		return JSON.toJSONBytes(object, new SerializerFeature[0]);
	}

	/**
	 * 获取JSON串中指定的key对应的值
	 *
	 * @param json
	 * @param key
	 * @return String
	 * @author 
	 * @date 2018年11月12日
	 * @since JDK 11
	 */
	public static String getJsonValue(String json, String key) {
		if (StringUtils.isBlank(json) || StringUtils.isBlank(key)) {
			return null;
		}
		JSONObject jsonObj = JSONObject.parseObject(json);
		return jsonObj.getString(key);
	}

	/**
	 * 获取JSON串中指定的key对应的值
	 *
	 * @param json 数组
	 * @param key
	 * @return String
	 * @author 
	 * @date 2018年12月12日
	 * @since JDK 11
	 */
	public static List<String> getJsonArrayValue(String json, String key) {

		if (StringUtils.isBlank(json) || StringUtils.isBlank(key)) {
			return null;
		}

		List<String> list = new ArrayList<>();

		JSONArray jsonArray = JSON.parseArray(json);

		if (jsonArray != null) {

			for (int i = 0; i < jsonArray.size(); i++) {

				JSONObject jsonObj = jsonArray.getJSONObject(i);

				list.add(jsonObj.getString(key));
			}
		}
		return list;
	}

	public static String toJsonStringFormat(Object obj) {
		// 自定义时间格式
		JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

		return JSON.toJSONString(obj, //
				// SerializerFeature.PrettyFormat, // 格式化结果
				SerializerFeature.WriteMapNullValue, // 输出值为null的字段
				SerializerFeature.WriteNullStringAsEmpty, // 字符类型字段如果为null,输出为”“,而非null
				// SerializerFeature.WriteNullNumberAsZero, // 数值字段如果为null,输出为0,而非null
				// SerializerFeature.DisableCircularReferenceDetect, // 消除对同一对象循环引用的问题
				SerializerFeature.WriteNullListAsEmpty, // List字段如果为null,输出为[],而非null
				SerializerFeature.WriteDateUseDateFormat, // 自定义时间格式
				SerializerFeature.DisableCircularReferenceDetect // 消除循环引用
		);
	}
}

6. 实体类

import java.util.Date;

import com.fasterxml.jackson.annotation.JsonFormat;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;


@Data
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = true)
public class SmsSendRecord implements Serializable {

    private static final long serialVersionUID = -2051624697942261462L;

    private String id;

    /** 第三方系统编码（见接口文档） */
	private String sysCode;

	/** 第三方系统名称（见接口文档） */
	private String sysName;

	/** 功能名称 */
	private String functions;

	/** 手机号 */
	private String phone;

	/** 短信内容 */
	private String smsContent;

	/** 第三方发送请求时间戳 */
	private Long reqTime;

	/** 发送时间 */
	// @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
	private Date sendTime;

	/** 发送状态（0:失败, 1:成功） */
	private Integer sendStatus;

	/** 发送失败信息 */
	private String failMsg;

	/** 短信条数（短信内容以67个字符为一条短信） */
	private Long smsCount;

    private String status;

    // @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createDate;

    private String createBy;

    // @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date updateDate;

    private String updateBy;

    private String remarks;
}

import java.io.Serializable;
import java.util.Date;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

/**
 * 【Elasticsearch】短信发送记录 实体类
 * 
 * @author 
 * @date 2024/6/5
 * @since JDK 17
 */
@Data
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = true)
@Document(indexName = "sms_send_record", createIndex = false)
public class EsSmsSendRecord implements Serializable {

	private static final long serialVersionUID = 621657165808034654L;

	/*
    @Field(type=FieldType.Text, analyzer=“ik_max_word”) 表示该字段是一个文本，并作最大程度拆分，默认建立索引
	@Field(type=FieldType.Text,index=false) 表示该字段是一个文本，不建立索引
	@Field(type=FieldType.Date) 表示该字段是一个文本，日期类型，默认不建立索引
	@Field(type=FieldType.Long) 表示该字段是一个长整型，默认建立索引
	@Field(type=FieldType.Keyword) 表示该字段内容是一个文本并作为一个整体不可分，默认建立索引
	@Field(type=FieldType.Float) 表示该字段内容是一个浮点类型并作为一个整体不可分，默认建立索引
	注意：date 、float、long都是不能够被拆分的，并且date是默认不创建索引的。
    */

	/** 主键 */
	@Field(name = "id", type = FieldType.Keyword)
	@Id
	private String id;

	/** 第三方系统编码 */
	@Field(name = "sys_code", type = FieldType.Text)
	private String sysCode;

	/** 第三方系统名称 */
	@Field(name = "sys_name", type = FieldType.Text)
	private String sysName;

	/** 功能名称 */
	@Field(name = "functions", type = FieldType.Text)
	private String functions;

	/** 手机号 */
	@Field(name = "phone", type = FieldType.Text)
	private String phone;

	/** 短信内容 */
	@Field(name = "sms_content", type = FieldType.Text, analyzer = "jieba_index", searchAnalyzer = "jieba_index")
	private String smsContent;

	/** 第三方发送请求时间戳 */
	@Field(name = "req_time", type = FieldType.Long)
	private Long reqTime;

	/** 发送时间 */
	@Field(name = "send_time", type = FieldType.Date)
	private Date sendTime;

	/** 发送状态（0:失败, 1:成功） */
	@Field(name = "send_status", type = FieldType.Integer)
	private Integer sendStatus;

	/** 发送失败信息 */
	@Field(name = "fail_msg", type = FieldType.Text, analyzer = "jieba_index", searchAnalyzer = "jieba_index")
	private String failMsg;

	/** 短信条数（短信内容以67个字符为一条短信） */
	@Field(name = "sms_count", type = FieldType.Long)
	private Long smsCount;

	/** 状态（0:正常, 1:已删除, 2:已停用） */
	@Field(name = "status", type = FieldType.Keyword)
	private String status;

	/** 创建时间 */
	@Field(name = "create_date", type = FieldType.Date)
	private Date createDate;

	/** 创建人 */
	@Field(name = "create_by", type = FieldType.Text)
	private String createBy;

	/** 更新时间 */
	@Field(name = "update_date", type = FieldType.Date)
	private Date updateDate;

	/** 更新人 */
	@Field(name = "update_by", type = FieldType.Text)
	private String updateBy;

	/** 备注 */
	@Field(name = "remarks", type = FieldType.Text)
	private String remarks;
}