RestHighLevelClient操作7.10.0（二）ElasticSearch索引及别名详解

最新推荐文章于 2024-07-25 14:48:00 发布
最新推荐文章于 2024-07-25 14:48:00 发布
阅读量4.1k 收藏 16
点赞数 4
分类专栏： Elasticsearch 文章标签： elasticsearch java es 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39151461/article/details/111569095
版权

为便于更好的理解，这里示例会指出通过 Kibana 的 Restful 工具操作与对应的 Java 代码操作的两个示例。

ElasticSearch索引及别名操作

一、项目结构

在这里插入图片描述

主要项目目录结构介绍

  • annotation目录。自定义一些注解类。
  • dto目录。存放一搜索实体类。
  • config目录。项目的配置文件，初始化Elasticsearch连接等操作。
  • controller目录。搜索请求，系统索引，数据类型创建请求入口。
  • servcie目录。执行搜索请求等服务类。

二、Restful Index APIs介绍

官方文档Index APIs有很好的介绍
特别注意：

  • 更新索引别名,别名不能与索引同名；
  • 一个索引可以有多个别名，不同的索引可以有相同的别名。
    在这里插入图片描述
    这里简单介绍几个

#创建索引
PUT /blog

#创建索引及分片信息
PUT /blog
{
  "settings": {
    "index": {
      "number_of_shards": 3,  
      "number_of_replicas": 2 
    }
  }
}

#获取索引信息
GET /blog

#索引是否存在
HEAD /blog
#索引别名是否存在
HEAD /_alias/blog_alias

#更新索引别名,别名不能与索引同名
#一个索引可以有多个别名，不同的索引可以有相同的别名
POST /blog/_alias/blog_alias

#添加索引别名
POST /_aliases 
{ "actions":[ { "add":{"index":"blog","alias":"alias1"} } ] } 


#获取索引别名
GET /blogs/_alias

#删除索引
DELETE /blogs

#删除索引别名
DELETE /blog/_alias/blog_alias

可在kibana上做相关操作
在这里插入图片描述

三、项目源码

ElasticSearch 连接配置可参考上一篇内容
RestHighLevelClient操作7.10.0（一）ElasticSearch 连接配置，这里不再赘述。

3.1 类ESFieldTypeConstains.java

该类用于存放一些es中的常量，便于统一管理。

package com._520xuzai.es7.constains;


/**
 * \* Created with IntelliJ IDEA.
 * \* User: 煦仔
 * \* Date: 2020-12-22
 * \* Time: 10:43
 * \* To change this template use File | Settings | File Templates.
 * \* Description: es中的一些常量信息
 * \
 */
public class ESFieldTypeConstains {


    //分词策略
    public static final String SETANALYZER_IK_MAX_WORD = "ik_max_word";
    public static final String SETANALYZER_KEYWORD = "keyword";
    public static final String SETANALYZER_standard = "standard";
    public static final String SETANALYZER_IK_smart = "ik_smart";


    //数据类型
    public static final String DATATYPE_KEYWORD = "keyword";
    public static final String DATATYPE_TEXT = "text";
    public static final String DATATYPE_LONG = "long";
    public static final String DATATYPE_INTEGER = "integer";

}

3.2 类 ESMappingField.java

该注解类用于注解映射到ES中的数据字段，类似Hibernate中实体字段映射数据库中的表字段。

package com._520xuzai.es7.annotation;

import java.lang.annotation.*;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 煦仔
 * \* Date: 2020-12-22
 * \* Time: 15:23
 * \* To change this template use File | Settings | File Templates.
 * \* Description: 该注解类用于注解映射到ES中的数据字段，类似Hibernate中实体字段映射数据库中的表字段
 * \
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
@Inherited
public @interface ESMappingField {

    /**
     * 字段名称
     * @return
     */
    String fieldName() default "";

    /**
     * 数据类型
     * @return
     */
    String dataType() default "";

    /**
     * 使用哪种分词器
     * @return
     */
    String setAnalyzer() default "";

    /**
     * 是否使用分词功能
     * @return
     */
    boolean isAnalyze() default false;
}

3.3 SearchGoodsMappingDTO.java

商品搜索映射实体类，用于字段的映射。

package com._520xuzai.es7.dto;

