Java引入Elasticsearch实现增删改查

  org.elasticsearch.client
  elasticsearch-rest-high-level-client
  7.6.2
  
    
      org.elasticsearch
      elasticsearch
    
  


   org.elasticsearch
   elasticsearch
   7.6.2


  org.elasticsearch.plugin
  delete-by-query
  2.4.6

Es的基本信息的获取和封装

package *.*.common.es.common;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringJoiner;

import org.apache.http.HttpHost;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import *.*.common.config.ConfigGroupFile;
import *.*.common.config.ConfigService;

public class EsConfig {
	@SuppressWarnings("unused")
	private static final Logger logger = LoggerFactory.getLogger(EsConfig.class);

	private static EsConfig config;

	
	private HttpHost[] hosts;

	
	private String username;

	
	private String password;

	// 调优参数

	
	private int connTimeout;

	
	private int socketTimeout;

	
	private int connRequestTimeout;

	
	private int maxConnTotal;

	
	private int maxConnPerRoute;

	
	public static EsConfig getConfig() {
		if (config == null) {
			config = doCreate();
		}
		return config;
	}

	
	private static EsConfig doCreate() {
		EsConfig config = new EsConfig();
		config.hosts = buildHosts();
		
		config.username = ConfigService.getPersionString("elasticsearch.http.username", ConfigGroupFile.getEsConfig());
		config.password = ConfigService.getPersionString("elasticsearch.http.password", ConfigGroupFile.getEsConfig());

		// 超时参数
		config.connTimeout = ConfigService.getInt("crab.elasticsearch.http.conn_timeout", 5000);
		config.socketTimeout = ConfigService.getInt("crab.elasticsearch.http.socket_timeout", 30000);
		config.connRequestTimeout = ConfigService.getInt("crab.elasticsearch.http.conn_request_timeout", 5000);

		// 连接数
		config.maxConnTotal = ConfigService.getInt("crab.elasticsearch.http.max_conn_total", 400);
		config.maxConnPerRoute = ConfigService.getInt("crab.elasticsearch.http.max_conn_per_route", 200);
		return config;
	}

	
	private static HttpHost[] buildHosts() {
		String hosts = ConfigService.getPersionString("elasticsearch.http.hosts", ConfigGroupFile.getEsConfig());
		if (hosts == null) {
			return new HttpHost[0];
		}

		List hostList = new ArrayList<>();
		for (String host : hosts.split(",")) {
			String[] hostPort = host.split(":");
			if (hostPort.length == 1) {
				hostList.add(new HttpHost(hostPort[0])); // 10.1.1.1
			} else if (hostPort.length == 2) {
				hostList.add(new HttpHost(hostPort[0], Integer.parseInt(hostPort[1])));  // 10.1.1.1:9200
			} else if (hostPort.length == 3) {
				hostList.add(new HttpHost(hostPort[1], Integer.parseInt(hostPort[2]), hostPort[0])); // https:10.1.1.1:9200
			}
		}
		return hostList.toArray(new HttpHost[hostList.size()]);
	}

	
	public static HttpHost[] getHosts() {
		return getConfig().hosts;
	}

	
	public static String getUsername() {
		return getConfig().username;
	}

	
	public static String getPassword() {
		return getConfig().password;
	}

	public static int getConnTimeout() {
		return getConfig().connTimeout;
	}

	public static int getSocketTimeout() {
		return getConfig().socketTimeout;
	}

	public static int getConnRequestTimeout() {
		return getConfig().connRequestTimeout;
	}

	public static int getMaxConnTotal() {
		return getConfig().maxConnTotal;
	}

	public static int getMaxConnPerRoute() {
		return getConfig().maxConnPerRoute;
	}

	@Override
	public String toString() {
		StringJoiner sj = new StringJoiner(", ", "{", "}");
		sj.add("hosts:" + Arrays.toString(hosts));
		sj.add("username:" + username);
		sj.add("connTimeout:" + connTimeout);
		sj.add("socketTimeout:" + socketTimeout);
		sj.add("connRequestTimeout:" + connRequestTimeout);
		sj.add("maxConnTotal:" + maxConnTotal);
		sj.add("maxConnPerRoute:" + maxConnPerRoute);
		return sj.toString();
	}
}

package *.*.common.es.common;

import java.io.IOException;

import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.Node;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import *.*.api.error.ServerException;

public class EsClients {
	private static final Logger logger = LoggerFactory.getLogger(EsClients.class);

