es基于数据库的远程字典热更新

最新推荐文章于 2023-05-31 13:49:30 发布
最新推荐文章于 2023-05-31 13:49:30 发布
阅读量1k 收藏 2
点赞数
分类专栏： java 文章标签： 数据库 elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43094085/article/details/127392731
版权
1.ik 热词及近义词 远程字典的获取方式

简单看下源码，这里需要注意的
1.每次轮询校验的时候设置了请求头 “If-Modified-Since”,“If-None-Match”
2.用 “Etag”和 “Last-Modified” 来确定文件是否发生变化
3.词库有更新的时候调用了 Dictionary.getSingleton().reLoadMainDict();, reLoadMainDict里调用了 loadRemoteExtDict() 来加载远程字典 然后 getRemoteWords 和 getRemoteWordsUnprivileged 来获取词条，获取词条的请求头并没有加上面两个属性

package org.wltea.analyzer.dic;
public class Monitor implements Runnable {
	.....
	....
	/**
	 * 监控流程：
	 *  ①向词库服务器发送Head请求
	 *  ②从响应中获取Last-Modify、ETags字段值，判断是否变化
	 *  ③如果未变化，休眠1min，返回第①步
	 * 	④如果有变化，重新加载词典
	 *  ⑤休眠1min，返回第①步
	 */

	public void runUnprivileged() {

		//超时设置
		RequestConfig rc = RequestConfig.custom().setConnectionRequestTimeout(10*1000)
				.setConnectTimeout(10*1000).setSocketTimeout(15*1000).build();

		HttpHead head = new HttpHead(location);
		head.setConfig(rc);

		//设置请求头
		if (last_modified != null) {
			head.setHeader("If-Modified-Since", last_modified);
		}
		if (eTags != null) {
			head.setHeader("If-None-Match", eTags);
		}

		CloseableHttpResponse response = null;
		try {

			response = httpclient.execute(head);

			//返回200 才做操作
			if(response.getStatusLine().getStatusCode()==200){

				if (((response.getLastHeader("Last-Modified")!=null) && !response.getLastHeader("Last-Modified").getValue().equalsIgnoreCase(last_modified))
						||((response.getLastHeader("ETag")!=null) && !response.getLastHeader("ETag").getValue().equalsIgnoreCase(eTags))) {

					// 远程词库有更新,需要重新加载词典，并修改last_modified,eTags
					 Dictionary.getSingleton().reLoadMainDict();
					last_modified = response.getLastHeader("Last-Modified")==null?null:response.getLastHeader("Last-Modified").getValue();
					eTags = response.getLastHeader("ETag")==null?null:response.getLastHeader("ETag").getValue();
				}
			}else if (response.getStatusLine().getStatusCode()==304) {
				//没有修改，不做操作
				//noop
			}else{
				logger.info("remote_ext_dict {} return bad code {}" , location , response.getStatusLine().getStatusCode() );
			}

		} catch (Exception e) {
			logger.error("remote_ext_dict {} error!",e , location);
		}finally{
			try {
				if (response != null) {
					response.close();
				}
			} catch (IOException e) {
				logger.error(e.getMessage(), e);
			}
		}
	}
}
....
....

/**
 * 词典管理类,单子模式
 */
public class Dictionary {
...
...
	void reLoadMainDict() {
		logger.info("start to reload ik dict.");
		// 新开一个实例加载词典，减少加载过程对当前词典使用的影响
		Dictionary tmpDict = new Dictionary(configuration);
		tmpDict.configuration = getSingleton().configuration;
		tmpDict.loadMainDict();
		tmpDict.loadStopWordDict();
		_MainDict = tmpDict._MainDict;
		_StopWords = tmpDict._StopWords;
		logger.info("reload ik dict finished.");
	}
	/**
	 * 加载主词典及扩展词典
	 */
	private void loadMainDict() {
		// 建立一个主词典实例
		_MainDict = new DictSegment((char) 0);

		// 读取主词典文件
		Path file = PathUtils.get(getDictRoot(), Dictionary.PATH_DIC_MAIN);
		loadDictFile(_MainDict, file, false, "Main Dict");
		// 加载扩展词典
		this.loadExtDict();
		// 加载远程自定义词库
		this.loadRemoteExtDict();
	}


