IK 分词器字典热加载实现思路

最新推荐文章于 2024-06-17 10:14:48 发布
原创 最新推荐文章于 2024-06-17 10:14:48 发布 · 1.1k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#elasticsearch

记得前几年在上一家公司基于 Solr 做搜索服务的时候，也是有 IK 分词器词库自动更新的场景，当时是在 CSDN 上花钱下了个可以从数据库自动更新词库的 JAR 包。碰巧最近也有朋友遇到了相似了问题，这次决定自己研究下，不花钱。

本文 IK 分词器版本：6.x，Elasticsearch 版本：6.6.2。

源码地址：https://gitee.com/dongguabai/ik-hot

IK 分词器是一款非常优秀的开源中文分词。也可以配置自定义词库：

<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict">custom/mydict.dic;custom/single_word_low_freq.dic</entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords">custom/ext_stopword.dic</entry>
 	<!--用户可以在这里配置远程扩展字典 -->
	<entry key="remote_ext_dict">location</entry>
 	<!--用户可以在这里配置远程扩展停止词字典-->
	<entry key="remote_ext_stopwords">http://xxx.com/xxx.dic</entry>
</properties>

但是有个问题是默认当词库需要更新时要重启 ES 才能生效，这个在线上肯定是不可接受的。

IK 分词器官方也提供了一种远程热更新词库的方式：

目前该插件支持热更新 IK 分词，通过上文在 IK 配置文件中提到的如下配置

	<!--用户可以在这里配置远程扩展字典 -->
	<entry key="remote_ext_dict">location</entry>
	<!--用户可以在这里配置远程扩展停止词字典-->
	<entry key="remote_ext_stopwords">location</entry>

其中 location 是指一个 url，比如 http://yoursite.com/getCustomDict，该请求只需满足以下两点即可完成分词热更新。

  1. 该 http 请求需要返回两个头部(header)，一个是 Last-Modified，一个是 ETag，这两者都是字符串类型，只要有一个发生变化，该插件就会去抓取新的分词进而更新词库。
  2. 该 http 请求返回的内容格式是一行一个分词，换行符用 \n 即可。

满足上面两点要求就可以实现热更新分词了，不需要重启 ES 实例。

可以将需自动更新的热词放在一个 UTF-8 编码的 .txt 文件里，放在 nginx 或其他简易 http server 下，当 .txt 文件修改时，http server 会在客户端请求该文件时自动返回相应的 Last-Modified 和 ETag。可以另外做一个工具来从业务系统提取相关词汇，并更新这个 .txt 文件。

这个方案有时候不太适合项目中的要求。有时候我们更希望那种简单点的，比如我们把要添加、删除的词存入数据库，然后 IK 分词器隔一段时间自己去更新。

那么现在的问题就变成：

  • 怎么加载数据库中的词语到 IK 的词库中？
  • 词语是全量同步还是增量同步？

分析

先看 IK 分词器的配置：

<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict">custom/mydict.dic;custom/single_word_low_freq.dic</entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords">custom/ext_stopword.dic</entry>
 	<!--用户可以在这里配置远程扩展字典 -->
	<entry key="remote_ext_dict">location</entry>
 	<!--用户可以在这里配置远程扩展停止词字典-->
	<entry key="remote_ext_stopwords">http://xxx.com/xxx.dic</entry>
</properties>

因为官方已经提供了通过远程自动更新，可以照葫芦画瓢，先看看官方源码是怎么实现远程更新字典的。

org.wltea.analyzer.dic.Dictionary#initial 方法：

	public static synchronized void initial(Configuration cfg) {
		if (singleton == null) {
			synchronized (Dictionary.class) {
				if (singleton == null) {

					singleton = new Dictionary(cfg);
					singleton.loadMainDict();
					singleton.loadSurnameDict();
					singleton.loadQuantifierDict();
					singleton.loadSuffixDict();
					singleton.loadPrepDict();
					singleton.loadStopWordDict();

					if(cfg.isEnableRemoteDict()){
						// 建立监控线程
						for (String location : singleton.getRemoteExtDictionarys()) {
							// 10 秒是初始延迟可以修改的 60是间隔时间 单位秒
							pool.scheduleAtFixedRate(new Monitor(location), 10, 60, TimeUnit.SECONDS);
						}
						for (String location : singleton.getRemoteExtStopWordDictionarys()) {
							pool.scheduleAtFixedRate(new Monitor(location), 10, 60, TimeUnit.SECONDS);
						}
					}

				}
			}
		}
	}