	private RestHighLevelClient client;

	// 单例
	private static class Singleton {
		public static final EsClients INSTANCE = new EsClients();
		private Singleton() {}
	}

	private EsClients() {
		client = new RestHighLevelClient(createClientBuilder());
	}
	
	public void reBuildEsClients() {
		if (client != null) {
			try {
				client.close();
			} catch (Exception e) {
				logger.debug(e.getMessage(), e);
			}
		}
		client = new RestHighLevelClient(createClientBuilder());
	}
	
	public static RestHighLevelClient getClient(){
		return Singleton.INSTANCE.client;
	}

	
	@FunctionalInterface
	public interface ClientRequest {
		T doRequest(RestHighLevelClient client) throws IOException;
	}
	
	
	public static  T executeRequest(ClientRequest request) {
		try {
			return request.doRequest(Singleton.INSTANCE.client);
		} catch (Exception e) {
			logger.error(e.getMessage());
			String message = e.getMessage();
			if (message != null && message.contains("I/O reactor status: STOPPED")) {
				return reQuery(request);
			}
			throw new ServerException("", e);
		}
	}

	private static  T reQuery(ClientRequest request) {
		logger.warn("we encounter a problem I/O reactor status: STOPPED");

		Singleton.INSTANCE.reBuildEsClients();
		try {
			return request.doRequest(Singleton.INSTANCE.client);
		} catch (Exception e) {
			throw new ServerException("new query", e);
		}
	}

	
	private static RestClientBuilder createClientBuilder() {
		RestClientBuilder builder = RestClient.builder(EsConfig.getHosts());

		// 连接超时时间
		builder.setRequestConfigCallback(requestConfigBuilder -> {
				requestConfigBuilder.setConnectTimeout(EsConfig.getConnTimeout());
				requestConfigBuilder.setSocketTimeout(EsConfig.getSocketTimeout());
				requestConfigBuilder.setConnectionRequestTimeout(EsConfig.getConnRequestTimeout());
				return requestConfigBuilder;
		});

		// 连接信息
		builder.setHttpClientConfigCallback(httpClientBuilder -> {
			httpClientBuilder.setMaxConnTotal(EsConfig.getMaxConnTotal());
			httpClientBuilder.setMaxConnPerRoute(EsConfig.getMaxConnPerRoute());

			final BasicCredentialsProvider provider = new BasicCredentialsProvider();
			provider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(EsConfig.getUsername(), EsConfig.getPassword()));
			return httpClientBuilder.setDefaultCredentialsProvider(provider);
		});

		builder.setFailureListener(new RestClient.FailureListener() {
			@Override
			public void onFailure(Node node) {
				logger.debug("failed to execute on node: {}", node);
			}
		});
		return builder;
	}
}

ES索引的Setting统一设置 ，包括分片信息，数据集，map的字段个数，是否开启大消息忽略

package *.*.common.es.entity;

import *.*.common.config.ConfigService;


public class EsSettingEntity {

	
	private int indexShard = 3;
	
	private int indexReplicas = 2;
	
	private int fieldLength = 5000;//默认5000
	
	private boolean openLowercase = ConfigService.getInstance().isOpenLowercase();
	
	public EsSettingEntity() {
		
	}
	
	public EsSettingEntity(int indexShard, int indexReplicas, boolean openLowercase) {
		this.indexShard = indexShard;
		this.indexReplicas =  indexReplicas;
		this.openLowercase = openLowercase;
	}

	
	public int getIndexShard() {
		return indexShard;
	}

	
	public void setIndexShard(int indexShard) {
		this.indexShard = indexShard;
	}

	
	public int getIndexReplicas() {
		return indexReplicas;
	}

	
	public void setIndexReplicas(int indexReplicas) {
		this.indexReplicas = indexReplicas;
	}

	
	public int getFieldLength() {
		return fieldLength;
	}

	
	public void setFieldLength(int fieldLength) {
		this.fieldLength = fieldLength;
	}

	
	public boolean isOpenLowercase() {
		return openLowercase;
	}

	
	public void setOpenLowercase(boolean openLowercase) {
		this.openLowercase = openLowercase;
	}
	
	
}

ES Setting的初始化公共类 

package *.*.common.es.support;

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

import org.elasticsearch.common.settings.Settings;

import *.*.common.es.entity.EsSettingEntity;


public class EsSetting {
	