	/**
	 * 加载远程扩展词典到主词库表
	 */
	private void loadRemoteExtDict() {
		List<String> remoteExtDictFiles = getRemoteExtDictionarys();
		for (String location : remoteExtDictFiles) {
			logger.info("[Dict Loading] " + location);
			List<String> lists = getRemoteWords(location);
			// 如果找不到扩展的字典，则忽略
			if (lists == null) {
				logger.error("[Dict Loading] " + location + " load failed");
				continue;
			}
			for (String theWord : lists) {
				if (theWord != null && !"".equals(theWord.trim())) {
					// 加载扩展词典数据到主内存词典中
					logger.info(theWord);
					_MainDict.fillSegment(theWord.trim().toLowerCase().toCharArray());
				}
			}
		}

	}
	private static List<String> getRemoteWords(String location) {
		SpecialPermission.check();
		return AccessController.doPrivileged((PrivilegedAction<List<String>>) () -> {
			return getRemoteWordsUnprivileged(location);
		});
	}
   }
	
	/**
	 * 从远程服务器上下载自定义词条
	 */
	private static List<String> getRemoteWordsUnprivileged(String location) {

		List<String> buffer = new ArrayList<String>();
		RequestConfig rc = RequestConfig.custom().setConnectionRequestTimeout(10 * 1000).setConnectTimeout(10 * 1000)
				.setSocketTimeout(60 * 1000).build();
		CloseableHttpClient httpclient = HttpClients.createDefault();
		CloseableHttpResponse response;
		BufferedReader in;
		HttpGet get = new HttpGet(location);
		get.setConfig(rc);
		try {
			response = httpclient.execute(get);
			if (response.getStatusLine().getStatusCode() == 200) {

				String charset = "UTF-8";
				// 获取编码，默认为utf-8
				HttpEntity entity = response.getEntity();
				if(entity!=null){
					Header contentType = entity.getContentType();
					if(contentType!=null&&contentType.getValue()!=null){
						String typeValue = contentType.getValue();
						if(typeValue!=null&&typeValue.contains("charset=")){
							charset = typeValue.substring(typeValue.lastIndexOf("=") + 1);
						}
					}

					if (entity.getContentLength() > 0 || entity.isChunked()) {
						in = new BufferedReader(new InputStreamReader(entity.getContent(), charset));
						String line;
						while ((line = in.readLine()) != null) {
							buffer.add(line);
						}
						in.close();
						response.close();
						return buffer;
					}
			}
			}
			response.close();
		} catch (IllegalStateException | IOException e) {
			logger.error("getRemoteWords {} error", e, location);
		}
		return buffer;
	}

......

近义词也是差不多的就不多看了，简单贴一点
git 地址 https://github.com/bells/elasticsearch-analysis-dynamic-synonym
不过 这里需要配一下analysis

"analysis": {
	"analyzer": {
		"my_ik_max_word": {
				"tokenizer": "ik_max_word",
				"filter": ["remote_synonym"]
		}
	},
	"filter": {
			"remote_synonym": {
				"type": "dynamic_synonym",
				"synonyms_path": "http://xxxx/${type}/remote_dic.txt",
				"interval": 30
			}
		},
}


 public class Monitor implements Runnable {

        private SynonymFile synonymFile;

        Monitor(SynonymFile synonymFile) {
            this.synonymFile = synonymFile;
        }

        @Override
        public void run() {
            if (synonymFile.isNeedReloadSynonymMap()) {
                synonymMap = synonymFile.reloadSynonymMap();
                for (AbsSynonymFilter dynamicSynonymFilter : dynamicSynonymFilters.keySet()) {
                    dynamicSynonymFilter.update(synonymMap);
                    logger.debug("success reload synonym");
                }
            }
        }
    }