可以发现默认是 10s 延迟后每 60s 从远程加载字典。

再看 org.wltea.analyzer.dic.Monitor#run 方法：

	public void run() {
		SpecialPermission.check();
		AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
			this.runUnprivileged();
			return null;
		});
	}

再看 org.wltea.analyzer.dic.Monitor#runUnprivileged 方法：

/**
	 * 监控流程：
	 *  ①向词库服务器发送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);
			}
		}
	}

其实可以看出 IK 内部通过请求远程的 remote_ext_dict 和remote_ext_stopwords，将响应参数与 Monitor 内部的 last_modified 或 eTags 进行比较，从而判断字典是否需要更新，当字典需要更新的话就会调用 org.wltea.analyzer.dic.Dictionary#reLoadMainDict 方法重新加载字典：

	void reLoadMainDict() {
		logger.info("重新加载词典...");
		// 新开一个实例加载词典，减少加载过程对当前词典使用的影响
		Dictionary tmpDict = new Dictionary(configuration);
		tmpDict.configuration = getSingleton().configuration;
		tmpDict.loadMainDict();
		tmpDict.loadStopWordDict();
		_MainDict = tmpDict._MainDict;
		_StopWords = tmpDict._StopWords;
		logger.info("重新加载词典完毕...");
	}

可以发现停用词和扩展词就是重新 load 了一下，那么是从哪里 load 的呢，看看 org.wltea.analyzer.dic.Dictionary#loadStopWordDict 方法：

	/**
	 * 加载用户扩展的停止词词典
	 */
	private void loadStopWordDict() {
		// 建立主词典实例
		_StopWords = new DictSegment((char) 0);

		// 读取主词典文件
		Path file = PathUtils.get(getDictRoot(), Dictionary.PATH_DIC_STOP);
		loadDictFile(_StopWords, file, false, "Main Stopwords");

		// 加载扩展停止词典
		List<String> extStopWordDictFiles = getExtStopWordDictionarys();
		if (extStopWordDictFiles != null) {
			for (String extStopWordDictName : extStopWordDictFiles) {
				logger.info("[Dict Loading] " + extStopWordDictName);

				// 读取扩展词典文件
				file = PathUtils.get(extStopWordDictName);
				loadDictFile(_StopWords, file, false, "Extra Stopwords");
			}
		}

		// 加载远程停用词典
		List<String> remoteExtStopWordDictFiles = getRemoteExtStopWordDictionarys();
		for (String location : remoteExtStopWordDictFiles) {
			logger.info("[Dict Loading] " + location);
			List<String> lists = getRemoteWords(location);
			// 如果找不到扩展的字典，则忽略
			if (lists == null) {
				logger.error("[Dict Loading] " + location + "加载失败");
				continue;
			}
			for (String theWord : lists) {
				if (theWord != null && !"".equals(theWord.trim())) {
					// 加载远程词典数据到主内存中
					logger.info(theWord);
					_StopWords.fillSegment(theWord.trim().toLowerCase().toCharArray());
				}
			}
		}

可以看到加载是分两种，一个是加载配置的本地停用词典，另一个是加载的远程停用词典。这里也能看出 remote_ext_stopwords 有两个作用：判断是否有字典更新和获取更新的字典数据，比如我们想搭建一个 HTTP 服务去处理词语更新的话，就需要一个 URL 提供两种不同的访问方式，最好的方式其实是提供一个远程文件地址，如http://192.120.180.100:8080/hot_ext.dic，然后其他的字典更新服务更新这个文件。

目前比较流行的方式是轮训从数据库中获取最新的字典。

基于 MySQL 更新字典的实现

在这之前先要考虑上面提出的问题：是全量更新还是增量更新。字典本身数据量并不大，充其量也就小几十万，一般也不会把所有的词语都放在词库中，而且数据库中的字典数据是为整个 ES 集群服务的，增量的话考虑的细节就会很多，同时在进行字典更新的时候是不会影响先有字典的使用的，综合来看全量更新更好。

接下来实现基于 MySQL 热更新字典。

先建立两张表：

CREATE TABLE stop_words ( word VARCHAR ( 200 ) );
CREATE TABLE ext_words ( word VARCHAR ( 200 ) );

其中 stop_words 是停用词表，ext_words 是扩展词表。

添加 MySQL 依赖：

 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.48</version>
 </dependency>

这里要注意的是，根据 Maven 的规则，需要在 src\main\assemblies\plugin.xml 中添加配置使得数据库相关依赖一并打包：

<dependencySet>
   <outputDirectory/>
      <useProjectArtifact>true</useProjectArtifact>
      <useTransitiveFiltering>true</useTransitiveFiltering>
      <includes>
          <include>mysql:mysql-connector-java</include>
      </includes>
</dependencySet>

既然使用了 MySQL，那肯定要有数据相关的配置，那这个配置文件放在哪呢。其实在 IK 的源码中可以看到 PathUtils 这个类，已经有现成的方法获取 IK 配置文件夹下的配置文件了，所以这里的 mysql.properties 文件就放在跟 IKAnalyzer.cfg.xml 同级的文件夹下。

mysql.url=jdbc:mysql://10.224.221.111:3306/test
mysql.user=root
mysql.password=root

接下来开始编写热更新字典的代码。再理一下思路，我们要实现的就是开一个线程每隔一段时间从 MySQL 中捞出数据，直接更新本地字典，且加载过程几乎不会对当前词典的使用产生影响。

还有一个问题是从 MySQL 热加载的代码写在哪。其实 IK 原生的从远程加载自定义词库就在 org.wltea.analyzer.dic.Dictionary#loadMainDict 方法中：

	/**
	 * 加载主词典及扩展词典
	 */
	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();
	}

