前言

众所周知，在ES中有各种聚合方法能够是数据分析简单、高效。但是在繁杂的聚合方法中找到满足我们需求的那个，需要我们自己去实践。下面我就说明一下“访问量超过1000的人数”统计案例的实现。

需求

ES在使用过程中，我们公司有一个需求，就是需要统计活跃用户数，我们定义活跃用户数为：今日访问量超过1000的用户，所以我们统计活跃用户数的时候需要统计“访问量超过1000的人数”。

之前的做法

第一版统计活跃用户数的方法由于对复杂的聚合统计不熟悉的原因，就把统计分为了两步。 第一步：在ES中使用字段聚合每个用户的访问数量，数量大于1000；

查询语句

{
  "aggs": {
    "user": {
      "terms": {
        "field": "userId.keyword",
        "size": 10000,
        "order": {
          "_count": "desc"
        },
        "min_doc_count": "1000"
      }
    }
  },
  "size": 0,
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "startTime": {
              "gte": "now-4h",
              "lte": "now",
              "format": "epoch_millis"
            }
          }
        }
      ]
    }
  }
}

查询结果

{
  "took" : 203,
  "timed_out" : false,
  "_shards" : {
    "total" : 1565,
    "successful" : 1565,
    "skipped" : 1520,
    "failed" : 0
  },
  "hits" : {
    "total" : 67470,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "user" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "admin",
          "doc_count" : 46998
        },
        {
          "key" : "nameless",
          "doc_count" : 8416
        },
        {
          "key" : "li",
          "doc_count" : 2486
        },
        {
          "key" : "liu",
          "doc_count" : 2183
        },
        {
          "key" : "111111",
          "doc_count" : 1281
        }
      ]
    }
  }
}

第二步：从ES中获取第一步的统计结果，然后统计用户桶的个数，达到统计出个数的效果。

改进后的做法

改进后就是直接使用ES的查询，使用了sum_bucket聚合，是计算每个用户的用户ID独立数，也就是每个用户的用户ID独立数都是1，然后用桶聚合求和，得到所有的人数。 参考链接：[sum bucket聚合](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/search-aggregations-pipeline-sum-bucket-aggregation.html)

查询语句

{
  "aggs": {
    "usercount": {
      "sum_bucket": {
        "buckets_path": "usercount-bucket>usercount-metric"
      }
    },
    "usercount-bucket": {
      "terms": {
        "field": "userId.keyword",
        "size": 10,
        "order": {
          "_key": "desc"
        },
        "min_doc_count": "1000"
      },
      "aggs": {
        "usercount-metric": {
          "cardinality": {
            "field": "userId.keyword"
          }
        }
      }
    }
  },
  "size": 0,
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "x_st": {
              "gte": "now-4h",
              "lte": "now",
              "format": "epoch_millis"
            }
          }
        }
      ]
    }
  }
}

查询结果

{
  "took" : 106,
  "timed_out" : false,
  "_shards" : {
    "total" : 1565,
    "successful" : 1565,
    "skipped" : 1520,
    "failed" : 0
  },
  "hits" : {
    "total" : 63956,
    "max_score" : 0.0,
    "hits" : [ ]
  },
  "aggregations" : {
    "usercount-bucket" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "nameless",
          "doc_count" : 8278,
          "usercount-metric" : {
            "value" : 1
          }
        },
        {
          "key" : "liu",
          "doc_count" : 2142,
          "usercount-metric" : {
            "value" : 1
          }
        },
        {
          "key" : "li",
          "doc_count" : 1928,
          "usercount-metric" : {
            "value" : 1
          }
        },
        {
          "key" : "admin",
          "doc_count" : 44395,
          "usercount-metric" : {
            "value" : 1
          }
        },
        {
          "key" : "111111",
          "doc_count" : 1281,
          "usercount-metric" : {
            "value" : 1
          }
        }
      ]
    },
    "usercount" : {
      "value" : 5.0
    }
  }
}

xpack.security.enabled: true

./elasticsearch -d

./bin/elasticsearch-setup-passwords interactive

elasticsearch.username: "kibana"
elasticsearch.password: "123456"