	public EsSetting() {
		
	}
	
	
	public static Settings.Builder initSetting(EsSettingEntity entity) {
		Settings.Builder setting = Settings.builder().put("index.number_of_shards", entity.getIndexShard()).put("index.number_of_replicas", entity.getIndexReplicas())
				.put("index.mapping.total_fields.limit", entity.getFieldLength());
		if (entity.isOpenLowercase()) {
			setLowercase(setting);
		}
		return setting;
	}
	
	
	public static Settings.Builder setLowercase(Settings.Builder setting) {
		List filter = new ArrayList<>();
		filter.add("lowercase");
		setting.put("index.analysis.normalizer.lowercase.type",EsActivityMapping.FIELD_TYPE_CUSTOM).putList("index.analysis.normalizer.lowercase.filter", filter);
		return setting;
	}
}

ES查询 数据的基础类

package *.*.common.es.support;

import java.util.List;
import java.util.concurrent.TimeUnit;

import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import *.*.api.error.ClientException;
import *.*.api.error.ServerException;
import *.*.common.config.ConfigService;
import *.*.common.es.common.EsClients;
import *.*.i18n.source.error.I18nErrorMessages;


public class EsDataReader {
	private static final Logger logger = LoggerFactory.getLogger(EsDataReader.class);
	private static boolean UNIT_TEST = ConfigService.getBoolean("crab.unit.test.open", false);

	public EsDataReader() {
	}

	
	public static long count(List index, SearchSourceBuilder sourceBuilder) {
		if (UNIT_TEST) {
			logger.debug("es count has been suppressed for unit test.");
			return 0l;
		}
		
		try {
			CountRequest countReq = new CountRequest(index.toArray(new String[index.size()]), sourceBuilder);
			return EsClients.executeRequest(client -> client.count(countReq, RequestOptions.DEFAULT).getCount());
		} catch (ElasticsearchException e) {
			logger.error("", e);
			throw new ServerException("Failed to execute count: " + e.getMessage(), null);
		}
	}

	
	public static SearchResponse query(List index, SearchSourceBuilder sourceBuilder) {
		if (UNIT_TEST) {
			logger.debug("es query has been suppressed for unit test.");
			return null;
		}
		
		SearchResponse response;
		SearchRequest request;
		try {
			// 设置超时时间
			sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
			request = new SearchRequest(index.toArray(new String[index.size()]), sourceBuilder);
			if (logger.isDebugEnabled()) {
				logger.debug("query with condition: {}", request.source().query());
			}
			response = EsClients.executeRequest(client -> client.search(request, RequestOptions.DEFAULT));
		} catch (ElasticsearchException ee) {
			Throwable cause = ee.getCause();
			if (cause != null && cause.getMessage().contains("Result window is too large")) {
				logger.debug("", ee);
				throw ClientException.create(I18nErrorMessages.ERROR_QUERY_FAIELD_NEED_LIMIT);
			} else {
				logger.error("", ee);
				throw new ServerException("Failed to execute query: " + ee.getMessage(), null);
			}
		}

		if (response.isTimedOut()) {
			throw new ServerException("Query with timeout", null);
		}
		return response;
	}
}

ES的写入数据的基础类 

package *.*.common.es.support;

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

import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import *.*.common.config.ConfigService;
import *.*.common.es.common.EsClients;
import *.*.common.es.common.EsIndexUtils;
import *.*.common.util.ConstantFields;


public class EsDataWriter {
	private static final Logger logger = LoggerFactory.getLogger(EsDataWriter.class);
	private static boolean UNIT_TEST = ConfigService.getBoolean("crab.unit.test.open", false);

	public EsDataWriter() {
	}