public class RemoteSynonymFile implements SynonymFile {
	...
	...
	@Override
    public boolean isNeedReloadSynonymMap() {
        RequestConfig rc = RequestConfig.custom()
                .setConnectionRequestTimeout(10 * 1000)
                .setConnectTimeout(10 * 1000).setSocketTimeout(15 * 1000)
                .build();
        HttpHead head = AccessController.doPrivileged((PrivilegedAction<HttpHead>) () -> new HttpHead(location));
        head.setConfig(rc);

        // 设置请求头
        if (lastModified != null) {
            head.setHeader("If-Modified-Since", lastModified);
        }
        if (eTags != null) {
            head.setHeader("If-None-Match", eTags);
        }

        CloseableHttpResponse response = null;
        try {
            response = executeHttpRequest(head);
            if (response.getStatusLine().getStatusCode() == 200) { // 返回200 才做操作
                if (!response.getLastHeader(LAST_MODIFIED_HEADER).getValue()
                        .equalsIgnoreCase(lastModified)
                        || !response.getLastHeader(ETAG_HEADER).getValue()
                        .equalsIgnoreCase(eTags)) {

                    lastModified = response.getLastHeader(LAST_MODIFIED_HEADER) == null ? null
                            : response.getLastHeader(LAST_MODIFIED_HEADER)
                            .getValue();
                    eTags = response.getLastHeader(ETAG_HEADER) == null ? null
                            : response.getLastHeader(ETAG_HEADER).getValue();
                    return true;
                }
            } else if (response.getStatusLine().getStatusCode() == 304) {
                return false;
            } else {
                logger.info("remote synonym {} return bad code {}", location,
                        response.getStatusLine().getStatusCode());
            }
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                logger.error("failed to close http response", e);
            }
        }
        return false;
    }
	...
	...
 	/**
     * Download custom terms from a remote server
     */
    public Reader getReader() {
        Reader reader;
        RequestConfig rc = RequestConfig.custom()
                .setConnectionRequestTimeout(10 * 1000)
                .setConnectTimeout(10 * 1000).setSocketTimeout(60 * 1000)
                .build();
        CloseableHttpResponse response = null;
        BufferedReader br = null;
        HttpGet get = new HttpGet(location);
        get.setConfig(rc);
        try {
            response = executeHttpRequest(get);
            if (response.getStatusLine().getStatusCode() == 200) {
                String charset = "UTF-8"; // 获取编码，默认为utf-8
                if (response.getEntity().getContentType().getValue()
                        .contains("charset=")) {
                    String contentType = response.getEntity().getContentType()
                            .getValue();
                    charset = contentType.substring(contentType
                            .lastIndexOf('=') + 1);
                }

                br = new BufferedReader(new InputStreamReader(response
                        .getEntity().getContent(), charset));
                StringBuilder sb = new StringBuilder();
                String line;
                while ((line = br.readLine()) != null) {
                    logger.debug("reload remote synonym: {}", line);
                    sb.append(line)
                            .append(System.getProperty("line.separator"));
                }
                reader = new StringReader(sb.toString());
            } else reader = new StringReader("");
        } catch (Exception e) {
            logger.error("get remote synonym reader {} error!", location, e);
//            throw new IllegalArgumentException(
//                    "Exception while reading remote synonyms file", e);
            // Fix #54 Returns blank if synonym file has be deleted.
            reader = new StringReader("");
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                logger.error("failed to close bufferedReader", e);
            }
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                logger.error("failed to close http response", e);
            }
        }
        return reader;
    }
 }
2.实现

思路挺简单的
就是存一个最后修改时间
最后修改时间变了 证明新增了
存一个重构分词时间，
最后修改时间大于重构分词时间 ，就需要重构下分词

/**词条类**/
@Data
@TableName("ext_dict")
public class ExtDict extends BaseEntity {

    /**
     * id
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 扩展词
     */
    @NotNull(message = "热词不能为空", groups = { AddGroup.class})
    private String word;

    /**
     * 类型 0 热词 1近义词 2.停用词
     */
    private Integer type;

    /**
     * 近义词
     */
    private String synonym;

}