output {
    elasticsearch {
      hosts => ["10.68.24.136:9200","10.68.24.137:9200"]
      index => "%{[indexName]}-%{+YYYY.MM.dd}"
      user => "logstash_system"
      password => "123456"
    }

本文始发于知乎Elasticsearch专栏：从MySQL建立Elasticsearch索引-索引

接上文从MySQL建立Elasticsearch索引-引言，本文介绍一下我们实现索引创建时的一些思路。

目标

框架以Jar包的形式提供，通过配置（XML）提供规则，支持插件开发，支持全量、增量等。

因为希望尽量减少开发量，所以不要求使用方提供平表，因此需要考虑如何将平表

概念

• 全量：即使用全部数据创建一个新的索引
• 增量：按照时间范围或者给定的规则，把变化的数据同步到ES
• 插件：本框架内定义了一个插件接口，用于特定需求自行开发，并接入到现有的配置文件中
• 分批参数：SQL中由框架填充的参数，类似${id}等

配置

以用户（users）为例，配置有三种文件：

1. users.mapping，保存了索引的配置，每次全量的时候会读取本文件进行索引创建
2. rule，规则文件，里面主要定义了对应SQL和插件的配置
   1. users-all.rule，全量规则，规则中以主表为主体，支持以Top、Limit的形式对数据进行分批获取，分批参数在SQL里可以定义为${id}，框架会自动填充该值，以保证能够拉取到全量的数据
   2. users-inc.rule，按照时间范围进行增量，分批参数支持在SQL中使用${startTime}和${endTime}
   3. users-spec.rule，按照指定的主表的主键，获取数据及更新索引的操作
   4. users-partial.rule，框架接入了阿里的Canal，本规则定义了各种表变化时，如果取到主表Id，以使用spec进行数据更新
3. users.plugin，以上的rule主要提供了主表数据的获取方法，plugin文件则提供了各种关联表的信息获取方式，可以使用SQL，或者自定义的插件

全量索引实现关键点

为了保证索引的性能、监控、正确性等，实现时进行了以下设计。

（一）索引的维护

ES使用分布式、Replica、Snapshot机制保证索引的有效及集群稳定性。我们综合考虑后决定放弃Snapshot机制，通过定时/不定时创建全新全量索引，索引名字以${indexName}-{yyyy-MM-dd}的格式定义。正进行全量的索引关联上${indexName}_F的别名，正在使用的索引关联上${indexName}的别名，这样代码里可以不用关心应该读取或者使用哪个索引，合适的场景使用合适的别名即可。

（二）索引的性能

此处专指创建索引的性能，ES的性能是老话题了。

首先，为了保证全量的性能，创建索引时会调整mapping参数，类似refresh_interval改成-1，number_of_replicas改成0，添加默认slowlog设置。

索引过程中，控制bulk请求体的总大小，保证合适的分批大小的数据一并提交到ES。如果失败简单重试三次，如果三次都失败则认为失败，退出并删除当前索引，以保证线上ES数据干净准确。

（三）索引的变更

索引完成后，检查当前索引文档数和正使用索引文档数差异，如果大于配置的阈值，则认为此次索引创建有问题，删除索引并退出；做强制合并，减少segments数，提高搜索性能；恢复refresh_interval、number_of_replicas等设置；等待新索引状态变成GREEN后，将${indexName}切换到新的索引上，以使新索引生效。

最后，检查以${indexName}-{yyyy-MM-dd}格式命名的索引有几份，将多于指定个数的较老的索引删除，将多于指定个数的索引状态改为Close。这样可以尽可能提供磁盘内存利用率，减少不必要的损耗，又能在一定程度上保证数据可用。

以上，即完成了全量索引的创建。

增量索引实现关键点

增量索引因为场景比较多，所以规则也分了几种：

• inc，使用${startTime}和${endTime}在SQL中代替时间范围，框架会自动保存上次执行时间，以使整个增量整体不断滚动更新。实际使用时，因为有多个关联表导致SQL写起来比较复杂，以及部分增量数据过大，对DB有一定压力，因此不推荐使用此种方式。数据相对简单的场景可以使用。
• spec，在知道主表数据变化范围的时候使用，也是目前我们推荐的一种方式。使用主键查找数据，所有的表都是主键查询，影响范围也很明确。
• partial，针对canal做了单独封装的规则，用户获取canal的变化类型（更新、删除），变化的主表Id，用于使用spec的方式进行数据更新。

暂时没有使用部分更新的原因是，关联表与主表的映射关系比较复杂，有1:1，1:N，M：N；并且目前按照主键更新数据的方式，对DB等压力不大；加上spec的方式逻辑清晰，有利于维护和开发。

扩展性

SQL不是万能的，比方说我们部分数据需要从其他微服务取，或者SQL逻辑复杂建议代码实现，这时候就可以使用我们的插件机制了。默认框架提供了一个很强大的插件，支持Distinct、Merge、Mapping等功能，可以满足80%的关联数据的场景了。其他的场景以及需要微服务的场景，支持用户自己实现指定插件，通过配置文件，即可接入现有的框架体系中。以此能支持目前我们全部需求。

下一篇，我们将分享我们搜索模块的实现思路。

本文始发于知乎Elasticsearch专栏：从MySQL建立Elasticsearch索引-引言

日常工作里，因业务需要大量使用了Elasticsearch。为了简化索引的开发工作，我们需要一个易用可扩展的MySQL到ES的同步框架，在比较了可以找到的各种开源框架&工具后，我们还是选择自行研发了一个，名字简单粗暴：es-common。

背景

16年我接手了并负责了部门所有业务的搜索系统，旧搜索系统是基于Lucene自研实现的一个搜索框架，包含了平表创建、全量索引、增量索引、搜索引擎四个部分基础功能的封装；另有一个管理系统，用于配置索引、字典等信息。框架的实现思路是通过建立平表，简化索引创建的过程。

接手该系统以后，各业务出现井喷式发展，各种需求铺天盖地，同时该系统的不稳定性也开始作妖，最早三个人的小团队每天都疲于奔命。解决现有问题的同时，也在查找更好的解决方案。于是Elasticsearch进入视野。 基于JSON的交互、分布式、数据与逻辑隔离、开箱即用、稳定等特性，使我们确定了向ES转型的计划。每个点都是现有系统没有解决的问题，具体的点就不吐槽了。

选择

我们的需求有：

1. 支持全量、增量建立索引，以使数据变更较快体现
2. 支持更新指定文档，以处理突发问题
3. 索引有版本控制，以防止出现问题无法快速回滚
4. 尽量减少代码开发，减少出错概率，更专注业务
5. 简单的出错处理，失败检测等
6. 支持插件化开发，提供额外数据
7. 支持简单的规则，类似合并同主键数据
8. 域名、AUTH不可见，以满足安全要求
9. 支持非MySQL来源的数据，因为微服务的存在，不是所有数据都能从DB获取到

当时的调用结果已经找不到了，那么按照现在可以搜索到的框架和工具来重新做调研好了。简单搜索了一下MySQL到ES的同步框架或者工具，有以下几个：

• elasticsearch-jdbc
• elasticsearch-river-mysql
• go-mysql-elasticsearch
• logstash-input-jdbc

这几个工具通过简单的配置，即可建立索引，但分析我们的需求，有以下需求无法满足：

1. 需要提供DB的URL、User和Password等，我们公司由于安全的考虑，是无法拿到这些参数的；
2. 有部分数据是通过微服务获取的，单纯的SQL是无法访问微服务的；
3. 有的表数据量比较大，需要分片多JOB同时处理，JDBC在这点上操作比较麻烦；
4. 增量是需要按照主键进行更新的，按照时间扫描对表压力比较大；
5. 类似工具无法走常规发布，有一定的发布风险

基于以上原因，我们选择了自己研发了一个框架，用来满足我们的需求。下篇文章讲介绍es-common的实现思路。

本文将详细介绍利用 ES 与 Hive 直接的数据交互；通过 Hive 外部表的方式，可以快速将 ES 索引数据映射到 Hive 中，使用易于上手的 Hive SQL 实现对数据的进一步加工。

一、开发环境

1、组件版本

• CDH 集群版本：6.0.1
• ES 版本：6.5.1
• Hive 版本：2.1.1
• ES-Hadoop 版本：6.5.1

2、Hive 简介

Hive 在 Hadoop 生态系统中扮演着数据仓库的角色，借助 Hive 可以方便地进行数据汇总、即席查询以及分析存储在 Hadoop 文件系统中的大型数据集。

Hive 通过类 SQL 语言（HSQL）对 Hadoop 上的数据进行抽象，这样用户可以通过 SQL 语句对数据进行定义、组织、操作和分析；在 Hive 中，数据集是通过表（定义了数据类型相关信息）进行定义的，用户可以通过内置运算符或用户自定义函数（UDF）对数据进行加载、查询和转换。

3、Hive 安装 ES-Hadoop

官方推荐的安装方式：

使用 add jar

add jar /path/elasticsearch-hadoop.jar

使用 hive.aux.jars.path

$ bin/hive --auxpath=/path/elasticsearch-hadoop.jar

修改配置(hive-site.xml)

<property>
  <name>hive.aux.jars.path</name>
  <value>/path/elasticsearch-hadoop.jar</value>
  <description>A comma separated list (with no spaces) of the jar files</description>
</property>

CDH6.X 推荐的安装方法

将 elasticsearch-hadoop.jar 复制到 Hive 的 auxlib 目录中，然后重启 Hive 即可。

cp elasticsearch-hadoop.jar /opt/cloudera/parcels/CDH/lib/hive/auxlib/

二、Hive 与 ElasticSearch 的数据交互

1、数据类型对照表

请务必注意，ES 中的类型是 index/_mapping 中对应的数据类型，非 _source 里面数据的类型。

2、建立 Hive 外部表

CREATE EXTERNAL TABLE default.surface(
    water_type STRING,
    water_level STRING,
    monitor_time TIMESTAMP,
    sitecode STRING,
    p492 DOUBLE,
    p311 DOUBLE,
    status STRING
)
STORED BY 'org.elasticsearch.hadoop.hive.EsStorageHandler'
TBLPROPERTIES(
    'es.resource'='ods_data_day_surface*/doc',
    'es.query'='?q=status:001'
    'es.nodes'='sky-01','es.port'='9200',
    'es.net.http.auth.user'='sky',
    'es.net.http.auth.pass'='jointsky',
    'es.date.format'='yyyy-MM-dd HH:mm:ss',
    'es.ser.reader.value.class'='com.jointsky.bigdata.hive.EsValueReader'
    'es.mapping.names'='waterType:water_type,monitortime:monitor_time'
);

3、配置项说明

es.resource

es.resource 用于设置 ES 资源的位置，默认该配置项同时设置了读和写的索引，当然也可以分别设置读写索引名称：

• es.resource.read：设置读取位置；
• es.resource.write：设置写入位置。

es.query

es.query 设置查询过滤条件，目前支持 uri query、query dsl、external resource 三种设置方式。

# uri (or parameter) query
es.query = ?q=costinl

# query dsl
es.query = { "query" : { "term" : { "user" : "costinl" } } }

# external resource
es.query = org/mypackage/myquery.json

es.mapping.names

es.mapping.names 用于设置 Hive 与 ES 的字段映射关系，如果不设置，则默认字段名不发生变化（即为 data type 区域定义的字段名）；此外该部分还用于定义 Hive 到 ES 的数据映射类型。

'es.mapping.names' = 'date:@timestamp , url:url_123 ')