	public static boolean sync(String index, List> map) {
		if (UNIT_TEST) {
			logger.debug("es sync has been suppressed for unit test.");
			return true;
		}

		if (StringUtils.isBlank(index) || map == null)
			return false;

		boolean storeIndex = false;
		if (!map.isEmpty()) {
			if (!EsIndexUtils.exists(index)) {
				logger.info("create index:" + index);
				EsIndexUtils.createIndex(index, null, null, EsActivityMapping.buildActivityMapping());
				storeIndex = true;
			}
			EsDataWriter.createObjectsAsync(index, map);
		}
		return storeIndex;
	}

	
	public enum WriteAction {
		ADD, UPDATE, UPSERT, DELETE;
	}

	
	public static void createObjectsAsync(String index, List> objects) {
		if (UNIT_TEST) {
			logger.debug("es create object has been suppressed for unit test.");
			return;
		}
		
		writerObjectsAsync(index, objects, WriteAction.ADD);
	}

	
	public static void updateObjectsAsync(String index, List> objects) {
		if (UNIT_TEST) {
			logger.debug("es update object has been suppressed for unit test.");
			return;
		}
		
		writerObjectsAsync(index, objects, WriteAction.UPDATE);
	}

	
	public static void saveObjectsAsync(String index, List> objects) {
		if (UNIT_TEST) {
			logger.debug("es save object has been suppressed for unit test.");
			return;
		}
		
		writerObjectsAsync(index, objects, WriteAction.UPSERT);
	}

	
	public static void delObjectsAsync(String index, List> objects) {
		if (UNIT_TEST) {
			logger.debug("es delete object has been suppressed for unit test.");
			return;
		}
		
		writerObjectsAsync(index, objects, WriteAction.DELETE);
	}

	
	public static void writerObjectsAsync(String index, List> writeRequests, WriteAction action) {
		if (UNIT_TEST) {
			logger.debug("es write object has been suppressed for unit test.");
			return;
		}
		
		if (writeRequests == null || writeRequests.isEmpty())
			return;

		final BulkRequest request = new BulkRequest();
		for (Map writeRequest : writeRequests) {
			switch (action) {
			case ADD:
				request.add(buildCreateRequest(index, writeRequest));
				break;
			case UPDATE:
				UpdateRequest reqUp = buildUpdateRequest(index, writeRequest, true);
				if (reqUp == null)
					break;
				request.add(reqUp);
				break;
			case UPSERT:
				UpdateRequest reqU = buildUpdateRequest(index, writeRequest, true);
				if (reqU == null)
					break;
				request.add(reqU);
				break;
			case DELETE:
				DeleteRequest reqD = buildDeleteRequest(index, writeRequest.get(ConstantFields.FIELD_ID));
				if (reqD == null)
					break;
				request.add(reqD);
				break;
			}
		}

		EsClients.executeRequest(client -> {
			client.bulkAsync(request, RequestOptions.DEFAULT, new BulkWriteCallback());
			return null;
		});
	}

	
	private static IndexRequest buildCreateRequest(String index, Map map) {
		IndexRequest create = new IndexRequest(index);
		if (map.containsKey(ConstantFields.FIELD_ID)) {
			create.id(map.get(ConstantFields.FIELD_ID).toString());
		}
		create.source(map);
		return create;
	}

	
	private static UpdateRequest buildUpdateRequest(String index, Map map, boolean upsert) {
		if (!map.containsKey(ConstantFields.FIELD_ID)) {
			return null;
		}
		UpdateRequest update = new UpdateRequest(index, map.get(ConstantFields.FIELD_ID).toString()).retryOnConflict(3);
		update.docAsUpsert(upsert);
		update.doc(map);
		return update;
	}

	
	private static DeleteRequest buildDeleteRequest(String index, Object id) {
		if (id == null)
			return null;

		return new DeleteRequest(index, id.toString());
	}

	
	private static class BulkWriteCallback implements ActionListener {

		@Override
		public void onFailure(Exception e) {
			logger.error("Write data with error", e);
		}

		@Override
		public void onResponse(BulkResponse bulkItemResponses) {
			if (bulkItemResponses.hasFailures()) {
				processError(bulkItemResponses.getItems());
			} else {
				logger.debug("Write data successfully, count: {}", bulkItemResponses.getItems().length);
			}
		}

		private void processError(BulkItemResponse[] responses) {
			for (BulkItemResponse response : responses) {
				if (!response.isFailed() || StringUtils.contains(response.getFailureMessage(), "document_missing_exception")) {
					continue;
				}
				logger.error("Write data with error: {}", response.getFailureMessage());
			}
		}
	}
}

ES创建索引，修改别名等公共方法类 

package *.*.common.es.common;

import java.util.Collections;
import java.util.List;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.action.admin.indices.alias.Alias;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.GetAliasesResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.PutIndexTemplateRequest;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.RestStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import *.*.common.config.ConfigService;
import *.*.common.es.entity.EsSettingEntity;
import *.*.common.es.support.EsSetting;
import *.*.common.util.ObjectUtils;
import *.*.api.error.ServerException;