/** ctroller类**/

	 /**
     * 获取远程字典
     * @param type 字典类型， 0 热词 1 近义词 2 禁用词
     * @param request
     * @param response
     */
    @GetMapping("/{type}/remote_dic.txt")
    public void  getRemotDic(@PathVariable("type") int type,HttpServletRequest request,HttpServletResponse response) {
        ArrayList<String> headerNames = Collections.list(request.getHeaderNames());
        response.setContentType("text/plain");
        response.setCharacterEncoding("utf-8");
        String lastModified = RedisUtils.getCacheObject(REMOTE_DIC_LAST_MODIFY+ type +":").toString();
        if(StringUtils.isEmpty(lastModified)){
            lastModified=extDictService.queryLastModified(type)+"";
            RedisUtils.setCacheObject(REMOTE_DIC_LAST_MODIFY+type+":",lastModified);
        }
        response.setHeader("ETag","xxxxxxxxxxxxxxxxdsa");
        response.setDateHeader("Last-Modified",Long.valueOf(lastModified));
        //es轮询校验请求  无需返回字典数据
        if(headerNames.contains("If-None-Match") || headerNames.contains("If-Modified-Since")){
            return;
        }
        //非es校验请求 返回正常内容
        List<ExtDict> list = extDictService.queryListByType(type);
        PrintWriter writer=null;
        try {
            writer = response.getWriter();
            if (type==1){
                list = list.stream().map(exdict -> {
                    exdict.setWord(exdict.getWord() + "=>" + exdict.getSynonym());
                    return exdict;
                }).collect(Collectors.toList());
            }
            for (int i = 0; i < list.size(); i++) {
                writer.write(list.get(i).getWord()+"\n");
            }
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (writer!=null){
                writer.close();
            }
        }

        String status = RedisUtils.getCacheObject(REBUILD_ANALYSIS_STATUS);
        String time = RedisUtils.getCacheObject(REBUILD_ANALYSIS_TIME);

        //status 无值 进行初始化操作
        if(status==null){
            RedisUtils.setCacheObject(REBUILD_ANALYSIS_STATUS,ANALYSIS_STATUS_SUCCESS);
            RedisUtils.setCacheObject(REBUILD_ANALYSIS_TIME,System.currentTimeMillis()+"");
            return;
        }
        //进行重建分词
        if(!ANALYSIS_STATUS_UPDATING.equals(status) && StringUtils.compare(lastModified,time)>0){
            elasticSearchService.rebuildAnalysis();
        }
    }



/**Service*/
  /**
     * 重建分词
     * 用于远程扩展词典更新
     */
    @Override
    public void rebuildAnalysis() {
        UpdateByQueryRequest request =new UpdateByQueryRequest(DEFULT_INDEX_NAME);
        request.setConflicts("proceed");
        request.setQuery(QueryBuilders.matchAllQuery());
        request.setRefresh(true);

        restHighLevelClient.updateByQueryAsync(request, RequestOptions.DEFAULT, new 				ActionListener<BulkByScrollResponse>() {
            @Override
            public void onResponse(BulkByScrollResponse bulkByScrollResponse) {
                log.info("------------------重建分词成功");
                RedisUtils.setCacheObject(REBUILD_ANALYSIS_STATUS,ANALYSIS_STATUS_SUCCESS);
                RedisUtils.setCacheObject(REBUILD_ANALYSIS_TIME,System.currentTimeMillis()+"");
            }
            @Override
            public void onFailure(Exception e) {
                log.error("----------- -----重建分词失败",e);
                RedisUtils.setCacheObject(REBUILD_ANALYSIS_STATUS,ANALYSIS_STATUS_FAILED);
            }
        });
        RedisUtils.setCacheObject(REBUILD_ANALYSIS_STATUS,ANALYSIS_STATUS_UPDATING);
    }