其他通用字段的说明请参考文章：使用 ES-Hadoop 将 Spark Streaming 流数据写入 ES

4、自定义日期类型解析

目前将 ES 的 date 类型映射到 Hive 的 TIMESTAMP 类型时，ES-Hadoop 组件只能识别时间戳格式或者标准的 XSD 格式的日期字符串：

@Override
protected Object parseDate(Long value, boolean richDate) {
    return (richDate ? new TimestampWritable(new Timestamp(value)) : processLong(value));
}

@Override
protected Object parseDate(String value, boolean richDate) {
    return (richDate ? new TimestampWritable(new Timestamp(DatatypeConverter.parseDateTime(value).getTimeInMillis())) : parseString(value));
}

关于 XSD（XML Schema Date/Time Datatypes）可用参考文章：https://www.w3schools.com/xml/schema_dtypes_date.asp

为了兼容自定义的日期格式，需要编写自定义的日期读取类：

import org.apache.hadoop.hive.serde2.io.TimestampWritable;
import org.elasticsearch.hadoop.cfg.Settings;
import org.elasticsearch.hadoop.hive.HiveValueReader;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Date;

public class EsValueReader extends HiveValueReader {
    private String dateFormat;
    private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
    private static final String DEFAULT_DATE_FORMAT_MIN = "yyyy-MM-dd HH:mm";
    private static final String DEFAULT_DATE_FORMAT_HOUR = "yyyy-MM-dd HH";
    private static final String DEFAULT_DATE_FORMAT_DAY = "yyyy-MM-dd";