public class EsIndexUtils {
	private static final Logger logger = LoggerFactory.getLogger(EsIndexUtils.class);
	private static boolean UNIT_TEST = ConfigService.getBoolean("crab.unit.test.open", false);
	// 是否删除旧索引
	private static boolean deleteOldIndex = ConfigService.getBoolean("crab.es.delete.old.index", true);
	

	private static final String INDEX_PREX = "*_activity_";

	private EsIndexUtils() {
	}

	
	public static void createIndex(String idxName, String aliasName, Settings.Builder setting, XContentBuilder mappingBuilder) {
		if (UNIT_TEST) {
			logger.debug("es create index has been suppressed for unit test.");
			return;
		}

		//当setting为null时，初始化默认的setting
		if (setting == null) {
			setting = EsSetting.initSetting(new EsSettingEntity());
		}
		
		CreateIndexRequest request = new CreateIndexRequest(idxName);
		request.settings(setting);

		if (aliasName != null) {
			request.alias(new Alias(aliasName));
		}

		if (mappingBuilder != null) {
			request.mapping(mappingBuilder);
		}

		CreateIndexResponse response = EsClients.executeRequest(client -> client.indices().create(request, RequestOptions.DEFAULT));
		if (!response.isAcknowledged()) {
			logger.error("Failed to create index '{}' with alias: {}", idxName, aliasName);
		}
	}

	
	public static void createIndexByTemplate(String idxName) {
		CreateIndexRequest request = new CreateIndexRequest(idxName);
		CreateIndexResponse response = EsClients.executeRequest(client -> client.indices().create(request,
				RequestOptions.DEFAULT));

		if (!response.isAcknowledged()) {
			logger.error("Failed to create index '{}'", idxName);
		}
	}

	
	public static void aliases(String indexAlias, String oldIndexName, String newIndexName) {
		if (UNIT_TEST) {
			logger.debug("es aliases name has been suppressed for unit test.");
			return;
		}

		IndicesAliasesRequest request = new IndicesAliasesRequest();

		// 先移除，再添加
		request.addAliasAction(
				new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.REMOVE).index(oldIndexName).alias(indexAlias));
		request.addAliasAction(
				new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.ADD).index(newIndexName).alias(indexAlias));

		AcknowledgedResponse response = EsClients.executeRequest(client -> client.indices().updateAliases(request, RequestOptions.DEFAULT));
		if (!response.isAcknowledged()) {
			logger.error("Failed to aliases index: {}", indexAlias);
		}
	}
	
	
	public static Set aliases(String indexAlias, String newIndexName, boolean dropOldIndeces) {
		Set oldIndices = Collections.emptySet();
		if (dropOldIndeces) {
			oldIndices = getIndexByAlias(indexAlias);
		}
		if (!oldIndices.isEmpty()) {
			oldIndices.remove(newIndexName); // 保留最新创建的索引
		}
		
		IndicesAliasesRequest request = new IndicesAliasesRequest();

		// 关联新索引
		request.addAliasAction(new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.ADD)
				.index(newIndexName).alias(indexAlias).writeIndex(true)); // 将新增的索引设置为可写
		
		// 删除指定索引
		if (!oldIndices.isEmpty()) {
			request.addAliasAction(new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.REMOVE_INDEX)
					.indices(oldIndices.toArray(new String[oldIndices.size()])));
		}

		AcknowledgedResponse response = EsClients.executeRequest(client -> client.indices().updateAliases(request, RequestOptions.DEFAULT));
		if (!response.isAcknowledged()) {
			logger.error("Failed to aliases index: {}", indexAlias);
			return Collections.emptySet();
		}
		// 删除旧索引
		deleteOldIndexes(oldIndices);
		
		return oldIndices;
	}
	
	private static void deleteOldIndexes(Set oldIndexes) {
		if (ObjectUtils.isNullOrEmpty(oldIndexes) || !deleteOldIndex) {
			return;
		}
		for (String oldIndex : oldIndexes) {
			dropIndex(oldIndex, true);
		}
	}

	
	public static Set getIndexByAlias(String indexAlias) {
		GetAliasesRequest getAliasReq = new GetAliasesRequest();
		getAliasReq.aliases(indexAlias);
		GetAliasesResponse getAliasRsp = EsClients.executeRequest(client -> client.indices().getAlias(getAliasReq, RequestOptions.DEFAULT));
		return getAliasRsp.getAliases().keySet();
	}


	
	public static boolean exists(String indexName) {
		if (UNIT_TEST) {
			logger.debug("es check index has been suppressed for unit test.");
			return false;
		}

		GetIndexRequest getRequest = new GetIndexRequest(indexName);
		return EsClients.executeRequest(client -> client.indices().exists(getRequest, RequestOptions.DEFAULT));
	}

	
	public static void dropIndex(String indexName, boolean ignoreIfNotExists) {
		if (UNIT_TEST) {
			logger.debug("es drop index has been suppressed for unit test.");
			return;
		}

		try {
			DeleteIndexRequest deleteRequest = new DeleteIndexRequest(indexName);
			EsClients.executeRequest(client -> client.indices().delete(deleteRequest, RequestOptions.DEFAULT));
		} catch (ElasticsearchException e) {
			if (ignoreIfNotExists && e.status() == RestStatus.NOT_FOUND) {
				return; // ignore
			}
			logger.error("Failed to drop index: " + indexName, e);
			throw new ServerException("Failed to drop index: " + indexName + ", reason: " + e.getMessage(), null);
		}
	}

	public static String fillIndex(String index) {
		if (StringUtils.isBlank(index))
			return null;

		StringBuffer sb = new StringBuffer(INDEX_PREX);
		if (index.startsWith(INDEX_PREX)) {
			return index;
		}

		return sb.append(index).toString();
	}

	
	public static void createIndexTemplate(String tplName, String idxAliasName, List patterns,
																				 XContentBuilder mappingBuilder) {
		PutIndexTemplateRequest request = new PutIndexTemplateRequest(tplName);
		request.settings(getIndexSettings(idxAliasName)).patterns(patterns);

		if (idxAliasName != null) {
			request.alias(new Alias(idxAliasName));
		}

		if (mappingBuilder != null) {
			request.mapping(mappingBuilder);
		}

		AcknowledgedResponse response = EsClients.executeRequest(client -> client.indices().putTemplate(request,
				RequestOptions.DEFAULT));

		if (!response.isAcknowledged()) {
			logger.error("Failed to create index template'{}' with alias: {}", tplName, idxAliasName);
		}
	}

	
	private static Settings.Builder getIndexSettings(String aliasName) {
		final String paramPrefix = "pacific.es.index.";
		int shards = ConfigService.getInt(paramPrefix + aliasName + ".number_of_shards", 3);
		int replicas = ConfigService.getInt(paramPrefix + aliasName + ".number_of_replicas", 2);
		int fields = ConfigService.getInt(paramPrefix + aliasName + ".total_fields", 5000);
		return Settings.builder().put("index.number_of_shards", shards)
				.put("index.number_of_replicas", replicas).put("index.mapping.total_fields.limit", fields);
	}
}