import com._520xuzai.es7.annotation.ESMappingField;
import com._520xuzai.es7.constains.ESFieldTypeConstains;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 煦仔
 * \* Date: 2020-12-22
 * \* Time: 16:00
 * \* To change this template use File | Settings | File Templates.
 * \* Description: 商品搜索映射实体类
 * \
 */
@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
public class SearchGoodsMappingDTO implements java.io.Serializable {


    /**
     * 商品ID
     */
    @ESMappingField(fieldName = "goodsId", dataType = ESFieldTypeConstains.DATATYPE_KEYWORD)
    private String goodsId;

    /**
     * 商品名称-不分词
     */
    @ESMappingField(fieldName = "goodsName", dataType = ESFieldTypeConstains.DATATYPE_TEXT, isAnalyze = true, setAnalyzer = ESFieldTypeConstains.SETANALYZER_KEYWORD)
    private String goodsName;

    /**
     * 商品名称-使用ik_max_word分词
     */
    @ESMappingField(fieldName = "goodsNameIk", dataType = ESFieldTypeConstains.DATATYPE_TEXT, isAnalyze = true, setAnalyzer = ESFieldTypeConstains.SETANALYZER_IK_MAX_WORD)
    private String goodsNameIk;

    /**
     * 商品名称-使用ik_smart分词
     */
    @ESMappingField(fieldName = "goodsNameSmart", dataType = ESFieldTypeConstains.DATATYPE_TEXT, isAnalyze = true, setAnalyzer = ESFieldTypeConstains.SETANALYZER_IK_smart)
    private String goodsNameSmart;

    /**
     * 商品名称-使用标准分词器
     */
    @ESMappingField(fieldName = "goodsNameStandard", dataType = ESFieldTypeConstains.DATATYPE_TEXT, isAnalyze = true, setAnalyzer = ESFieldTypeConstains.SETANALYZER_standard)
    private String goodsNameStandard;

    /**
     * 商品分类ID
     */
    @ESMappingField(fieldName = "goodsClassId", dataType = ESFieldTypeConstains.DATATYPE_KEYWORD)
    private String goodsClassId;

    /**
     * 商品分类名称
     */
    @ESMappingField(fieldName = "goodsClassName", dataType = ESFieldTypeConstains.DATATYPE_KEYWORD)
    private String goodsClassName;

    /**
     * 商品图片
     */
    @ESMappingField(fieldName = "goodsImg", dataType = ESFieldTypeConstains.DATATYPE_KEYWORD)
    private String goodsImg;

    /**
     * 商品价格
     */
    @ESMappingField(fieldName = "goodsPrice", dataType = ESFieldTypeConstains.DATATYPE_LONG)
    private Long goodsPrice;

    /**
     * 商品状态，1正常，0下架，-1已删除
     */
    @ESMappingField(fieldName = "goodsStatus", dataType = ESFieldTypeConstains.DATATYPE_KEYWORD)
    private String goodsStatus;

    /**
     * 商品销量
     */
    @ESMappingField(fieldName = "goodsSales", dataType = ESFieldTypeConstains.DATATYPE_LONG)
    private Long goodsSales;

    /**
     * 商品库存
     */
    @ESMappingField(fieldName = "goodsNum", dataType = ESFieldTypeConstains.DATATYPE_INTEGER)
    private Integer goodsNum;

    /**
     * 搜索结果匹配度
     */
    private float score;

}

3.4 接口IElasticsearchIndexService.java

package com._520xuzai.es7.service;


import java.io.IOException;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 煦仔
 * \* Date: 2020-12-22
 * \* Time: 10:44
 * \* To change this template use File | Settings | File Templates.
 * \* Description: es索引相关操作
 * \
 */
public interface IElasticsearchIndexService {

    /**
     * 判断索引是否存在
     * @param indexName
     * @return
     */
    Boolean isIndexExists(String indexName) throws IOException;

    /**
     * 创建索引
     *
     * @param indexName
     * @param numberOfShards
     * @param numberOfReplicas
     * @return
     */
    Boolean createIndexWithShards(String indexName, Integer numberOfShards, Integer numberOfReplicas) throws IOException;

    /**
     * 创建索引(默认1个分片，1个副本)
     *
     * @param indexName
     * @return
     */
    Boolean createIndex(String indexName) throws IOException;

    /**
     * 删除索引
     * @param indexName
     * @return
     * @throws IOException
     */
    Boolean deleteIndex(String indexName) throws IOException;

