1. 常用热词词库的配置方式

1.采用IK 内置词库

优点：部署方便，不用额外指定其他词库位置
缺点：分词单一化，不能指定想分词的词条

2.IK 外置静态词库

优点：部署相对方便，可以通过编辑指定文件分词文件得到想要的词条
缺点：需要指定外部静态文件，每次需要手动编辑整个分词文件，然后放到指定的文件目录下，重启ES后才能生效

3.IK 远程词库

优点：通过指定一个静态文件代理服务器来设置IK分词的词库信息
缺点：需要手动编辑整个分词文件来进行词条的添加， IK源码中判断头信息Last-Modified ETag 标识来判断是否更新，有时不生效
结合上面的优缺点，决定采用Mysql作为外置热词词库，定时更新热词 和 停用词。

2. 准备工作

1.下载合适的ElasticSearch对应版本的IK分词器

https://github.com/medcl/elasticsearch-analysis-ik

2.我们来查看它config文件夹下的文件：

image.png

因为我本地安装的是ES是6.6.2版本，所以下载的IK为6.6.2的适配版

3.分析IKAnalyzer.cfg.xml 配置文件：

image.png

ext_dict：对应的扩展热词词典的位置，多个热词文件之间使用分号来进行间隔
ext_stopwords:对应扩展停用词词典位置，多个之间用分号进行间隔
remote_ext_dict：远程扩展热词位置 如：https://xxx.xxx.xxx.xxx/ext_hot.txt
remote_ext_stopwords：远程扩展停用词位置 如：https://xxx.xxx.xxx.xxx/ext_stop.txt

4.Dictionary类

Dictionary中单例方法public static synchronized Dictionary initial(Configuration cfg)

  1. public static synchronized Dictionary initial(Configuration cfg) {
  2.     if (singleton == null) {
  3.         synchronized (Dictionary.class) {
  4.             if (singleton == null) {
  5.                 singleton = new Dictionary(cfg);
  6.                 singleton.loadMainDict();
  7.                 singleton.loadSurnameDict();
  8.                 singleton.loadQuantifierDict();
  9.                 singleton.loadSuffixDict();
  10.                 singleton.loadPrepDict();
  11.                 singleton.loadStopWordDict();
  12.                 if(cfg.isEnableRemoteDict()){
  13.                     // 建立监控线程
  14.                     for (String location : singleton.getRemoteExtDictionarys()) {
  15.                         // 10 秒是初始延迟可以修改的 60是间隔时间 单位秒
  16.                         pool.scheduleAtFixedRate(new Monitor(location), 10, 60, TimeUnit.SECONDS);
  17.                     }
  18.                     for (String location : singleton.getRemoteExtStopWordDictionarys()) {
  19.                         pool.scheduleAtFixedRate(new Monitor(location), 10, 60, TimeUnit.SECONDS);
  20.                     }
  21.                 }
  23.                 return singleton;
  24.             }
  25.         }
  26.     }
  27.     return singleton;
  28. }

initial中 load*中方法是利用config中其他文本文件来初始化Dictionary中的上面声明的成员变量：
_MainDict ： 主词典对象，也是用来存储热词的对象
_SurnameDict ： 姓氏词典
_QuantifierDict ： 量词词典，例如1个中的 个 2两种的两
_SuffixDict ： 后缀词典
_PrepDict ： 副词/介词词典
_StopWords ： 停用词词典

3. 修改Dictionary源码