Elasticsearch索引动态字段基础类

package *.*.common.es.support;

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;

import *.*.common.config.ConfigService;
import *.*.common.util.ConstantFields;
import *.*.api.error.ServerException;


public class EsActivityMapping {
	public static final String FIELD_TYPE_KEYWORD = "keyword";
	public static final String FIELD_TYPE_DATE = "date";
	public static final String FIELD_TYPE_TEXT = "text";
	public static final String FIELD_TYPE_LONG = "long";
	public static final String FIELD_TYPE_OBJECT = "object";
	public static final String FIELD_TYPE_CUSTOM = "custom";
	public static final List NEED_LOWERCASE_TYPE = Stream.of(FIELD_TYPE_KEYWORD, FIELD_TYPE_TEXT).collect(Collectors.toList());
	public static final String CONTENT = "Total-OAO-context-OBO";
	public static final boolean OPEN_LOWERCASE = ConfigService.getInstance().isOpenLowercase();

	private EsActivityMapping() {
	}
	
	public static XContentBuilder buildMapping(Map propertiesMap) {
		try (XContentBuilder builder = XContentFactory.jsonBuilder();) {
			builder.startObject();
			{
				builder.startObject("properties");
				if (propertiesMap != null && !propertiesMap.isEmpty()) {
					for (Entry entry : propertiesMap.entrySet()) {
						buildField(builder, entry.getKey(), entry.getValue());
					}
				}
				builder.endObject();
			}
			return builder.endObject();
		} catch (IOException e) {
			throw new ServerException("Failed to build index ci mapping", e);
		}
	}