    /**
     * 判断索引别名是否存在
     * @param aliasName
     * @return
     */
    Boolean isAliasExists(String aliasName) throws IOException;

    /**
     * 创建索引同时给索引创建别名
     *
     * @param indexName
     * @param aliasName
     * @return
     */
    Boolean createIndexWithAlias(String indexName, String aliasName) throws IOException;

    /**
     * 给索引添加别名
     * @param indexName
     * @param aliasName
     * @return
     * @throws IOException
     */
    Boolean addAlias(String indexName, String aliasName) throws IOException;

    /**
     * 删除某个索引的别名
     * @param aliasName
     * @return
     * @throws IOException
     */
    Boolean deleteAlias(String indexName,String aliasName) throws IOException;

    /**
     * 重建索引，拷贝数据
     *
     * @param oldIndexname
     * @param newIndexname
     */
    void reindex(String oldIndexname, String newIndexname) throws IOException;

    /**
     * 重建索引后修改别名
     *
     * @param aliasname
     * @param oldIndexname
     * @param newIndexname
     * @return
     */
    Boolean changeAliasAfterReindex(String aliasname, String oldIndexname, String newIndexname) throws IOException ;

    /**
     * 添加mapping
     * @param indexName
     * @param clazz
     * @return
     */
    Boolean addMapping(String indexName, Class<?> clazz) throws IOException;

}

3.5 接口实现类ElasticsearchIndexServiceImpl.java

package com._520xuzai.es7.service.impl;


import com._520xuzai.es7.annotation.ESMappingField;
import com._520xuzai.es7.service.IElasticsearchIndexService;
import com.google.common.collect.Maps;
import org.apache.commons.lang3.StringUtils;
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.IndicesOptions;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.*;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.index.reindex.ReindexRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Map;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 煦仔
 * \* Date: 2020-12-22
 * \* Time: 10:50
 * \* To change this template use File | Settings | File Templates.
 * \* Description: es索引相关操作实现
 * \
 */