完全可以照葫芦画瓢，把从 MySQL 加载的代码也写在这里，好处是可以复用 org.wltea.analyzer.dic.Dictionary#reLoadMainDict 方法。但是要注意的是 org.wltea.analyzer.dic.Dictionary#reLoadMainDict 方法也会调用 org.wltea.analyzer.dic.Dictionary#loadMainDict 方法。也就是说如果我们将 MySQL 热加载的代码写在这个地方，那此时就不要再同时使用 IK 原生的远程热加载方式了。

这里为了保留 IK 原生的远程热加载方式，就将代码写在 org.wltea.analyzer.dic.Dictionary#initial 处。

接下来开始代码实现：

	/**
	 * 词典初始化 由于IK Analyzer的词典采用Dictionary类的静态方法进行词典初始化
	 * 只有当Dictionary类被实际调用时，才会开始载入词典， 这将延长首次分词操作的时间 该方法提供了一个在应用加载阶段就初始化字典的手段
	 * 
	 * @return Dictionary
	 */
	public static synchronized void initial(Configuration cfg) {
		if (singleton == null) {
			synchronized (Dictionary.class) {
				if (singleton == null) {

					singleton = new Dictionary(cfg);
					singleton.loadMainDict();
					singleton.loadSurnameDict();
					singleton.loadQuantifierDict();
					singleton.loadSuffixDict();
					singleton.loadPrepDict();
					singleton.loadStopWordDict();

					if(cfg.isEnableRemoteDict()){
						// 建立监控线程
						for (String location : singleton.getRemoteExtDictionarys()) {
							// 10 秒是初始延迟可以修改的 60是间隔时间 单位秒
							pool.scheduleAtFixedRate(new Monitor(location), 10, 60, TimeUnit.SECONDS);
						}
						for (String location : singleton.getRemoteExtStopWordDictionarys()) {
							pool.scheduleAtFixedRate(new Monitor(location), 10, 60, TimeUnit.SECONDS);
						}
					}
					new Thread(()->{
						Properties pro = new Properties();
						try {
							pro.load(new FileInputStream(PathUtils.get(singleton.getDictRoot(), "mysql.properties").toFile()));
						} catch (IOException e) {
							e.printStackTrace();
						}

						while (true){
							try {
								TimeUnit.SECONDS.sleep(5);
								logger.info("开始从MySQL加载.....");
								try (Connection conn = DriverManager.getConnection(pro.getProperty("mysql.url"), pro.getProperty("mysql.user"), pro.getProperty("mysql.password"))) {
									reLoadFromMySQL(conn, pro);
								}
								logger.info("从MySQL加载完成.....");
							}catch (Exception e){
								logger.error("load from mysql error..",e);
							}
						}
					}).start();
				}
			}
		}
	}

	static {
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException ignored) {
		}
	}

	private static void reLoadFromMySQL(Connection conn, Properties pro) throws Exception {
		logger.info("从MySQL重新加载词典...start");
		// 新开一个实例加载词典，减少加载过程对当前词典使用的影响
		Dictionary tmpDict = new Dictionary(getSingleton().configuration);
		tmpDict.configuration = getSingleton().configuration;
		tmpDict.loadMainDict();
		tmpDict.reloadExtDictFromMySQL(conn);
		tmpDict.loadStopWordDict();
		tmpDict.reloadStopDictFromMySQL(conn);
		getSingleton()._MainDict = tmpDict._MainDict;
		getSingleton()._StopWords = tmpDict._StopWords;
		logger.info("从MySQL重新加载词典完毕...end");
	}

	private void reloadStopDictFromMySQL(Connection conn) throws SQLException {
		try (Statement statement = conn.createStatement();ResultSet rs = statement.executeQuery("select word from stop_words")) {
			while(rs.next()) {
				String word = rs.getString("word");
				if (word != null && !word.isBlank()){
					_StopWords.fillSegment(word.toCharArray());
				}
			}
		}
	}

	private void reloadExtDictFromMySQL(Connection conn) throws SQLException {
		try (Statement statement = conn.createStatement();ResultSet rs = statement.executeQuery("select word from ext_words")) {
			while(rs.next()) {
				String word = rs.getString("word");
				if (word != null && !word.isBlank()){
					_MainDict.fillSegment(word.toCharArray());
				}
			}
		}
	}