	public static XContentBuilder buildCIMapping() {
		try (XContentBuilder builder = XContentFactory.jsonBuilder();) {
			builder.startObject();
			{
				builder.startObject("properties");
				buildField(builder, CONTENT, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.FIELD_ID, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.FIELD_CLASSCODE, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.RES_CIRCLE_FIELD, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.CREATE_TIME, FIELD_TYPE_DATE);
				buildField(builder, ConstantFields.UPDATE_TIME, FIELD_TYPE_DATE);
				buildField(builder, ConstantFields.RES_ATTRVALUES, FIELD_TYPE_OBJECT);
			
				builder.endObject();
			}
			return builder.endObject();
		} catch (IOException e) {
			throw new ServerException("Failed to build index ci mapping", e);
		}
	}
	
	
	public static XContentBuilder buildActivityMapping() {
		try (XContentBuilder builder = XContentFactory.jsonBuilder();) {
			builder.startObject();
			{
				builder.startObject("properties");
				buildField(builder, ConstantFields.ACTIVITY_FIELD_ID, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_CLASSCODE, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_CLASSNAME, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_ACTYPE, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.FIELD_TYPE, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_TIME, FIELD_TYPE_DATE);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_TENANTID, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_VERSION, FIELD_TYPE_LONG);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_CIRCLEID, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.FIELD_USERID, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_USERNAME, FIELD_TYPE_TEXT);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_OPER, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_OPERNAME, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_ENTITYID, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_ENTITYNAME, FIELD_TYPE_TEXT);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_DESC, FIELD_TYPE_TEXT);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_PARENTCINAME, FIELD_TYPE_TEXT);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_TARGETCINAME, FIELD_TYPE_TEXT);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_ITSMINFO, FIELD_TYPE_OBJECT);
				buildField(builder, ConstantFields.ACTIVITY_FIELD_RELATIONNAME, FIELD_TYPE_TEXT);
				buildField(builder, ConstantFields.CI_RECORD_FIELD_SOURCE, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.FIELD_STATE, FIELD_TYPE_KEYWORD);
				buildField(builder, ConstantFields.CI_RECORD_FIELD_AUTO_CLAIM, FIELD_TYPE_KEYWORD);
				builder.endObject();
			}
			return builder.endObject();
		} catch (IOException e) {
			throw new ServerException("Failed to build index mapping", e);
		}
	}

	private static void buildField(XContentBuilder builder, String field, String type) throws IOException {
		builder.startObject(field);
		{
			builder.field("type", type);
			if (OPEN_LOWERCASE && NEED_LOWERCASE_TYPE.contains(type)) {
				builder.field("normalizer", "lowercase");
			}
		}
		builder.endObject();
	}
}

写入数据

	
	@SuppressWarnings({ "unchecked" })
	public void insertDates(List list, CommonTestData testData, boolean syncByAlias) {
		ObjectMapper mapper = new ObjectMapper();
		String id = null;
		StringJoiner content;
		Map testClassMap = testData.getClassMap();
		Map testAttributeMap = testData.getAttrMap();
		if (resClassMap.isEmpty()) {
			return;
		}
		try {
			List> objects = new ArrayList<>();
			for (Test entity : list) {
				TestClass testClass = testClassMap.get(entity.getClassCode());
				if (testClass == null) {
					continue;
				}
				List attrs = new ArrayList<>();
				for (String code : testClass.getAttrCodes()) {
					TestAttribute attr = testAttributeMap.get(code);
					if (attr != null) {
						attrs.add(attr);
					}
				}

				content = new StringJoiner(ElasticsearchUtil.SPLIT_SYMBOL);
				String json = mapper.writeValueAsString(ElasticsearchUtil.converVo(entity, content, testClass, attrs, testData.getDictMap()));
				Map productMap = mapper.readValue(json, Map.class);
				id = productMap.get(TestAttrFieldCodes.BASE_FIELD_ID).toString();
				if (productMap.containsKey(ATTRVALUES)) {
					Map result = new HashMap<>();
					Map attr = (Map) productMap.get(ATTRVALUES);
					for (Map.Entry entry : attr.entrySet()) {
						if (entry.getValue() == null || StringUtils.isBlank(entry.getValue().toString())) {
							continue;
						}
						TestAttribute att = testAttributeMap.get(entry.getKey().toString());

						if (att != null) {
							result.put(att.getType() + SPLIT + entry.getKey(), entry.getValue());
							content.add(String.valueOf(entry.getValue()));
						}

					}
					productMap.put(ATTRVALUES, result);
				}
				productMap.put(ElasticsearchUtil.CONTENT, ElasticsearchUtil.SPLIT_SYMBOL + content.toString() + ElasticsearchUtil.SPLIT_SYMBOL);
				objects.add(productMap);
			}
			if (syncByAlias) {
				EsDataWriter.saveObjectsAsync(ElasticsearchUtil.getIndexAliasName(), objects);
			} else {
				EsDataWriter.saveObjectsAsync(ElasticsearchUtil.getIndexName(), objects);
			}
			
		} catch (JsonParseException e) {
			resData.clearData();
			logger.error("Failed to parse JSON data id= {} , message : {}", id, e);
			throw new ServerException("Failed to parse JSON data" + id, e);
		} catch (JsonMappingException e) {
			resData.clearData();
			logger.error("Failed to parse JSON data id= {} , message : {}", id, e);
			throw new ServerException("Failed to process JSON data" + id, e);
		} catch (IOException e) {
			resData.clearData();
			logger.error("Failed to parse JSON data id= {} , message : {}", id, e);
			throw new ServerException("Failed to execute" + id, e);
		}
	}