@Service
public class ElasticsearchIndexServiceImpl implements IElasticsearchIndexService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;


    @Override
    public Boolean isIndexExists(String indexName) throws IOException {
        GetIndexRequest getIndexRequest = new GetIndexRequest(indexName);
        getIndexRequest.humanReadable(true);
        return restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
    }

    @Override
    public Boolean createIndexWithShards(String indexName, Integer numberOfShards, Integer numberOfReplicas) throws IOException {
        CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexName);
        //设置分片信息
        numberOfShards = numberOfShards == null ? 1 : numberOfShards;
        numberOfReplicas = numberOfReplicas == null ? 1 : numberOfReplicas;
        createIndexRequest.settings(Settings.builder().
                put("index.number_of_shards", numberOfShards)
                .put("index.number_of_replicas", numberOfReplicas));
        //创建索引
        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
        return createIndexResponse.isAcknowledged();
    }

    @Override
    public Boolean createIndex(String indexName) throws IOException {
        CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexName);
        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
        return createIndexResponse.isAcknowledged();
    }

    @Override
    public Boolean deleteIndex(String indexName) throws IOException {
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indexName);
        deleteIndexRequest.indicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN);
        AcknowledgedResponse delete = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
        return delete.isAcknowledged();
    }

    @Override
    public Boolean isAliasExists(String aliasName) throws IOException {
        GetAliasesRequest getAliasesRequest = new GetAliasesRequest(aliasName);
        return restHighLevelClient.indices().existsAlias(getAliasesRequest, RequestOptions.DEFAULT);
    }


    @Override
    public Boolean createIndexWithAlias(String indexName, String aliasName) throws IOException {
        CreateIndexRequest request = new CreateIndexRequest(indexName);
        if (StringUtils.isNotEmpty(aliasName)) {
            request.alias(new Alias(aliasName));
        }
        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
        return createIndexResponse.isAcknowledged();
    }

    @Override
    public Boolean addAlias(String indexName, String aliasName) throws IOException {
        IndicesAliasesRequest aliasesRequest = new IndicesAliasesRequest();
        IndicesAliasesRequest.AliasActions aliasAction =
                new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.ADD)
                        .index(indexName)
                        .alias(aliasName);
        aliasesRequest.addAliasAction(aliasAction);
        AcknowledgedResponse acknowledgedResponse = restHighLevelClient.indices().updateAliases(aliasesRequest,RequestOptions.DEFAULT);
        return acknowledgedResponse.isAcknowledged();
    }

    @Override
    public void reindex(String oldIndexname, String newIndexname) throws IOException {
        ReindexRequest request = new ReindexRequest();
        request.setSourceIndices(oldIndexname);
        request.setDestIndex(newIndexname);
        request.setSourceBatchSize(1000);
        request.setDestOpType("create");
        request.setConflicts("proceed");
//        request.setScroll(TimeValue.timeValueMinutes(10));
//        request.setTimeout(TimeValue.timeValueMinutes(20));
        request.setRefresh(true);
        restHighLevelClient.reindex(request, RequestOptions.DEFAULT);
    }

    @Override
    public Boolean deleteAlias(String indexName,String aliasName) throws IOException {
        DeleteAliasRequest deleteAliasRequest = new DeleteAliasRequest(indexName,aliasName);
        org.elasticsearch.client.core.AcknowledgedResponse acknowledgedResponse = restHighLevelClient.indices().deleteAlias(deleteAliasRequest, RequestOptions.DEFAULT);
        return acknowledgedResponse.isAcknowledged();
    }

    @Override
    public Boolean changeAliasAfterReindex(String aliasname, String oldIndexname, String newIndexname) throws IOException {
        IndicesAliasesRequest.AliasActions addIndexAction = new IndicesAliasesRequest.AliasActions(
                IndicesAliasesRequest.AliasActions.Type.ADD).index(newIndexname).alias(aliasname);
        IndicesAliasesRequest.AliasActions removeAction = new IndicesAliasesRequest.AliasActions(
                IndicesAliasesRequest.AliasActions.Type.REMOVE).index(oldIndexname).alias(aliasname);

        IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
        indicesAliasesRequest.addAliasAction(addIndexAction);
        indicesAliasesRequest.addAliasAction(removeAction);
        AcknowledgedResponse indicesAliasesResponse = restHighLevelClient.indices().updateAliases(indicesAliasesRequest,
                RequestOptions.DEFAULT);
        return indicesAliasesResponse.isAcknowledged();
    }


    @Override
    public Boolean addMapping(String indexName, Class<?> clazz) throws IOException {
        PutMappingRequest putMappingRequest = new PutMappingRequest(indexName);
        Map<String, Object> jsonMap = Maps.newHashMap();
        Map<String, Object> properties = Maps.newHashMap();

        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            ESMappingField esMappingField = field.getDeclaredAnnotation(ESMappingField.class);
            if (esMappingField != null) {
                String fieldname = esMappingField.fieldName();
                String datatype = esMappingField.dataType();
                String analyzer = esMappingField.setAnalyzer();
                boolean isanalye = esMappingField.isAnalyze();
                Map<String, Object> m = Maps.newHashMap();
                m.put("type", datatype);
                if (isanalye && StringUtils.isNotEmpty(analyzer)) {
                    m.put("analyzer", analyzer);
                    m.put("search_analyzer", analyzer);
                }
                properties.put(fieldname, m);
            }
        }
        jsonMap.put("properties", properties);
        putMappingRequest.source(jsonMap);
        AcknowledgedResponse putMappingResponse = restHighLevelClient.indices().putMapping(putMappingRequest,
                RequestOptions.DEFAULT);
        return putMappingResponse.isAcknowledged();
    }

}

3.6 控制层，便于测试ElasticsearchIndexController.java

package com._520xuzai.es7.controller;

import com._520xuzai.es7.service.IElasticsearchIndexService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 煦仔
 * \* Date: 2020-12-22
 * \* Time: 10:43
 * \* To change this template use File | Settings | File Templates.
 * \* Description:elasticsearch索引相关接口
 * \
 */
@RestController
@RequestMapping("/es/index")
@Api(tags = "elasticsearch索引相关接口")
public class ElasticsearchIndexController {

    @Autowired
    private IElasticsearchIndexService elasticsearchIndexService;


    @GetMapping("/isIndexExists")
    @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query")
    Boolean isIndexExists(@RequestParam(value = "indexName")String indexName) throws IOException{
        return elasticsearchIndexService.isIndexExists(indexName);
    }


    @PostMapping("/createIndex")
    @ApiOperation(value = "创建索引")
    @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query")
    Boolean createIndex(@RequestParam(value = "indexName")String indexName) throws IOException {
        return elasticsearchIndexService.createIndex(indexName);
    }