接下来打包：

➜  elasticsearch-analysis-ik git:(6.x-hot) ✗ mvn clean package -Dmaven.test.skip=true

将打包好的 elasticsearch-analysis-ik-6.5.0.zip 解压后放在 ES 的 plugins/ik 目录中：

在这里插入图片描述

重新启动 ES。

会出现如下异常：

java.lang.ExceptionInInitializerError: null
	at java.lang.Class.forName0(Native Method) ~[?:1.8.0_202]
	at java.lang.Class.forName(Class.java:264) ~[?:1.8.0_202]
	at com.mysql.jdbc.NonRegisteringDriver.<clinit>(NonRegisteringDriver.java:98) ~[?:?]
	at java.lang.Class.forName0(Native Method) ~[?:1.8.0_202]
	at java.lang.Class.forName(Class.java:264) ~[?:1.8.0_202]
	at org.wltea.analyzer.dic.Dictionary.<clinit>(Dictionary.java:201) ~[?:?]
	at org.wltea.analyzer.cfg.Configuration.<init>(Configuration.java:40) ~[?:?]
	at org.elasticsearch.index.analysis.IkTokenizerFactory.<init>(IkTokenizerFactory.java:15) ~[?:?]
	at org.elasticsearch.index.analysis.IkTokenizerFactory.getIkSmartTokenizerFactory(IkTokenizerFactory.java:23) ~[?:?]
	at org.elasticsearch.index.analysis.AnalysisRegistry.buildMapping(AnalysisRegistry.java:374) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.index.analysis.AnalysisRegistry.buildTokenizerFactories(AnalysisRegistry.java:184) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.index.analysis.AnalysisRegistry.build(AnalysisRegistry.java:158) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.index.IndexService.<init>(IndexService.java:164) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.index.IndexModule.newIndexService(IndexModule.java:397) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.indices.IndicesService.createIndexService(IndicesService.java:519) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.indices.IndicesService.verifyIndexMetadata(IndicesService.java:592) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.gateway.Gateway.performStateRecovery(Gateway.java:129) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.gateway.GatewayService$1.doRun(GatewayService.java:228) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.common.util.concurrent.ThreadContext$ContextPreservingAbstractRunnable.doRun(ThreadContext.java:759) ~[elasticsearch-6.6.2.jar:6.6.2]
	at org.elasticsearch.common.util.concurrent.AbstractRunnable.run(AbstractRunnable.java:37) ~[elasticsearch-6.6.2.jar:6.6.2]
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) ~[?:1.8.0_202]
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) ~[?:1.8.0_202]
	at java.lang.Thread.run(Thread.java:748) [?:1.8.0_202]