    @Override
    public void setSettings(Settings settings) {
        super.setSettings(settings);
        dateFormat = settings.getProperty("es.date.format");
    }

    @Override
    protected Object parseDate(String value, boolean richDate) {
        if (value != null && value.trim().length() > 0 && DEFAULT_DATE_FORMAT.equalsIgnoreCase(dateFormat)) {
            if (richDate){
                if (value.length() == 16){
                    return new TimestampWritable(new Timestamp(parseDate(value, DEFAULT_DATE_FORMAT_MIN).getTime()));
                }
                if (value.length() == 13){
                    return new TimestampWritable(new Timestamp(parseDate(value, DEFAULT_DATE_FORMAT_HOUR).getTime()));
                }
                if (value.length() == 10){
                    return new TimestampWritable(new Timestamp(parseDate(value, DEFAULT_DATE_FORMAT_DAY).getTime()));
                }
                return new TimestampWritable(new Timestamp(parseDate(value, DEFAULT_DATE_FORMAT).getTime()));
            }
            return parseString(value);
        }
        return super.parseDate(value, richDate);
    }

    /**
     * 解析日期,根據指定的格式進行解析.<br>
     * 如果解析錯誤,則返回null
     * @param stringDate 日期字串
     * @param format 日期格式
     * @return 日期型別
     */
    private static Date parseDate(String stringDate, String format) {
        if (stringDate == null) {
            return null;
        }
        try {
            return parseDate(stringDate, new String[] { format });
        } catch (ParseException e) {
            return null;
        }
    }