    @PostMapping("/createIndexWithShards")
    @ApiOperation(value = "创建索引及自定义分片信息")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "分片数量", name = "numberOfShards", dataType = "int", required = true, paramType = "query"),
            @ApiImplicitParam(value = "副本数量", name = "numberOfReplicas", dataType = "int", required = true, paramType = "query")
    })
    Boolean createIndexWithShards(@RequestParam(value = "indexName")String indexName,
                                  @RequestParam(value = "numberOfShards")int numberOfShards,
                                  @RequestParam(value = "numberOfReplicas")int numberOfReplicas) throws IOException {
        return elasticsearchIndexService.createIndexWithShards(indexName,numberOfShards,numberOfReplicas);
    }

    @PostMapping("/deleteIndex")
    @ApiOperation(value = "删除索引")
    @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query")
    Boolean deleteIndex(@RequestParam(value = "indexName")String indexName) throws IOException {
        return elasticsearchIndexService.deleteIndex(indexName);
    }

    /**
     * 判断索引别名是否存在
     * @param aliasName
     * @return
     */
    @GetMapping("/isAliasExists")
    @ApiOperation(value = "判断索引别名是否存在")
    @ApiImplicitParam(value = "别名", name = "aliasName", dataType = "String", required = true, paramType = "query")
    Boolean isAliasExists(@RequestParam(value = "aliasName")String aliasName) throws IOException{
        return elasticsearchIndexService.isAliasExists(aliasName);
    }

    @PostMapping("/createIndexWithAlias")
    @ApiOperation(value = "创建索引同时给索引创建别名")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "别名", name = "aliasName", dataType = "String", required = true, paramType = "query")
    })
    Boolean createIndexWithAlias(@RequestParam(value = "indexName")String indexName,
                                 @RequestParam(value = "aliasName")String aliasName) throws IOException{
        return elasticsearchIndexService.createIndexWithAlias(indexName,aliasName);
    }

    @PostMapping("/addAlias")
    @ApiOperation(value = "给索引添加别名")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "别名", name = "aliasName", dataType = "String", required = true, paramType = "query")
    })
    Boolean addAlias(@RequestParam(value = "indexName")String indexName,
                                 @RequestParam(value = "aliasName")String aliasName) throws IOException{
        return elasticsearchIndexService.addAlias(indexName,aliasName);
    }

    @PostMapping("/deleteAlias")
    @ApiOperation(value = "删除某个索引的别名")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "别名", name = "aliasName", dataType = "String", required = true, paramType = "query")
    })
    Boolean deleteAlias(@RequestParam(value = "indexName")String indexName,
                        @RequestParam(value = "aliasName")String aliasName) throws IOException{
        return elasticsearchIndexService.deleteAlias(indexName,aliasName);
    }

    @PostMapping("/reindex")
    @ApiOperation(value = "重建索引，拷贝数据")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "原索引名称", name = "oldIndexName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "新索引名称", name = "newIndexName", dataType = "String", required = true, paramType = "query")
    })
    void reindex(@RequestParam(value = "oldIndexName")String oldIndexName,
                 @RequestParam(value = "newIndexName")String newIndexName) throws IOException{
        elasticsearchIndexService.reindex(oldIndexName,newIndexName);

    }

    @PostMapping("/changeAliasAfterReindex")
    @ApiOperation(value = "重建索引后修改别名")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "原索引名称别名", name = "aliasName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "原索引名称", name = "oldIndexName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "新索引名称", name = "newIndexName", dataType = "String", required = true, paramType = "query")
    })
    Boolean changeAliasAfterReindex(@RequestParam(value = "aliasName")String aliasName,
                                    @RequestParam(value = "oldIndexName")String oldIndexName,
                                    @RequestParam(value = "newIndexName")String newIndexName) throws IOException{
        return elasticsearchIndexService.changeAliasAfterReindex(aliasName,oldIndexName,newIndexName);
    }


    /**
     * 添加mapping
     * @param indexName
     * @param className
     * @return
     */
    @PostMapping("/addMapping")
    @ApiOperation(value = "添加mapping")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "索引名称", name = "indexName", dataType = "String", required = true, paramType = "query"),
            @ApiImplicitParam(value = "添加的映射实体权限定名", name = "className", dataType = "String", required = true, paramType = "query")
    })
    Boolean addMapping(@RequestParam(value = "indexName")String indexName,
                       @RequestParam(value = "className")String className) throws IOException, ClassNotFoundException {
        Class<?> clazz = Class.forName(className);
        return elasticsearchIndexService.addMapping(indexName,clazz);
    }


}