1. Dictionary类：更新词典 this.loadMySQLExtDict()

  1. /**
  2.  * 加载主词典及扩展词典
  3.  */
  4. private void loadMainDict() {
  5.    // 建立一个主词典实例
  6.    _MainDict = new DictSegment((char) 0);
  8.    // 读取主词典文件
  9.    Path file = PathUtils.get(getDictRoot(), Dictionary.PATH_DIC_MAIN);
  10.    loadDictFile(_MainDict, file, false, "Main Dict");
  11.    // 加载扩展词典
  12.    this.loadExtDict();
  13.    // 加载远程自定义词库
  14.    this.loadRemoteExtDict();
  15.        // 2. 从mysql加载词典
  16.        this.loadMySQLExtDict();
  17. }
  18.    private static Properties prop = new Properties();
  20.    static {
  21.        try {
  22.            Class.forName("com.mysql.jdbc.Driver");
  23.        } catch (ClassNotFoundException e) {
  24.            logger.error("error", e);
  25.        }
  26.    }
  28. /**
  29.  * @Title: loadMySQLExtDict
  30.  * @Description: 从mysql加载热更新词典
  31.  * @author 石鹏程
  32.  * @created 2019年3月3日
  33.  * @param:
  34.  * @return: void
  35.  * @throws
  36.  */
  37. private void loadMySQLExtDict() {
  38.    Connection conn = null;
  39.    Statement stmt = null;
  40.    ResultSet rs = null;
  42.    try {
  43.       Path file = PathUtils.get(getDictRoot(), "jdbc-reload.properties");
  44.       prop.load(new FileInputStream(file.toFile()));
  46.       /*logger.info("[==========]jdbc-reload.properties");
  47.       for(Object key : prop.keySet()) {
  48.          logger.info("[==========]" + key + "=" + prop.getProperty(String.valueOf(key)));
  49.       }
  51.       logger.info("[==========]query hot dict from mysql, " + prop.getProperty("jdbc.reload.sql") + "......");
  52.            */
  54.       conn = DriverManager.getConnection(
  55.             prop.getProperty("jdbc.url"),
  56.             prop.getProperty("jdbc.user"),
  57.             prop.getProperty("jdbc.password"));
  58.       stmt = conn.createStatement();
  59.       rs = stmt.executeQuery(prop.getProperty("jdbc.reload.sql"));
  61.       int i=0;
  62.       while(rs.next()) {
  63.          String theWord = rs.getString("word");
  64.          //logger.info("[==========]hot word from mysql: " + theWord);
  65.          _MainDict.fillSegment(theWord.trim().toCharArray());
  66.          i++;
  67.       }
  68.            logger.info("[==========] 加载分词数量: " + i+"个");
  70.    } catch (Exception e) {
  71.       logger.error("erorr", e);
  72.    } finally {
  73.       if(rs != null) {
  74.          try {
  75.             rs.close();
  76.          } catch (SQLException e) {
  77.             logger.error("error", e);
  78.          }
  79.       }
  80.       if(stmt != null) {
  81.          try {
  82.             stmt.close();
  83.          } catch (SQLException e) {
  84.             logger.error("error", e);
  85.          }
  86.       }
  87.       if(conn != null) {
  88.          try {
  89.             conn.close();
  90.          } catch (SQLException e) {
  91.             logger.error("error", e);
  92.          }
  93.       }
  94.    }
  95. }

2. Dictionary类：更新停用词 this.loadMySQLStopwordDict()

  1. /**
  2.  * 加载用户扩展的停止词词典
  3.  */
  4. private void loadStopWordDict() {
  5.    // 建立主词典实例
  6.    _StopWords = new DictSegment((char) 0);
  8.    // 读取主词典文件
  9.    Path file = PathUtils.get(getDictRoot(), Dictionary.PATH_DIC_STOP);
  10.    loadDictFile(_StopWords, file, false, "Main Stopwords");
  12.    // 加载扩展停止词典
  13.    List<String> extStopWordDictFiles = getExtStopWordDictionarys();
  14.    if (extStopWordDictFiles != null) {
  15.       for (String extStopWordDictName : extStopWordDictFiles) {
  16.          logger.info("[Dict Loading] " + extStopWordDictName);
  18.          // 读取扩展词典文件
  19.          file = PathUtils.get(extStopWordDictName);
  20.          loadDictFile(_StopWords, file, false, "Extra Stopwords");
  21.       }
  22.    }
  24.    // 加载远程停用词典
  25.    List<String> remoteExtStopWordDictFiles = getRemoteExtStopWordDictionarys();
  26.    for (String location : remoteExtStopWordDictFiles) {
  27.       logger.info("[Dict Loading] " + location);
  28.       List<String> lists = getRemoteWords(location);
  29.       // 如果找不到扩展的字典，则忽略
  30.       if (lists == null) {
  31.          logger.error("[Dict Loading] " + location + "加载失败");
  32.          continue;
  33.       }
  34.       for (String theWord : lists) {
  35.          if (theWord != null && !"".equals(theWord.trim())) {
  36.             // 加载远程词典数据到主内存中
  37.             logger.info(theWord);
  38.             _StopWords.fillSegment(theWord.trim().toLowerCase().toCharArray());
  39.          }
  40.       }
  41.    }
  42.        //3.加载自定义停用词
  43.        this.loadMySQLStopwordDict();
  44. }
  47.    /**
  48.     * 从mysql加载停用词
  49.     */
  50.    private void loadMySQLStopwordDict() {
  51.        Connection conn = null;
  52.        Statement stmt = null;
  53.        ResultSet rs = null;
  55.        try {
  56.            Path file = PathUtils.get(getDictRoot(), "jdbc-reload.properties");
  57.            prop.load(new FileInputStream(file.toFile()));
  58.            conn = DriverManager.getConnection(
  59.                    prop.getProperty("jdbc.url"),
  60.                    prop.getProperty("jdbc.user"),
  61.                    prop.getProperty("jdbc.password"));
  62.            stmt = conn.createStatement();
  63.            rs = stmt.executeQuery(prop.getProperty("jdbc.reload.stopword.sql"));
  65.            int i=0;
  66.            while(rs.next()) {
  67.                String theWord = rs.getString("word");
  68.                //logger.info("[==========]hot stopword from mysql: " + theWord);
  69.                _StopWords.fillSegment(theWord.trim().toCharArray());
  70.                i++;
  71.            }
  72.            logger.info("[==========] 加载停用词数量: " + i+"个");
  73.        } catch (Exception e) {
  74.            logger.error("erorr", e);
  75.        } finally {
  76.            if(rs != null) {
  77.                try {
  78.                    rs.close();
  79.                } catch (SQLException e) {
  80.                    logger.error("error", e);
  81.                }
  82.            }
  83.            if(stmt != null) {
  84.                try {
  85.                    stmt.close();
  86.                } catch (SQLException e) {
  87.                    logger.error("error", e);
  88.                }
  89.            }
  90.            if(conn != null) {
  91.                try {
  92.                    conn.close();
  93.                } catch (SQLException e) {
  94.                    logger.error("error", e);
  95.                }
  96.            }
  97.        }
  98.    }