Caused by: java.security.AccessControlException: access denied ("java.lang.RuntimePermission" "setContextClassLoader")
	at java.security.AccessControlContext.checkPermission(AccessControlContext.java:472) ~[?:1.8.0_202]
	at java.security.AccessController.checkPermission(AccessController.java:884) ~[?:1.8.0_202]
	at java.lang.SecurityManager.checkPermission(SecurityManager.java:549) ~[?:1.8.0_202]
	at java.lang.Thread.setContextClassLoader(Thread.java:1474) ~[?:1.8.0_202]
	at com.mysql.jdbc.AbandonedConnectionCleanupThread$1.newThread(AbandonedConnectionCleanupThread.java:66) ~[?:?]
	at java.util.concurrent.ThreadPoolExecutor$Worker.<init>(ThreadPoolExecutor.java:619) ~[?:1.8.0_202]
	at java.util.concurrent.ThreadPoolExecutor.addWorker(ThreadPoolExecutor.java:932) ~[?:1.8.0_202]
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1367) ~[?:1.8.0_202]
	at java.util.concurrent.Executors$DelegatedExecutorService.execute(Executors.java:668) ~[?:1.8.0_202]
	at com.mysql.jdbc.AbandonedConnectionCleanupThread.<clinit>(AbandonedConnectionCleanupThread.java:70) ~[?:?]

在网上找的解决方案是在 IK 的 config 中创建文件 socketPolicy.policy，内容为：

grant {
   permission java.net.SocketPermission "*:*","accept,connect,resolve";
   permission java.lang.RuntimePermission "setContextClassLoader";
};

同时在 ES 中的 config 目录文件 jvm.option 添加如下代码配置上面的文件路径：

-Djava.security.policy=/Users/dongguabai/develope/elasticsearch/es/elasticsearch-6.6.2/plugins/ik/config/socketPolicy.policy

在使用原生的 IK 分词器的分词效果如下：

GET /ik_index3/_analyze
{
  "text": "携手打造的小清新风格的东湖樱花邮局",
  "analyzer": "ik_max_word"
}

{
  "tokens" : [
    {
      "token" : "携手",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "打造",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 1
    },
    {
      "token" : "的",
      "start_offset" : 4,
      "end_offset" : 5,
      "type" : "CN_CHAR",
      "position" : 2
    },
    {
      "token" : "小",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "CN_CHAR",
      "position" : 3
    },
    {
      "token" : "清新",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 4
    },
    {
      "token" : "清",
      "start_offset" : 6,
      "end_offset" : 7,
      "type" : "CN_CHAR",
      "position" : 5
    },
    {
      "token" : "新风格",
      "start_offset" : 7,
      "end_offset" : 10,
      "type" : "CN_WORD",
      "position" : 6
    },
    {
      "token" : "新风",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 7
    },
    {
      "token" : "风格",
      "start_offset" : 8,
      "end_offset" : 10,
      "type" : "CN_WORD",
      "position" : 8
    },
    {
      "token" : "的",
      "start_offset" : 10,
      "end_offset" : 11,
      "type" : "CN_CHAR",
      "position" : 9
    },
    {
      "token" : "东湖",
      "start_offset" : 11,
      "end_offset" : 13,
      "type" : "CN_WORD",
      "position" : 10
    },
    {
      "token" : "樱花",
      "start_offset" : 13,
      "end_offset" : 15,
      "type" : "CN_WORD",
      "position" : 11
    },
    {
      "token" : "邮局",
      "start_offset" : 15,
      "end_offset" : 17,
      "type" : "CN_WORD",
      "position" : 12
    }
  ]
}