四、实践

对于以上关于索引相关的接口，我这里不再一一将测试内容放上来了，简单介绍几个重要的操作。

在这里插入图片描述

1.给索引添加mapping

  • 我们这里通过swagger来给索引添加一个映射
    在这里插入图片描述

  • 在es-head中查看mapping信息
    在这里插入图片描述

  • 在kibana中查看

#获取索引信息
GET /blogs

{
  "blogs" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "goodsClassId" : {
          "type" : "keyword"
        },
        "goodsClassName" : {
          "type" : "keyword"
        },
        "goodsId" : {
          "type" : "keyword"
        },
        "goodsImg" : {
          "type" : "keyword"
        },
        "goodsName" : {
          "type" : "text",
          "analyzer" : "keyword"
        },
        "goodsNameIk" : {
          "type" : "text",
          "analyzer" : "ik_max_word"
        },
        "goodsNameSmart" : {
          "type" : "text",
          "analyzer" : "ik_smart"
        },
        "goodsNameStandard" : {
          "type" : "text",
          "analyzer" : "standard"
        },
        "goodsNum" : {
          "type" : "integer"
        },
        "goodsPrice" : {
          "type" : "long"
        },
        "goodsSales" : {
          "type" : "long"
        },
        "goodsStatus" : {
          "type" : "keyword"
        }
      }
    },
    "settings" : {
      "index" : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards" : "1",
        "provided_name" : "blogs",
        "creation_date" : "1608703505760",
        "number_of_replicas" : "1",
        "uuid" : "JZ6AKiAvR6q67GLUhfRnbg",
        "version" : {
          "created" : "7100099"
        }
      }
    }
  }
}

2.使用别名重建索引的过程

restful api端相关操作可阅读博文Elasticsearch基础11——索引之别名使用

  • 为当前索引建立一个别名
  • 将需要调整后的映射建立一个索引
  • 将旧索引的数据同步到新索引中
  • 将新索引和当前索引别名关联
  • 删除旧索引，完成数据转移

2.1通过kibana添加一条文档数据

POST /blogs/_doc/1
{
  "goodsClassId":"1",
  "goodsClassName":"大家电",
  "goodsId":"1",
  "goodsName":"高效多功能洗衣机，值得一试",
  "goodsNameIk":"高效多功能洗衣机，值得一试",
  "goodsNameStandard":"高效多功能洗衣机，值得一试",
  "goodsNum":10,
  "goodsPrice":12668,
  "goodsSales":198,
  "goodsStatus":1,
  "goodsBrand":"小天鹅"
}

2.2 创建一个新的索引及mapping

新建一个索引blogsbak，并在mapping中添加一个商品详情的字段。

	PUT /blogsbak

 	/**
     * 商品详情
     */
    @ESMappingField(fieldName = "goodsContent", dataType = ESFieldTypeConstains.DATATYPE_TEXT,isAnalyze = true, setAnalyzer = ESFieldTypeConstains.SETANALYZER_IK_MAX_WORD)
    private Integer goodsContent;

添加后新的索引blogsbak及mapping如下：

{
  "blogsbak" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "goodsClassId" : {
          "type" : "keyword"
        },
        "goodsClassName" : {
          "type" : "keyword"
        },
        "goodsContent" : {
          "type" : "text",
          "analyzer" : "ik_max_word"
        },
        "goodsId" : {
          "type" : "keyword"
        },
        "goodsImg" : {
          "type" : "keyword"
        },
        "goodsName" : {
          "type" : "text",
          "analyzer" : "keyword"
        },
        "goodsNameIk" : {
          "type" : "text",
          "analyzer" : "ik_max_word"
        },
        "goodsNameSmart" : {
          "type" : "text",
          "analyzer" : "ik_smart"
        },
        "goodsNameStandard" : {
          "type" : "text",
          "analyzer" : "standard"
        },
        "goodsNum" : {
          "type" : "integer"
        },
        "goodsPrice" : {
          "type" : "long"
        },
        "goodsSales" : {
          "type" : "long"
        },
        "goodsStatus" : {
          "type" : "keyword"
        }
      }
    },
    "settings" : {
      "index" : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards" : "1",
        "provided_name" : "blogsbak",
        "creation_date" : "1608711776108",
        "number_of_replicas" : "1",
        "uuid" : "oG4LE1AXR6WpFK3l8gx7AQ",
        "version" : {
          "created" : "7100099"
        }
      }
    }
  }
}