    public static Date parseDate(String str, String... parsePatterns) throws ParseException {
        return parseDateWithLeniency(str, parsePatterns, true);
    }

    private static Date parseDateWithLeniency(
            String str, String[] parsePatterns, boolean lenient) throws ParseException {
        if (str == null || parsePatterns == null) {
            throw new IllegalArgumentException("Date and Patterns must not be null");
        }

        SimpleDateFormat parser = new SimpleDateFormat();
        parser.setLenient(lenient);
        ParsePosition pos = new ParsePosition(0);
        for (String parsePattern : parsePatterns) {
            String pattern = parsePattern;
            if (parsePattern.endsWith("ZZ")) {
                pattern = pattern.substring(0, pattern.length() - 1);
            }
            parser.applyPattern(pattern);
            pos.setIndex(0);
            String str2 = str;
            if (parsePattern.endsWith("ZZ")) {
                str2 = str.replaceAll("([-+][0-9][0-9]):([0-9][0-9])$", "$1$2");
            }
            Date date = parser.parse(str2, pos);
            if (date != null && pos.getIndex() == str2.length()) {
                return date;
            }
        }
        throw new ParseException("Unable to parse the date: " + str, -1);
    }
}

上述代码的 Maven 依赖

<dependencies>
    <dependency>
        <groupId>org.apache.hive</groupId>
        <artifactId>hive-exec</artifactId>
        <version>2.1.1</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch-hadoop</artifactId>
        <version>6.5.4</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

自定义日期解析包的部署

代码编写完成后，将代码进行打包，然后将打包好的 jar 包放置到 Hive 的 auxlib 目录中，然后重启 Hive 即可；该步骤与 ES-Hadoop 的安装步骤一样。

在编写 Spark 程序从 Hive 中读取数据的时候，需要添加对该包的依赖以及对 ES-Hadoop 的依赖。

三、总结

经过上述的步骤，Hive 与 ES 的映射已经不成问题，如果想从 ES 中导出数据，可用借助 HSQL insert into table XXX select * from XXXXX; 的方式从 ES 中读取数据写入到 HDFS；当然通过更为复杂的 HSQL 可以将数据进行处理，并将数据重新写入到 ES 或者存储到 HDFS。