mmmmm12342
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Elasticsearch7.17.5版本同义词热更新插件源码
12-07
支持7.16.3以上版本，修改对应的es版本即可，测试7.17.5也可使用
elasticsearch数据库
03-20
ES数据库,eelasticsearch-sql-2.2.0.1. nosql数据库
Elasticsearch数据库的连接客户端
03-24
图形化界面连接Elasticsearch,方便开发人员操作,elasticsearch的客户端比较出名的就是elasticsearch head 和Kibana了， 但是elasticsearch head已经停止更新，且样式老旧，功能不全； 而Kibana虽功能全面，但是启动麻烦，大部分功能用不上，很不灵活，该客户端使用十分方便，界面友好，即点即用
基于java+ ElasticSearch 的文件检索系统（源码+数据库）
06-18
基于 ElasticSearch 的文件检索系统（源码+数据库），项目经过测试，可完美运行！ 启动项目 IDEA打开项目，或者到处jar包运行接口，默认端口80，gitbook列表变更请修改spring.gitbook.ds 4. 数据初始化 /admin/createIndex 创建索引 /admin/update 更新文档 /admin/reset 清空es数据(不删除索引)和mysql数据 浏览器中顺序执行创建索引和更新文档调用即可。
elasticsearch ik分词器远程扩展词典放nginx服务器实现热更新不需重启es
m0_37592814的博客
03-28 2761
一、elasticearch 添加ik分词器并实现分词功能 ik分词器安装参看下：https://blog.csdn.net/chen_2890/article/details/83757022，
SpringBoot拓展IK远程动态词典（可以定义拓展）
hk1360154205的博客
01-29 778
自定义字典控制器     首先新建一个控制器用来处理Rest请求的添加删除词典，以及查询词典。 package com.topcom.test.es.controller; import org.springframework.http.MediaType; import org.springframework.web.bind.annotation.*; import javax.annotation.PostConstruct; import javax.se
Spring Boot实现扩展字段功能
奇艺诶
07-31 1934
前言 接口接收的Json在反序列化的过程中，有时候会遇到一些无法识别的属性（unrecognized properties），通常我们只要在Json处理类库上设置为忽略即可，但有时候作为中间服务，上下游服务希望提供一个透传功能。本文分享Jackson、Fastjson两个Json处理类库下，实现扩展字段收集透传功能。 Fastjson扩展字段实现 使用Fastjson类库，核心思路是通过自定义参数解析器来实现 1.自定义注解 /*** * 自定义注解标记对扩展字段的处理 */ @..
【Springboot系列】springboot扩展点大整理,赶紧收藏起来
我是香菜
05-31 2167
这些接口都属于Spring框架的一部分，可以通过在您的组件类中实现相应的接口并实现相应的方法来使用它们。通过使用这些扩展点，可以在应用程序的不同生命周期阶段插入自定义逻辑，例如应用程序启动前的准备、应用程序启动后的初始化、应用程序关闭时的清理等。：通过实现该接口，您的组件可以获取ApplicationContext（应用程序上下文）对象的引用，从而访问应用程序上下文中的Bean以及其他特定的Spring功能。这些接口提供了不同层面的扩展点，可以让您在Bean的生命周期中插入自定义逻辑。
springboot基于Elasticsearch6.x版本进行ES同义词、停用词（停止词）插件配置，远程词典热加载及数据库词典热加载总结，es停用词热更新，es同义词热更新
like_java_的博客
07-16 4179
前言：ES版本差异较大，建议跨版本的同学，可以先了解一下版本区别，建议不要跨版本使用插件或者进行项目调试。 本总结主要基于6.x版本的6.5.1（6.2.2实测可用)，分词器为IK，下载地址：https://github.com/medcl/elasticsearch-analysis-ik 不做ES入门普及，直入正题。 ES操作系统：win10（如ES部署在linux，相应操作需调整） ...
ElasticSearch第五篇：IK分词器，自定义扩展字典
不经意的博客
05-29 4299
一、什么是ik分词器 分词：即把一段中文或者别的划分成一个个的关键字，我们在搜索时候会把自己的信息进行分词，会把数据库中或者索引库中的数 据进行分词，然后进行一个匹配操作，默认的中文分词是每个字看成一个词，比如“我爱狂神”会被分为“我，“爱”，“狂”，“神”，这显 然是不符合要求的，所以我们需要安装中文分词器ik来解决这个问题， IK提供了两个分词算法：ik_smart和ik_max_word，其中ik_smart为最少切分，ik_max_word为最细粒度划分！ 二、如何使用 1.下载 各版本下载
ElasticSearch基于Mysql热更新IK词典项目
最新发布
10-31
ElasticSearch基于Mysql热更新IK词典项目
elasticsearch 相关知识
m0_37712622的博客
02-11 1658
es集群部署 windows 修改elasticsearch.yml配置文件 集群名称 cluster.name: wangyue-elasticsearch 节点名称,不能重复 node.name: node-1001 节点类型 node.master: true node.data: true 主机名称 network.host: localhost 端口号 http.port: 1001 通信端口 transport.tcp.port: 9301 根据通信端口查找(类似相互注册相互守望) discov
Elasticsearch，head插件，kibana以及ik分词器的安装与简单使用
qq_45100706的博客
06-30 454
Elasticsearch 是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据； 使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的Restful API来隐藏Lucence的复杂性，从而让全文搜索变得简单。 SQL：like %查询内容%，如果是大数据，就算有索引也十分慢 1.安装 开发工具：Postman、Curl、head、Google浏览器插件 1、安装ElasticSearch https://mirrors.huaweic
Elasticsearch及相关环境安装 - Windows
weixin_44117045的博客
05-28 1127
可以清晰的看到和管理Elasticsearch集群的各个节点。需要具备Java环境（1.8或11版本）推荐Java11。
ElasticSearch学习篇1_ES简介、安装使用(ES、head可视化、Kibana可视化、IK分词器)
xiaosi的博客
07-18 809
目录 Lucene简单概述 ElasticSearch概述 一、Lucene简单概述 概念 是一套信息检索工具包，也就是jar包，不包含搜索引擎系统 包含 索引结构、读写索引的工具、排序、搜搜规则、工具类等 ElasticSearch 和 Lucene关系 ES其实就是基于Lucene做了一些封装和增强！ 二、ElasticSearch概述 概述 是一个开源的高拓展的 分布式全文检索引擎，他可以近乎实时的存储、检索数据，本身拓展性很好，可以拓展到上百台服务器，处理PB级别的数据 es适用jav
ES 词库热更新(实现方式一：远程词库)
weixin_44276921的博客
10-24 1695
配置远程词库（“D:\EdgeDownLoad\elasticsearch-7.8.0-windows-x86_64\elasticsearch-7.8.0\plugins\analysis-ik\config\IKAnalyzer.cfg.xml”）），这两个词都是字符串类型，只要一个发生变化，改插件就会去抓取新词。要求：（前提安装ik词库。下载复制到plugin，重启即可）1、改http请求需要返回两个头部header（1、远程词库，2、修改源码整合数据库。一分钟执行一次API。
ElasticSearch（七）【扩展词、停用词配置】
Vinjcent
09-18 893
定义扩展词典和停用词典可以修改IK分词器中
elasticsearch分词器词库热更新三种方案
one
12-01 4424
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、本地文件读取方式二、远程扩展热更新 IK 分词三、重写ik源码连接mysql 一、本地文件读取方式 首先进入elasticsearch目录的plugins目录下，查看目录结构 2.进入confg目录下 创建文件mydic.dic 并添加:“我是中国人” 3.打开config目录下 IKAnalyzer.cfg.xml配置文件 vim IKAnalyzer.cfg.xml 修改内容如下： 4.保存启动es 观察日志 加
ES 使用IK远程扩展词库
weixin_49374214的博客
08-16 930
es IK远程扩展词库
elasticsearch 和数据库有什么区别
06-11
Elasticsearch和数据库也有很大的区别。虽然它们都可以用于存储数据，但是它们的应用场景和功能不同。 首先，数据库是一种用于存储和管理数据的软件系统，它可以存储和检索数据，并且支持SQL查询语言。而Elasticsearch是一种基于Lucene的全文搜索引擎，它专门用于处理文本数据，提供基于文本的搜索、聚合和分析功能。 其次，数据库通常用于事务性应用程序，例如电子商务网站或银行系统，需要支持ACID事务，确保数据的完整性和一致性。而Elasticsearch则通常用于非事务性应用程序，例如搜索引擎、日志分析和监控系统，需要快速地处理大量的文本数据。 最后，Elasticsearch是一个分布式系统，可以水平扩展，支持高可用性和容错性。而数据库也可以进行分布式部署，但通常需要额外的配置和管理。 综上所述，Elasticsearch和数据库在应用场景和功能上有很大的不同，需要根据具体的业务需求进行选择和使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值