可以看到“的”也算一个词，同时“小清新”没有算作一个词。

接下来分别往停用词表 stop_words 和扩展词表 ext_words 中插入一条数据：

INSERT into stop_words (word) VALUES ('的');
INSERT into ext_words (word) VALUES ('小清新');

再来看分词效果：

{
  "tokens" : [
    {
      "token" : "携手",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "打造",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 1
    },
    {
      "token" : "小清新",
      "start_offset" : 5,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "小",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "CN_CHAR",
      "position" : 3
    },
    {
      "token" : "清新",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 4
    },
    {
      "token" : "新风格",
      "start_offset" : 7,
      "end_offset" : 10,
      "type" : "CN_WORD",
      "position" : 5
    },
    {
      "token" : "新风",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 6
    },
    {
      "token" : "风格",
      "start_offset" : 8,
      "end_offset" : 10,
      "type" : "CN_WORD",
      "position" : 7
    },
    {
      "token" : "东湖",
      "start_offset" : 11,
      "end_offset" : 13,
      "type" : "CN_WORD",
      "position" : 8
    },
    {
      "token" : "樱花",
      "start_offset" : 13,
      "end_offset" : 15,
      "type" : "CN_WORD",
      "position" : 9
    },
    {
      "token" : "邮局",
      "start_offset" : 15,
      "end_offset" : 17,
      "type" : "CN_WORD",
      "position" : 10
    }
  ]
}

发现已经没有“的”，且多了一个“小清新”。

接下来如果我将“小清新”从扩展词表中删除：

delete from ext_words;

再看分词效果：

{
  "tokens" : [
    {
      "token" : "携手",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "打造",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 1
    },
    {
      "token" : "小",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "CN_CHAR",
      "position" : 2
    },
    {
      "token" : "清新",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 3
    },
    {
      "token" : "清",
      "start_offset" : 6,
      "end_offset" : 7,
      "type" : "CN_CHAR",
      "position" : 4
    },
    {
      "token" : "新风格",
      "start_offset" : 7,
      "end_offset" : 10,
      "type" : "CN_WORD",
      "position" : 5
    },
    {
      "token" : "新风",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 6
    },
    {
      "token" : "风格",
      "start_offset" : 8,
      "end_offset" : 10,
      "type" : "CN_WORD",
      "position" : 7
    },
    {
      "token" : "东湖",
      "start_offset" : 11,
      "end_offset" : 13,
      "type" : "CN_WORD",
      "position" : 8
    },
    {
      "token" : "樱花",
      "start_offset" : 13,
      "end_offset" : 15,
      "type" : "CN_WORD",
      "position" : 9
    },
    {
      "token" : "邮局",
      "start_offset" : 15,
      "end_offset" : 17,
      "type" : "CN_WORD",
      "position" : 10
    }
  ]
}

可以发现“小清新”已经不见了，这也就实现了字典的热加载功能。

References

  • https://github.com/medcl/elasticsearch-analysis-ik
  • https://blog.csdn.net/qq_40592041/article/details/107856588
  • https://blog.yourtion.com/java-access-denied-socketpermission-solution.html

欢迎关注公众号：
在这里插入图片描述