充分利用 ES 的查询、过滤和聚合，可以很好的去服务数据标准化、数据清洗、数据分布情况等 ETL 流程。

Any Code，Code Any！

扫码关注『AnyCode』，编程路上，一起前行。

为ES构建Stanford NLP分词插件

Stanford NLP？

Stanford分词器是斯坦福大学NLP团队维护的一个开源分词器，支持了包括中文、英文…的语言，而且除了分词之外，它还支持了包括词性分析、情感分析…的各种功能。\ 这俩是这个project的项目主页

• Home page
• GitHub page

Why Stanford core NLP？

  市面上确实会有很多很有名的开源分词器，比如IK、Jieba，还有一些其他团队和公司提供的开源/商用的分词器，他们各有优劣。但是在各种分词器上比较了一大堆的分词case之后，我们发现Stanford NLP似乎是最适合我们当前需求的一个，因为我们不仅仅需要分词，还需要一些包括情感分析之类在内的更多的一些功能。

我们公司是做金融数据的搜索推荐的，在对比了各家分词器之后我们老板觉得Stanford NLP的效果最好，但是作为算法出身的人，他实现了一套非常重的分词、排序、搜索的服务。

在对比如研报、财报之类的信息进行搜索的时候确实会比较有效，但是在对经济类的新闻进行搜索的时候就会显得十分的笨重。

基于这个背景，我开始试图在ES里面引入老板推崇的Stanford 分词器来适应他的搜索、分词的需要，同时也能够不通过他那个笨重的分词排序服务来对我们系统中大量的经济、金融类的新闻进行分词、索引，并提供和他自己分词效果类似的分词和检索服务。

Why this project

我在包括百度、某谷姓404网站、GitHub以及国内的中文社区（Elastic中文社区)在内的各种地方搜过也问过了，但是似乎没有一个直接开箱可用的分词插件。所以，我只剩一条路了，就是搭建一个自己的插件来引用这个分词器。

How

对ES来说，插件主要分为两个部分：

1. 让ES可以看到的部分（class extends Plugin）
2. 自己行使职能的部分（functional part）

plugin

1. 为了让ES可以加载我们的plugin，我们需要先继承Plugin类，然后我们这个是个分词器插件，所以还要实现AnalysisPlugin类
2. 看过ES源码或者其他分词器源码的同学应该会知道，分词器插件需要实现两个方法，一个用来提供tokenizer，一个是analyzer分别对应分词器中的这俩。
   • 重写Map<String, AnalysisModule.AnalysisProvider<TokenizerFactory>>是为了可以提供搜索用分词器
   • 重写Map<String, AnalysisModule.AnalysisProvider<AnalyzerProvider<? extends Analyzer>>>是为了可以提供索引用分词器
3. 在这个分词器里面我们主要是依靠Tokenizer来实现分词的

functional class

分词器，特别是Tokenizer主要是靠重写三个方法来实现分词的

1. incrementToken：用来确定每一个词元，输出每一个单词（字）以及它的位置、长度等
2. reset：用来重制分词结果
3. end：用来告诉ES，这段文本的分词已经结束了

所以我们主要需要重写的就是这仨方法，当然了，为了能让分词器正确的使用，我们还需要添加一些分词器的配置和初始化的内容，具体代码不写了可以参考我的git，主要讲两个坑：

1. ES是通过配置文件里的路径来寻找对应的插件类
2. 然后通过配置文件里的key和刚才提到的代码里的key来寻找对应的分词器，所以这俩地方不要写错了 #plugin-descriptor.properties: classname=org.elasticsearch.plugin.analysis.AnalysisSDPlugin #plugin-descriptor.properties: name=stanford-core-nlp
3. 在开发过程中由于有java-security的存在，所以需要通过AccessController来调用和加载我们需要的外部jar包

odds and ends

1. Stanford分词器里面包含了很多功能，目前我使用了分词的部分
2. 分词器自带词典文件，不过如果要做词典的修改可能需要解包，修改，再重新打包
3. 我现在hardcode了一大堆的标点符号在里面，后面可能会去优化一下部分逻辑
4. 待完成的功能还有其他功能包括情感分析之类的

also see

GitHub 地址