2.3执行重建索引接口

在这里插入图片描述
通过kibana查看数据已被拷贝
在这里插入图片描述

2.4 进行别名替换

调用重建索引后修改别名接口
在这里插入图片描述
在这里插入图片描述

2.5 删除旧索引

在这里插入图片描述

小煦仔
关注
专栏目录
Spring data elasticsearch使用方法详解
08-25
本文将深入讲解如何利用 Spring Data Elasticsearch 进行索引创建、配置映射、文档操作等基本功能。 ### **一、设置依赖** 在开始使用 Spring Data Elasticsearch 之前，你需要在项目中添加相应的依赖。在 Maven ...
索引：“其实我是一种数据结构”
weixin_44988779的博客
09-07 1006
“人家真的 不是目录” 索引的自白引言索引概述索引的创建索引的删除索引的查询explain查询有无索引show keys查询何种索引索引的原理聚簇索引辅助索引联合索引索引存在的问题 引言 大家好，我是索引，在MySQL中你可以使用CREATE INDEX indexName ON table_name (column_name)或alter table table_name add index(column_name)来创造我！在这里我主要澄清一下，我不是目录，你可以认为我是一种排序的数据结构，实在不行你就
mysql索引
qq_45610772的博客
09-19 744
索引 1：什么是索引？ 索引其实就是一种为了加速对数据表中的数据行的检索从而创建的分散存储的数据结构(也可以打个比喻：就是书中的目录) 注意： 1： 一般关系型数据库的中的索引是 硬盘级索引，就是说索引是存放在硬盘中的 2：如果程序访问我们数据库中的数据行数如果是几万的数据的规模的话，其实我们无需在意索引，但是当数据规模达到几千万上亿的情况下我们一般就会使用到索引 2：索引的作用： 索引在数据库中的作用其实是类似于目录在书本中的作用，用来提高查找信息的速度，用索引查找信息的时候，无需对整张表进行扫描，可
Springboot集成Elasticsearch High Level REST Client实现增删改查实战
最新发布
老徐的博客只有干货
07-25 1645
Elasticsearch 的 High Level REST Client 是一个用于与 Elasticsearch 进行交互的 Java 客户端库，它提供了比低级别的 REST 客户端更高级别的抽象。High Level REST Client 使用了 OkHttp 库作为底层的 HTTP 客户端，并且提供了自动重试、连接管理和错误处理等功能。它允许开发人员以面向对象的方式构建请求和解析响应，从而简化了与 Elasticsearch 的 REST API 的交互过程。
MYSQL创建联合索引
唐僧取经
06-09 3240
【代码】MYSQL创建联合索引。
MySQL创建组合索引
weixin_45151960的博客
03-31 6704
大家都知道索引是用来优化的主要因素，对于少量数据索引的影响并不大，对于几十万或百万级别以上数据的时候，单列索引的性能也不是很理想，组合索引可以大大的减少开销。
mysql中如何用命令创建联合索引
qq_42449963的博客
11-05 1万+
目录普通联合索引唯一联合索引普通联合索引和唯一联合索引的区别 普通联合索引 语法： create index 索引名称 on 表名(字段名称) 示例： create index firstIndex on student(id, name, address); 注意： 索引名称、表名、字段名称 都不要用引号括起来 对于联合索引而言，字段名称可以有多个，中间用英文逗号分隔即可 普通索引可以重复 结果： 唯一联合索引 语法： create unique index 索引名称 on 表名(字段名称
基于Elasticsearch Java API的参考手册
04-29
**Elasticsearch Java API详解** Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，广泛应用于大数据领域的实时分析和信息检索。Java API是Elasticsearch官方提供的与Elasticsearch服务器进行交互的...
ElasticSearch 7.6.1 整合 SpringBoot 快速使用教程
03-03
在本教程中，我们将深入探讨如何将Elasticsearch 7.6.1版本与Spring Boot应用程序进行集成，以便实现高效、灵活的全文检索和数据分析功能。Elasticsearch是一款开源的分布式搜索引擎，它提供了实时分析、搜索、存储...
ElasticSearch 7.0 版本
07-22
**Elasticsearch 7.0 版本详解** Elasticsearch 是一款强大的开源搜索引擎，以其分布式、实时、可扩展的特性而备受青睐。在7.0版本中，它带来了一系列重要更新和改进，旨在提高性能、优化用户体验以及增强数据处理...
ElasticSearch最全详细使用教程.docx
01-30
本文将深入探讨 Elasticsearch 的基本使用，包括入门、索引管理和映射详解。 一、快速入门 1. 集群健康状况检查：通过访问 `http://localhost:9200/_cat/health?v` 可以查看集群的状态，绿色表示所有功能正常，...
Elasticsearch-RestHighLevelClient基础操作
会走的鱼
07-19 2293
*** 更新索引结构//你已经创建好的索引名称 PutMappingRequest putMappingRequest = new PutMappingRequest(idx);
【ES】RestHighLevelClient自动创建按月索引如何实现(二)
ssdlleave的专栏
07-02 4782
一.本文基于【ES】RestHighLevelClient连接阿里ElasticSearch7.10(一) 基础环境之上。记录对于es处于java中的相关业务需要做按月索引的实现 https://blog.csdn.net/ssdlleave/article/details/107846094?spm=1001.2014.3001.5501 定义es gis-location模版kibana添加 POST _template/template-gis-location { "templ...
MySQL之添加联合唯一索引
weixin_39833509的博客
09-24 1479
一、联合唯一索引 项目中需要用到联合唯一索引: 例如:有以下需求:每个人每一天只有可能产生一条记录:处了程序约定之外,数据库本身也可以设定: 例如:t_aa 表中有aa,bb两个字段,如果不希望有2条一模一样的记录（即：aa字段的值可以重复； bb字段的值也可以重复，但是一条记录（aa,bb）组合值不允许重复）,需要给 t_aa 表添加多个字段的联合唯一索引: alter table t_aa add unique index(aa,bb); 例如: alter table use_info
SpringBoot调用ElasticSearch的RestHighLevelClient的功能详解（创建索引、新增数据、修改数据、批量操作、搜索数据等）
热门推荐
tc979907461的博客
04-09 1万+
1、概念 JavaREST客户端有两种模式： Java低级REST客户端和高级REST客户端。低级别的客户端通过http与Elasticearch集群通信，版本兼容性好。高级REST客户端是基于低级客户端API的封装，版本兼容性差。需要的Java1.8以上的版本。Elasticsearch需要6.0以上。 Maven依赖 由于ElasticSearch版本不同，可能导致一些问题。自己要选择好适合自...
Java 操作RestHighLevelClient基本使用
Charge8的博客
08-28 6828
Java 操作RestHighLevelClient基本使用
ElasticSearch7.3学习(十六)----RestHighLevelClient Java api实现索引的创建、删除、是否存在、关闭、开启
09-08 2786
注意：导入的包区别，不同的包创建索引的方式不同。博主亲身实践，具体体现在createIndexRequest.mapping()里面。读者可自行试验。可以看到上述两种方式导入的包的子类名是相同的，但是具体对索引的操作方式可能是不同的。具体的区别博主暂时还不清楚，后续若有进展再在此处更新。
oracle数据库索引失效情况总结
喜羊羊love红太狼
02-04 1529
下面是工作流activiti中的两张表act_hi_procinst、act_hi_taskinst关系是一对多（一个流程包含多个流程环节），一个是历史流程表，一个是历史流程环节表。经验证如果列中创建了索引，但是查询时含有is null 和 is not null则执行计划没有走该列，故该列的以图表熟悉。索引生效，Oracle 数据库使用索引范围扫描方式。这种扫描方式通过索引键值的范围来定位需要的数据。(单表act_hi_procinst已经在delete_reason_列上创建了索引 )
RestClient操作索引库
我要记录学习博客
06-02 465
ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。官方文档地址：https://www.elastic.co/guide/en/elasticsearch/client/index.html其中的Java Rest Client又包括两种：克隆地址：https://github.com/ZhongChunle/hotel-demo.git数据表结构 2、mapping映射分析 创建索引库，最关键的是mapping映射，而mapping映射要考虑
ES入门：实时搜索与倒排索引详解
ES入门与探索.pptx是一份针对Elasticsearch（ES）的详细介绍文档，主要关注于ES作为一款分布式搜索和分析引擎的基础概念、安装配置、核心功能以及与关系型数据库的区别。以下是关键知识点的详细解读： 1. **Elastic...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值