3. 对外暴露方法：

  1. public void reLoadMainDict() {
  3.    try {
  4.       Path file = PathUtils.get(getDictRoot(), "jdbc-reload.properties");
  5.       prop.load(new FileInputStream(file.toFile()));
  6.       String enble = prop.getProperty("ik.mysql.enable");
  7.       logger.info("ik.mysql.enable:"+enble);
  8.       if(enble.equals("yes")){
  9.          //logger.info("重新加载词典...");
  10.          // 新开一个实例加载词典，减少加载过程对当前词典使用的影响
  11.          Dictionary tmpDict = new Dictionary(configuration);
  12.          tmpDict.configuration = getSingleton().configuration;
  13.          tmpDict.loadMainDict();
  14.          tmpDict.loadStopWordDict();
  15.          _MainDict = tmpDict._MainDict;
  16.          _StopWords = tmpDict._StopWords;
  17.          //logger.info("重新加载词典完毕...");
  19.          //logger.info("当前排队线程数:"+((ThreadPoolExecutor)pool).getQueue().size());
  20.          //logger.info("当前活动线程数:"+((ThreadPoolExecutor)pool).getActiveCount());
  21.          //logger.info("执行完成线程数:"+((ThreadPoolExecutor)pool).getCompletedTaskCount());
  22.          //logger.info("总线程数(排队线程数+活动线程数+执行完成线程数):"+ ((ThreadPoolExecutor)pool).getTaskCount());
  23.       }else{
  24.          logger.info("ik分词mysql热加载关闭......");
  25.       }
  26.    } catch (IOException e) {
  27.       logger.info("ik分词器 - jdbc-reload.properties文件解析出错....");
  28.       e.printStackTrace();
  29.    }
  32. }

4. HotDictReloadThread Runnable实现类，去执行 reLoadMainDict 加载热词

image.png

最后代码为定时调用：
image.png

其中一些细节就不讲述了。
image.png

4. 打包

因为我们链接的是mysql数据库，所以maven项目要引入mysql驱动：

  1. <dependency> 
  2.     <groupId>mysql</groupId> 
  3.     <artifactId>mysql-connector-java</artifactId> 
  4.     <version>6.0.6</version> 
  5. </dependency>

准备完毕：执行打包。 mvn clean package
image.png

打包完毕。 上传，重启进行实验啦

5.实验结果

数据库插入记录
image.png
image.png

  1. GET http://127.0.0.1:9200/g_index/_analyze?text=王者荣耀&analyzer=ik_max_word
  2. {
  3.     "tokens": [
  4.         {
  5.             "token": "王者荣耀",
  6.             "start_offset": 0,
  7.             "end_offset": 5,
  8.             "type": "CN_WORD",
  9.             "position": 0
  10.         },
  11.         {
  12.             "token": "王者",
  13.             "start_offset": 1,
  14.             "end_offset": 3,
  15.             "type": "CN_WORD",
  16.             "position": 1
  17.         },
  18.         {
  19.             "token": "王",
  20.             "start_offset": 1,
  21.             "end_offset": 2,
  22.             "type": "CN_WORD",
  23.             "position": 2
  24.         },
  25.         {
  26.             "token": "者",
  27.             "start_offset": 2,
  28.             "end_offset": 3,
  29.             "type": "CN_WORD",
  30.             "position": 3
  31.         },
  32.         {
  33.             "token": "荣耀",
  34.             "start_offset": 3,
  35.             "end_offset": 5,
  36.             "type": "CN_WORD",
  37.             "position": 4
  38.         },
  39.         {
  40.             "token": "荣",
  41.             "start_offset": 3,
  42.             "end_offset": 4,
  43.             "type": "CN_WORD",
  44.             "position": 5
  45.         },
  46.         {
  47.             "token": "耀",
  48.             "start_offset": 4,
  49.             "end_offset": 5,
  50.             "type": "CN_CHAR",
  51.             "position": 6
  52.         } 
  53.     ]
  54. }