ES搜索(ElasticSearch)(三) 创建索引

最新推荐文章于 2024-04-27 09:48:32 发布
最新推荐文章于 2024-04-27 09:48:32 发布
阅读量418 收藏 1
点赞数
分类专栏： Java 文章标签： elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YLJ_CSDN/article/details/118521788
版权

采用Java的方式创建ElasticSearch的index、settings、mapping

settings可采用XContentType.JSON也可以采用settingsJson的方式

mapping可以采用数据库Model的方式根据自定义规则映射成ES的数据类型

package com.demo.plugin;

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.elasticsearch.action.admin.indices.alias.Alias;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.client.IndicesClient;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.Requests;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetMappingsRequest;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.compress.CompressedXContent;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentType;

import com.jfinal.plugin.activerecord.Table;
import com.jfinal.plugin.activerecord.TableMapping;

@SuppressWarnings("all")
public class IniIndex {

	private RestHighLevelClient restHighLevelClient = ElasticSearchPlugin.getHighLevelClient();
	
	private RequestOptions options = RequestOptions.DEFAULT;
	
	private static final Map<String, String> MAPPINGS = new HashMap<>();
	
	/**
     * settings处理
     * @throws IOException 
     * indexName 类名_版本号   test_v1.0
     * 别名统一 	类名_alias
     */
    public void settings(String indexName) throws IOException {
    	CreateIndexRequest params = new CreateIndexRequest(indexName); 
    	params.alias(new Alias(indexName+"_alias"));
    	
    	/*params.settings("     {\n" +
						"        \"number_of_shards\" : 1,\n" +
						"        \"number_of_replicas\" : 0,\n" +
						"	\"analysis\": {\n" +
						"    	\"analyzer\": {\n" +
						"      		\"rebuilt_thai\": {\n" +
						"       	 \"tokenizer\": \"thai\"\n" +
						"      		}\n" +
						"   	}\n" +
						"  	}\n" +
						"}", XContentType.JSON);*/
    	params.settings(" {\n" +
    					"  \"number_of_shards\" : 1,\n" +
    					"   \"number_of_replicas\" : 0,\n" +
    					"	 \"analysis\": {\n" +
    					"    	\"analyzer\": {\n" +
    					"      		\"icu_analyzer\": {\n" +
    					"       	 \"tokenizer\": \"icu_tokenizer\",\n" +
    					"        	  \"filter\": [\n" +
    					"         		 \"lowercase\",\n" +
    					"          		 \"decimal_digit\"\n" +
    					"        		]\n" +
    					"      		}\n" +
    					"   	}\n" +
    					"  	}\n" +
    					"}", XContentType.JSON);
    	/*params.settings(
    			"     {\n" +
    					"        \"number_of_shards\" : 1,\n" +
    					"        \"number_of_replicas\" : 0,\n" +
    					"	\"analysis\": {\n" +
    					"    	\"analyzer\": {\n" +
    					"      		\"ik_analyzer\": {\n" +
    					"       	 \"tokenizer\": \"ik_max_word\",\n" +
    					"        	  \"filter\": [\n" +
    					"         		 \"lowercase\",\n" +
    					"          		 \"decimal_digit\"\n" +
    					"        		]\n" +
    					"      		}\n" +
    					"   	}\n" +
    					"  	}\n" +
    					"}", XContentType.JSON);*/
    	
    	/*params.settings("{\n" +
				"        \"number_of_shards\" : 1,\n" +
				"        \"number_of_replicas\" : 0,\n" +
				"		\"analysis\": {\n" +
				"    		\"tokenizer\": {\n" + 
				"     			 \"ik_max_word\": {\n" +
				"        	  	\"type\": \"pattern\",\n" +
				"       	   	\"pattern\": \"[ .,*,~,|,!,?,\\/,。,，,-,+,=,,]\"\n" +
				"      		 	}\n" +
				"    	 	},\n" +
				"    		\"analyzer\": {\n" +
				"      			\"ik_analyzer\": {\n" +
				"       	 	\"tokenizer\": \"ik_max_word\",\n" +
				"        	  	\"filter\": [\n" +
				"         			 \"lowercase\",\n" +
				"          			 \"decimal_digit\"\n" +
				"        			]\n" +
				"      			}\n" +
				"   		}\n" +
				"  		}\n" +
				"	}", XContentType.JSON);*/
    	
    	restHighLevelClient.indices().create(params, options);
    }
	/**
	 * 初始化索引
	 * 
	 * @param indexName			索引名称
	 * @param indexNameAlia		索引别名
	 * @param settingsJson		settings数据
	 * @param mappingJson		mapping数据
	 * @return
	 */
	public static boolean iniIndex(String indexName,String indexNameAlia,String settingsJson,String mappingJson){
		// 判断索引是否存在
        boolean result = isIndexExists(indexName);
		if(result){
			log.error("索引已存在: "+indexName);
			return false;
		}
		try {
			CreateIndexRequest params = new CreateIndexRequest(indexName); 
	    	params.alias(new Alias(indexNameAlia));
	    	params.settings(settingsJson, XContentType.JSON);
	    	params.mapping(mappingJson, XContentType.JSON);
			restHighLevelClient.indices().create(params, options);
		} catch (IOException e) {
			//e.printStackTrace();
			log.error("索引: "+indexName+",初始化异常:"+ e);
			return false;
		}
		return true;
	}    