Elasticsearch 核心技术（七）：IK 中文分词器的安装、使用、自定义字典
水滴的博客
03-09 2078
IK 中文分词器是 Elasticsearch 的一个插件，它集成了 Lucene IK analyzer，支持自定义字典。
IK Analyzer 热更新自定义词典
Tyshawn的博客
11-15 1407
IK Analyzer的GitHub地址: https://github.com/medcl/elasticsearch-analysis-ik IK Analyzer 自己有一个热更新方案, 但不推荐使用, 我们可以修改下源码, 从mysql读取中读取自定义的词典. 本文Elasticsearch安装的是5.2.0版本的, 所以对应的IK Analyzer也是安装的5.2.0版本. 自定义...
elaseticsearch 配置ik分词器的热更新_Spring Boot实现热部署，热部署好不好用有待讨论...
weixin_39875760的博客
11-26 189
程序员强心剂在人生路上，无论是遭遇阻碍，还是伤痛来袭，别紧张难过，要知道心的方向，由你掌控，必先好好爱自己，才能前进或转向。就像素黑所说，就等你一个决定，生命将瞬间改变。前言热部署是现在比较火的技术，其实并没有多难，但是每个人对于热部署的看法却不相同，但是今天只介绍方法，讨论好不好用的事情就交给大家的评论了。在Spring Boot实现代码热部署是一件很简单的事情，代码的修改可以自动部署并重新热启...
【热更新IK词典】ElasticSearch IK 自动热更新原理与实现
weixin_33786077的博客
08-21 1387
一、热更新原理 　　elasticsearch开启加载外部词典功功能后，会每60s间隔进行刷新字典。具体原理代码如下所示： public void loadDic(HttpServletRequest req,HttpServletResponse response){ String eTag =req.getParameter("If-None-Match"); tr...
es ik 词库添加词语_五、IK自定义词库及远程热更新
weixin_42340136的博客
01-13 421
IKAnalyzer.cfg.xml为IK分词器的配置文件一、IKAnalyzer.cfg.xml文件分析propertiesSYSTEM"http://java.sun.com/dtd/properties.dtd">IKAnalyzer扩展配置二、新建词库1.到elasticsearch/plugins/ik/config添加词库vim phone_words.dic输入你定义的...
Java开源分词系统IKAnalyzer学习（七） 词库加载分词
xiaomin1991222的专栏
12-10 266
  词库加载模块的源码： Java开源分词系统IKAnalyzer学习（四） 词库加载源代码——Dictionary类 Java开源分词系统IKAnalyzer学习（五） 词库加载源代码——DictSegmenty类 Java开源分词系统IKAnalyzer学习（六） 词库加载源代码——Hit类   首先这个词典管理类Dictionary类采用的设计模式是单立模式，实现的代码： ...
ik mysql热加载分词_Elasticsearch 之（25）重写IK分词器源码来基于mysql热更新词库...
weixin_29730445的博客
01-19 375
热更新在上一节《IK分词器配置文件讲解以及自定义词库》自定义词库，每次都是在es的扩展词典中，手动添加新词语，很坑(1)每次添加完，都要重启es才能生效，非常麻烦(2)es是分布式的，可能有数百个节点，你不能每次都一个一个节点上面去修改es不停机，直接我们在外部某个地方添加新的词语，es中立即热加载到这些新词语热更新的方案(1)修改ik分词器源码，然后手动支持从mysql中每隔一定时间，自动加载新...
ik分词器的热词更新_IK分词器：支持不同索引使用不同的字典进行独立切词
weixin_39598501的博客
01-13 776
IK Analysis for ElasticsearchThe IK Analysis plugin integrates Lucene IK analyzer (http://code.google.com/p/ik-analyzer/) into elasticsearch, support customized dictionary.Analyzer: ik_smart , ik_max_...
ik分词器动态从数据库中加载数据无需重启
qq_41978323的博客
12-19 1274
IK分词器动态从数据库中加载数据
elasticsearch安装ik分词器，连接mysql8.0实现热加载词库，踩坑
hqd1870299的博客
06-10 935
安装的是elasticsearch7.7.1 从https://github.com/medcl/elasticsearch-analysis-ik下载ik源码（导入idea）： 1：修改pom.xml 版本号改为自己的ES对应版本 如：7.7.1 添加mysql的jar包（和mysql数据库对应） 2.修改源码参考：https://blog.csdn.net/qq_35524586/article/details/88553670 坑：我自己加上驱动加载后打包到elastics...
es2.4.0版本对应1.10.0ik分词器
11-16
3. **热更新词典**：IK分词器支持在线热更新词典，无需重启ES服务即可生效。 总的来说，IK分词器1.10.0与ES 2.4.0的结合，为中文文本的索引和检索提供了强大的支持，通过合理的配置和优化，可以进一步提升搜索质量...
IK词典配置文件
03-01
IK词典配置文件 zip文件 解压即可得到
IK分词器热刷新词库实践分享
最新发布
whatsyournamejack的专栏
06-17 1550
本篇文章介绍了ElasticSearch分词器相关内容，介绍了什么是分词器，什么是ik分词器，ik分词器目前存在的问题以及如何通过修改ik分词器的源码来实现热更新词库。Elasticsearch是基于倒排索引来实现搜索功能，而倒排索引的基础就是分词。Elasticsearch默认的分词器支持英文的分词，因为分词很简单，基本基于空格就可以分出来，而汉语的分词则困难很多。
ElasticSearch5.0——IK词库加载
weixin_30872157的博客
09-27 91
Dictionary ConfigurationIKAnalyzer.cfg.xml can be located at {conf}/analysis-ik/config/IKAnalyzer.cfg.xml or {plugins}/elasticsearch-analysis-ik-*/config/IKAnalyzer.cfg.xml [html] <?...
elasticsearch5中ik词库远程热加载
jasnet_u的博客
05-07 4394
如题，本篇我们介绍下如何让ES自动从远程服务器中获取最新的词库（热加载，无须重启ES服务）。 IK自定义词库是支持远程热加载的，配置起来也非常简单。先看下官方的说明   ： remote_ext_dict该 http 请求需要返回两个头部(header)，一个是 Last-Modified，一个是 ETag，这两者都是字符串类型，只要有一个发生变化，该插件就会去抓取新的分词进而更新词库。该 htt...
安装IK分词器 + 扩展词典配置 + 停用词典配置
ros275229的博客
03-22 2240
安装IK分词器 + 扩展词典配置 + 停用词典配置
Java Word分词器插件使用
qq_38981109的博客
04-07 405
maven依赖 下面展示一些 内联代码片。 <!-- https://mvnrepository.com/artifact/org.apdplat/word --> <dependency> <groupId>org.apdplat</groupId> <artifactId>word</artifactId> <version>1.3&
ik分词 动态增加词库 mysql_ElasticSearch 重写IK分词器源码设置mysql热词更新词库
weixin_42440389的博客
01-27 817
常用热词词库的配置方式1.采用IK 内置词库优点：部署方便，不用额外指定其他词库位置缺点：分词单一化，不能指定想分词的词条2.IK 外置静态词库优点：部署相对方便，可以通过编辑指定文件分词文件得到想要的词条缺点：需要指定外部静态文件，每次需要手动编辑整个分词文件，然后放到指定的文件目录下，重启ES后才能生效3.IK 远程词库优点：通过指定一个静态文件代理服务器来设置IK分词的词库信息缺点：需要手动...
Elasticsearch ik分词器修改源码实现从mysql中定时更新词库
moxiong3212的博客
02-20 2643
下载源码导入eclispe请参考我的上一篇文章ik分词器安装 第一步 修改pom文件 加入mysql驱动jar 如图所示 第二步 修改Java类 1.在Dictionary.java文件中新增一个方法 /** * 批量加载新停用词条 * * @param words * Collection&lt;Str...
Elasticsearch IK分词器热加载词库插件
综合上述知识点，我们可以看到文件信息涉及Elasticsearch及其IK分词器插件的自定义修改、数据库集成、热加载机制和相关Java库文件的使用。所有这些细节共同构成了一个高级的Elasticsearch应用环境，涵盖了从基础架构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值