删除数据

@Override
	public void delById(String id, String type) {
		try {
			DeleteRequest deleteRequest = new DeleteRequest(ElasticsearchUtil.getIndexAliasName(), id);
			EsClients.getClient().delete(deleteRequest, RequestOptions.DEFAULT);
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

查询数据

public Map getSearchData(String index, String type, String value, boolean isPreciseSearch, Integer page, Integer size) {
		Map result = new HashMap<>();
		Integer from = 0;
		if (page - 1 >= 0) {
			from = (page - 1) * size;
		}
		try {
			if (isPreciseSearch) {
				value = "*" + ElasticsearchUtil.SPLIT_SYMBOL + value.substring(1, value.length() - 1) + ElasticsearchUtil.SPLIT_SYMBOL + "*";
			}

			if (value.length() == 1) {
				value = CommonUtil.replaceRegexChars(value);
			} else {
				value = CommonUtil.replaceRegexChars(value).replace("\*", "*");
			}
			SearchResponse response = this.getResponse(index, type, value, from, size);
			
			long totalRecords = response.getHits().getTotalHits().value;
			List> list = new ArrayList<>();
			SearchHit[] ciHits = response.getHits().getHits();
			CacheContext context = new CacheContext();
			for (int i = 0; i < ciHits.length; i++) {
				String objId = ciHits[i].getId();
				Map map = this.filter(ciHits[i].getSourceAsMap(), objId, context);
				map.put(TestAttrFieldCodes.BASE_FIELD_ID, objId);
				list.add(map);
			}
			context.clear();
			result.put("totalRecords", totalRecords);
			result.put("list", list);
			return result;
		} catch (Exception e) {// NOSONAR 此处增加代码稳定性
			throw new ServerException("Failed to search data", e);
		}
	}

private SearchResponse getResponse(String index, String type, String value, int from, int size) {
		SearchSourceBuilder sb = new SearchSourceBuilder();
		if (ConfigService.getInstance().isEsQueryNeedPointTotalOAOContxtObo()) {
			BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
					.must(QueryBuilders.queryStringQuery("*" + value + "*").defaultField(ElasticsearchUtil.getQueryContent()));
			// 是否开启分词查询
			if (ConfigService.getInstance().isOpenEsParticipleQuery()) {
				queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.matchPhraseQuery(ElasticsearchUtil.getQueryContent(), value));
			}
			queryBuilder.filter(
					QueryBuilders.boolQuery().must(QueryBuilders.termQuery(ResAttrFieldCodes.BASE_FIELD_TENANT, ThreadLocalContext.getTenantId())));
			sb.query(queryBuilder);
		} else {
			BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.queryStringQuery(value + "*")).filter(
					QueryBuilders.boolQuery().must(QueryBuilders.termQuery(ResAttrFieldCodes.BASE_FIELD_TENANT, ThreadLocalContext.getTenantId())));
			sb.query(queryBuilder);
		}

		// 分页信息
		sb.from(from);
		sb.size(size);

		// 是否统计总数
		sb.trackTotalHits(true);
		sb.sort(ConstantFields.UPDATE_TIME, SortOrder.DESC);
		List indexs = new ArrayList<>();
		indexs.add(index);
		return EsDataReader.query(indexs, sb);
	}