    /**
     * Mapping处理
     *
     * @param obj			model类
     * @param indexName		索引名
     * @param analyzerList	需要分词的字段
     * @param objType			对象类型
     * @throws IOException 
     */
    public void mapping(Object obj,String indexName,List<String> analyzerList,int objType) throws IOException {
    	String type = obj.getClass().getSimpleName().toLowerCase();
    	GetMappingsRequest request = new GetMappingsRequest();
    	if (!MAPPINGS.containsKey(type)) {
    		synchronized (ElasticSearchPlugin.class) {
    			createIndex(indexName);
    			//获取所有的Mapping
                //ImmutableOpenMap<String, MappingMetaData> mappings = client.admin().cluster().prepareState().execute()
                //       .actionGet().getState().getMetaData().getIndices().get(clusterName).getMappings();
                //MappingMetaData mmd = mappings.get(type);
    			Map<String, MappingMetaData> mappings = restHighLevelClient.indices().getMapping(request, options).mappings();
    			MappingMetaData mmd = mappings.get("type");
    			if (null == mmd) {
    				createMapping(obj,indexName,analyzerList,objType);
    			} else {
    				CompressedXContent xContent = mappings.get(type).source();
    				if (xContent == null) {
    					createMapping(obj,indexName,analyzerList,objType);
    				} else {
    					String mapping = xContent.toString();
    					MAPPINGS.put(type, mapping);
    				}
    			}
    		}
    	}
    }
 
    /**
     * 创建Mapping
     *
     */
	public void createMapping(Object obj,String indexName,List<String> analyzerList,int objType) {
        String type = obj.getClass().getSimpleName().toLowerCase();
        PutMappingRequest mapping = null;
        if(objType == 1){
        	mapping = Requests.putMappingRequest(indexName).type(type).source(saveMapping(obj,analyzerList));
        	
        }else{
        	mapping = Requests.putMappingRequest(indexName).type(type).source(setMapping(obj,analyzerList));
        }
        //AcknowledgedResponse actionGet = client.admin().indices().putMapping(mapping).actionGet();
        //AcknowledgedResponse putMapping = restHighLevelClient.indices().putMapping(mapping, options);
        try {
			restHighLevelClient.indices().putMapping(mapping, options);
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
 
    /**
     * 设置对象的ElasticSearch的Mapping
     *
     * jfinal
     * @param obj
     * @return
     */
    public XContentBuilder setMapping(Object obj,List<String> analyzerList) {
        List<Map.Entry<String,Object>> fieldList = getFieldList(obj);
        XContentBuilder mapping = null;
        try {
            mapping = jsonBuilder().startObject().startObject("properties");
            for (Map.Entry<String,Object> atrrValue : fieldList) {
                
            	String key = (String) atrrValue.getKey();
            	String value = atrrValue.getValue().toString();
            	String name = value.substring(value.lastIndexOf(".")+1);
            	String type = getElasticSearchMappingType(name.toLowerCase());
                if (analyzerList.contains(key)) {
                    mapping.startObject(key)
                        .field("type", type)
                        //使用icu_analyzer分词器
                        .field("analyzer", "icu_analyzer")
                        .field("search_analyzer", "icu_analyzer")
                        .endObject();
                } else {
                    mapping.startObject(key)
                     	.field("type", type)
                    .endObject();
                }
            }
            mapping.endObject().endObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return mapping;
    }
 
    /**
     * 设置对象的ElasticSearch的Mapping
     *
     * 普通对象
     * @param obj
     * @return
     */
    public XContentBuilder saveMapping(Object obj,List<String> analyzerList) {
    	List<Field> fieldList = getFields(obj);
        XContentBuilder mapping = null;
        try {
            mapping = jsonBuilder().startObject().startObject("properties");
            for (Field field : fieldList) {
                //修饰符是static的字段不处理
                if (Modifier.isStatic(field.getModifiers())){
                    continue;
                }
                if (field.getType().isInterface()){
         		   //处理list
                	List<Field> listFields = getListFields(obj,field.getName());
                	mapping.startObject(field.getName())
                			.field("type", "nested")
                		.startObject("properties");
                	for (Field f : listFields) {
	                	String name = f.getName();
	          		  	String type = getElasticSearchMappingType(f.getType().getSimpleName().toLowerCase());
	          		  	mapping.startObject(name)
    			   			.field("type", type)
    			   		.endObject();
                	}
                	mapping.endObject().endObject();
         	   }else{
         		   String name = field.getName();
         		   String type = getElasticSearchMappingType(field.getType().getSimpleName().toLowerCase());
         		   if (analyzerList.contains(name)) {
         			   mapping.startObject(name)
         			   		.field("type", type)
         			   		//使用icu_analyzer分词器
         			   		.field("analyzer", "icu_analyzer")
         			   		.field("search_analyzer", "icu_analyzer")
         			   .endObject();
         		   } else {
         			   mapping.startObject(name)
         			   		.field("type", type)
         			   .endObject();
         		   }
         	   }
            }
            mapping.endObject().endObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return mapping;
    }

    
    /**
     * 获取对象所有自定义的属性
     *
     * jfinal反射
     * @param obj
     * @return
     */
	public List<Map.Entry<String,Object>> getFieldList(Object obj) {
        List<Map.Entry<String,Object>> fieldList = new ArrayList<>();
        Class objClass = obj.getClass();
        Table table = TableMapping.me().getTable(objClass);
        Map<String, Class<?>> columnTypeMap = table.getColumnTypeMap();
        Iterator it = columnTypeMap.entrySet().iterator();
        while (it.hasNext()) {
           Map.Entry<String,Object> atrrValue = (Map.Entry<String,Object>)it.next();
           fieldList.add(atrrValue);
        }
        return fieldList;
    }

    /**
     * 获取对象所有自定义的属性
     * 
     * 普通对象映射
     * @param obj
     * @return
     */
	public List<Field> getFields(Object obj) {
		Field[] fields = obj.getClass().getDeclaredFields();
        List<Field> fieldList = new ArrayList<>();
        fieldList.addAll(Arrays.asList(fields));
        return fieldList;
    }
	
	/**
	 * 获取对象所有自定义的属性
	 * 普通对象List映射
	 * @param obj
	 * @param listName
	 * @return
	 */
    private List<Field> getListFields(Object obj,String listName) {
    	Field listField;
    	List<Field> fieldList = new ArrayList<>();
		try {
			listField = obj.getClass().getDeclaredField(listName);
			//获取 list 字段的泛型参数
			ParameterizedType listGenericType = (ParameterizedType) listField.getGenericType();
			Type[] listActualTypeArguments = listGenericType.getActualTypeArguments();
			Class objClass =(Class)listActualTypeArguments[0];
			Field[] fields = objClass.getDeclaredFields();
			fieldList.addAll(Arrays.asList(fields));
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		return fieldList;
    }
    
    /**
     * java类型与ElasticSearch类型映射
     *
     * @param varType
     * @return
     */
    public String getElasticSearchMappingType(String varType) {
        String es;
        switch (varType) {
	        case "date":
	        	//默认格式2020-06-06 || 1420070400001
	            es = "date";
	            break;
	        case "double":
	            es = "double";
	            break;
	        case "bigdecimal":
	        	//scaled_float 会缩放存储
	        	es = "double";
	        	break;
            case "long":
                es = "long";
                break;
            case "int":
                es = "long";
                break;
            case "integer":
            	es = "long";
            	break;
            case "list":
            	es = "nested";
            	break;
            default:
                es = "text";
                break;
        }
        return es;
    }
 
 
    /**
     * 创建索引
     * @throws IOException 
     */
    public void createIndex(String indexName) {
        /*if (!indexExists()) {
            CreateIndexRequest request = new CreateIndexRequest("ice");
            client.admin().indices().create(request);
        }*/
    	try {
	    	if (!indexExists(indexName)) {
	           CreateIndexRequest request = new CreateIndexRequest(indexName);
	           IndicesClient indices = restHighLevelClient.indices();
	           indices.create(request, options);
			} 
    	}catch (IOException e) {
			e.printStackTrace();
		}
    }
    
    /**
     * 判断ElasticSearch中的索引是否存在
     * @throws IOException 
     */
    public boolean indexExists(String indexName){
    	/*IndicesExistsRequest request = new IndicesExistsRequest(clusterName);
        IndicesAdminClient adminClient = client.admin().indices();
        IndicesExistsResponse response = adminClient.exists(request).actionGet();
        if (response.isExists()) {
            return true;
        }
        return false;*/
    	
        GetIndexRequest request = new GetIndexRequest(indexName);
        IndicesClient indices = restHighLevelClient.indices();
    	boolean exists = false;
		try {
			exists = indices.exists(request, options);
		} catch (IOException e) {
			e.printStackTrace();
		}
        return exists;
    }

}

高版本ES的mapping一旦设定不可修改 参考官方文档

采用Java的方式创建ES的 index、settings、mapping属于硬编码的形式，我是是可以选择更简便的方式 Kibana 去创建

夜幕¥¥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python elasticsearch从创建索引到写入数据的全过程
09-18
Python Elasticsearch 是一个用于操作Elasticsearch的客户端库，它提供了丰富的接口来实现对Elasticsearch的各种操作，包括创建索引、插入数据等。在本文中，我们将深入探讨如何使用Python Elasticsearch 从创建索引...
elasticsearch–使用http创建索引
01-20
在Elasticsearch中，创建索引是数据存储和检索的基础步骤。索引是Elasticsearch中的逻辑空间，类似于关系数据库中的数据库。通过HTTP接口，我们可以方便地管理这些索引，包括创建、设置映射（mapping）以及操作文档...
Elasticsearch：使用最新的 Elasticsearch Java client 8.0 来创建索引并搜索
Elastic 中国社区官方博客
03-30 1万+
这篇文章，我来详细地描述如何使用最新的 Elasticsearch Java client 8.0 来创建索引并进行搜索。最新的 Elasticsearch Java client API 和之前的不同。在之前的一些教程中，我们使用 High Level API来进行操作。在官方文档中，已经显示为 deprecated。 前提条件 Java 8 及以后的版本 一个 JSON 对象映射库，允许你的应用程序类与 Elasticsearch API 无缝集成。 Java 客户端支持 Jackson 或像
ElasticSearch-学习笔记04【Java客户端操作索引库】
upward
02-10 2701
ElasticSearch-学习笔记04【Java客户端操作索引库】
使用es必须要知道的一些知识点：索引篇_es创建索引
最新发布
2401_84170623的博客
04-27 1678
无需分词的情况下，可以在Elasticsearch动态模板中，设置所有字符串数据都用"type": "keyword"来存储。举个例子，我们可以创建一个适当的动态模板规则。当Elasticsearch被用作大数据量存储中心时，尤其是从Mysql迁移数据进来的情况下，我们很多场景下其实无需对字符串分词，也就是说字符串存储不使用es中的。es数据底层存储的时候是按照json结构的，Map结构的数据存储到es，key是不固定的，随着数据量的扩张，key的数量可能超过1000，此时es会抛出异常。
ElasticSearch 索引创建
未来在这儿的专栏
03-21 8615
创建索引是使用Elasticsearch的关键步骤之一。在创建索引时，您需要考虑字段类型、分析器、嵌套和多个映射等因素。您还可以使用别名、分片和副本等功能来提高系统的容错性、性能和可用性。在创建索引之前，请确保您已经安装了Elasticsearch并启动了服务器。您还需要使用适当的REST客户端与服务器进行交互。如果您遇到问题，请查看Elasticsearch文档或参考Elasticsearch社区中的其它资源。#ChatGPT协助生成。
elasticsearch系列-使用Java客户端创建索引、mapping、文档
在途中
01-30 4701
在前两篇我们介绍了通过postman和elasticsearch-head介绍了操作elasticsearch的增删改查操作和文档的添加、修改、搜索等基本操作。在实际工作中，难免使用Java对elasticsearch进行操作，本篇我们来介绍通过Java客户端如何创建索引、mappings和文档等。 引入maven依赖 引入elasticsearch和transport依赖如下所示。 ...
Elasticsearch创建Index--java实现
ZK_小小世界的专栏
09-05 1万+
将所要创建的index以json格式的方式写入配置文件，可以指定所要创建的index的字段类型，然后通过java api来创建index 具体实现： Index对象类： public class Index { private String index; //索引名 private String type; //type表名 privat
Spring Boot elasticsearch7.6.2基础操作：创建索引、新增数据、查询数据
04-29
在本文中，我们将深入探讨如何使用Spring Boot与Elasticsearch 7.6.2进行基本操作，包括创建索引、添加数据以及查询数据。Elasticsearch是一个强大的分布式搜索引擎，而Spring Boot是Java开发中的轻量级框架，两者...
elasticsearch 同义词创建索引实例.txt
07-19
elasticsearch 同义词创建索引实例
ElasticSearch7.3学习(十六)----RestHighLevelClient Java api实现索引的创建、删除、是否存在、关闭、开启
09-08 2721
注意：导入的包区别，不同的包创建索引的方式不同。博主亲身实践，具体体现在createIndexRequest.mapping()里面。读者可自行试验。可以看到上述两种方式导入的包的子类名是相同的，但是具体对索引的操作方式可能是不同的。具体的区别博主暂时还不清楚，后续若有进展再在此处更新。
Elasticsearch：使用最新的 Nodejs client 8.x 来创建索引并搜索
Elastic 中国社区官方博客
04-21 3412
针对最新的 Elastic Stack 8.0，Nodejs 的客户端也进行了升级。在今天的文章中，我来介绍如何在 Nodejs 中来连接 Elasticsearch 并创建索引及安装。 安装 我们可以通过如下的命令来进行安装： npm install <alias>@npm:@elastic/elasticsearch@<version> 如果我们不指定版本，我们可以通过如下的命令来进行安装。它可以帮我们安装最新的版本： npm install npm:@elas
Elasticsearch创建索引
a13568hki的博客
08-29 5629
您可以通过 Elasticsearch 的 RESTFul API 来创建索引： PUT http://127.0.0.1:9200/commodity 注意：默认情况下，创建的索引分片数量是 5 个，副本数量是 1 个。 您可以通过如下参数来指定分片数、副本数量： { "settings": { "number_of_shards": 3, "number_of_replicas": 2 } } 1.1 实战演示 通过 CURL 命令来上手操作一下，我们尝试创建一个商品索引, 看下效果：
spring data elasticsearch：启动项目时自动创建索引
55555的博客
07-02 5284
在springboot整合spring data elasticsearch项目中，当索引数量较多，mapping结构较为复杂时，我们常常希望启动项目时能够自动创建索引及mapping，这样就不用再到各个环境中创建索引了所以今天咱们就来看看如何自动创建索引我们已经在实体类中声明了索引数据结构了，只需要识别有注解的实体类，然后调用的和方法即可创建索引及mapping1、因为要调用ElasticsearchRestTemplate，所以要提前声明其bean，这个我们在之前的文章中已经讲解过，有需要的同学可以参考
Java连接ElasticSearch
huangbaokang的博客
02-06 4573
新建maven工程，添加依赖 dependency> groupId>org.elasticsearch.clientgroupId> artifactId>transportartifactId> version>5.5.2version> dependency> 启动好ElasticSearch服务，编写测试类。 package com.hbk.es; im
如何把数据快速批量添加到Elasticsearch中
zdy0_2004的专栏
11-16 4915
http://www.cnblogs.com/hai-ping/p/6068946.html 问题来源 最近新做一个项目，有部分搜索比较频繁的数据，而且量级比较大，预计一两年时间很可能达到100G，项目要求不要存在数据库中，最终出来有两个方案，一个是使用Protocol Buffers存储在文件上，另外就是存在Elasticsearch中，也方便搜索，但这两个方案需要验
ElasticSearch入门（八）ElasticSearch的全文检索
jwang的博客
10-21 763
前言 本章学习ElasticSearch全文检索的相关知识 方法 1.概念 我们知道，ES在全文检索、高亮这方面做的十分出色，让我们一起揭开它的神秘面纱！ 我们首先构造下数据（附带上ik中文分词器哦）！ 创建新的索引jwang01并构造数据： PUThttp://localhost:9200/jwang01 { "settings": { "index": { ...
elasticsearch基础知识以及创建索引
热门推荐
赶路人儿
11-13 7万+
一、基础概念： 1、索引： 索引（index）是elasticsearch的一个逻辑存储，可以理解为关系型数据库中的数据库，es可以把索引数据存放到一台服务器上，也可以sharding后存到多台服务器上，每个索引有一个或多个分片，每个分片可以有多个副本。 2、索引类型（index_type）： 在es中，一个索引对象可以存储多个不同用途的对象，通过索引类型（index_type）可以区分单
elasticsearch之Document APIs【Multi Get API】
山鬼谣的专栏
08-16 427
环境elasticsearch：5.5Multi Get APIMulti Get API 允许基于index，type（可选），id（或者是路由）来获取多个文档。 抓取到的所有文档都包含在响应字段docs里面，该字段是个数组，每个元素与get api获取的文档都有相似的结构。GET _mget { "docs":[ { "_index":"bank", "_t
怎样合理创建es索引_Elasticsearch(ES)创建索引
06-03
要合理创建 Elasticsearch（ES）索引，需要考虑以下几个方面： 1. 确定索引的名称：ES中的索引名称应该简洁明了，能够清楚地表达索引的用途或内容。 2. 确定索引的字段：确定需要存储的字段以及字段的类型。在创建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值