java keytool证书工具使用小结

Keytool 是一个Java数据证书的管理工具 ,Keytool将密钥（key）和证书（certificates）存在一个称为keystore的文件中在keystore里，包含两种数据:密钥实体（Key entity）-密钥（secret key）或者是私钥和配对公钥（采用非对称加密）可信任的证书实体（trusted certificate entries）-只包含公钥.
JDK中keytool常用参数说明（不同版本有差异，详细可参见【附录】中的官方文档链接）:

• -genkey 在用户主目录中创建一个默认文件”.keystore”,还会产生一个mykey的别名，mykey中包含用户的公钥、私钥和证书(在没有指定生成位置的情况下,keystore会存在用户系统默认目录)
• -alias 产生别名 每个keystore都关联这一个独一无二的alias，这个alias通常不区分大小写
• -keystore 指定密钥库的名称(产生的各类信息将不在.keystore文件中)
• -keyalg 指定密钥的算法 (如 RSA DSA，默认值为：DSA)
• -validity 指定创建的证书有效期多少天(默认 90)
• -keysize 指定密钥长度 （默认 1024）
• -storepass 指定密钥库的密码(获取keystore信息所需的密码)
• -keypass 指定别名条目的密码(私钥的密码)
• -dname 指定证书发行者信息 其中： “CN=名字与姓氏,OU=组织单位名称,O=组织名称,L=城市或区域名 称,ST=州或省份名称,C=单位的两字母国家代码”
• -list 显示密钥库中的证书信息 keytool -list -v -keystore 指定keystore -storepass 密码
• -v 显示密钥库中的证书详细信息
• -export 将别名指定的证书导出到文件 keytool -export -alias 需要导出的别名 -keystore 指定keystore -file 指定导出的证书位置及证书名称 -storepass 密码
• -file 参数指定导出到文件的文件名
• -delete 删除密钥库中某条目 keytool -delete -alias 指定需删除的别 -keystore 指定keystore – storepass 密码
• -printcert 查看导出的证书信息 keytool -printcert -file g:\sso\michael.crt
• -keypasswd 修改密钥库中指定条目口令 keytool -keypasswd -alias 需修改的别名 -keypass 旧密码 -new 新密码 -storepass keystore密码 -keystore sage
• -storepasswd 修改keystore口令 keytool -storepasswd -keystore g:\sso\michael.keystore(需修改口令的keystore) -storepass pwdold(原始密码) -new pwdnew(新密码)
• -import 将已签名数字证书导入密钥库 keytool -import -alias 指定导入条目的别名 -keystore 指定keystore -file 需导入的证书

在上一篇博客《模拟 HTTP 请求》中，我们分别介绍了两种方法来进行 HTTP 的模拟请求：HttpURLConnection 和 HttpClient ，到目前为止这两种方法都工作的很好，基本上可以实现我们需要的 GET/POST 方法的模拟。对于一个爬虫来说，能发送 HTTP 请求，能获取页面数据，能解析网页内容，这相当于已经完成 80% 的工作了。只不过对于剩下的这 20% 的工作，还得花费我们另外 80% 的时间 :-)

在这篇博客里，我们将介绍剩下 20% 的工作中最为重要的一项：如何在 Java 中使用 HTTP 代理，代理也是爬虫技术中的重要一项。你如果要大规模的爬别人网页上的内容，必然会对人家的网站造成影响，如果你太拼了，就会遭人查封。要防止别人查封我 们，我们要么将自己的程序分布到大量机器上去，但是对于资金和资源有限的我们来说这是很奢侈的；要么就使用代理技术，从网上捞一批代理，免费的也好收费的 也好，或者购买一批廉价的 VPS 来搭建自己的代理服务器。关于如何搭建自己的代理服务器，后面有时间的话我再写一篇关于这个话题的博客。现在有了一大批代理服务器之后，就可以使用我们这 篇博客所介绍的技术了。

一、简单的 HTTP 代理

我们先从最简单的开始，网上有很多免费代理，直接上百度搜索 “免费代理” 或者 “HTTP 代理” 就能找到很多（虽然网上能找到大量的免费代理，但它们的安全性已经有很多文章讨论过了，也有专门的文章对此进行调研的，譬如这篇文章，我在这里就不多作说明，如果你的爬虫爬取的信息并没有什么特别的隐私问题，可以忽略之，如果你的爬虫涉及一些例如模拟登录之类的功能，考虑到安全性，我建议你还是不要使用网上公开的免费代理，而是搭建自己的代理服务器比较靠谱）。

1.1 HttpURLConnection 使用代理

HttpURLConnection 的 openConnection() 方法可以传入一个 Proxy 参数，如下：

OK 了，就这么简单！

不仅如此，我们注意到 Proxy 构造函数的第一个参数为枚举类型 Proxy.Type.HTTP ，那么很显然，如果将其修改为 Proxy.Type.SOCKS 即可以使用 SOCKS 代理。

1.2 HttpClient 使用代理

由于 HttpClient 非常灵活，使用 HttpClient 来连接代理有很多不同的方法。最简单的方法莫过于下面这样：

和上一篇中使用 HttpClient 发送请求的代码几乎一样，只是 httpclient.execute() 方法多加了一个参数，第一参数为 HttpHost 类型，我们这里设置成我们的代理即可。

这里要注意一点的是，虽然这里的 new HttpHost() 和上面的 new Proxy() 一样，也是可以指定协议类型的，但是遗憾的是 HttpClient 默认是不支持 SOCKS 协议的，如果我们使用下面的代码：

将会直接报协议不支持异常：

org.apache.http.conn.UnsupportedSchemeException: socks protocol is not supported

如果希望 HttpClient 支持 SOCKS 代理，可以参看这里：How to use Socks 5 proxy with Apache HTTP Client 4? 通过 HttpClient 提供的 ConnectionSocketFactory 类来实现。

虽然使用这种方式很简单，只需要加个参数就可以了，但是其实看 HttpClient 的代码注释，如下：

可以看到第一个参数 target 并不是代理，它的真实作用是 执行请求的目标主机，这个解释有点模糊，什么叫做 执行请求的目标主机？代理算不算执行请求的目标主机呢？因为按常理来讲，执行请求的目标主机 应该是要请求 URL 对应的站点才对。如果不算的话，为什么这里将 target 设置成代理也能正常工作？这个我也不清楚，还需要进一步研究下 HttpClient 的源码来深入了解下。

除了上面介绍的这种方式（自己写的，不推荐使用）来使用代理之外，HttpClient 官网还提供了几个示例，我将其作为推荐写法记录在此。

第一种写法是使用 RequestConfig 类，如下：

第二种写法是使用 RoutePlanner 类，如下：

二、使用系统代理配置

我们在调试 HTTP 爬虫程序时，常常需要切换代理来测试，有时候直接使用系统自带的代理配置将是一种简单的方法。以前在做 .Net 项目时，程序默认使用 Internet 网络设置中配的代理，遗憾的是，我这里说的系统代理配置指的 JVM 系统，而不是操作系统，我还没找到简单的方法来让 Java 程序直接使用 Windows 系统下的代理配置。

尽管如此，系统代理使用起来还是很简单的。一般有下面两种方式可以设置 JVM 的代理配置：

2.1 System.setProperty

Java 中的 System 类不仅仅是用来给我们 System.out.println() 打印信息的，它其实还有很多静态方法和属性可以用。其中 System.setProperty() 就是比较常用的一个。

可以通过下面的方式来分别设置 HTTP 代理，HTTPS 代理和 SOCKS 代理：

这里有三点要说明：

1. 系统默认先使用 HTTP/HTTPS 代理，如果既设置了 HTTP/HTTPS 代理，又设置了 SOCKS 代理，SOCKS 代理会起不到作用
2. 由于历史原因，注意 socksProxyHost 和 socksProxyPort 中间没有小数点
3. HTTP 和 HTTPS 代理可以合起来缩写，如下：

2.2 JVM 命令行参数

可以使用 System.setProperty() 方法来设置系统代理，也可以直接将这些参数通过 JVM 的命令行参数来指定。如果你使用的是 Eclipse ，可以按下面的步骤来设置：

1. 按顺序打开：Window -> Preferences -> Java -> Installed JREs -> Edit
2. 在 Default VM arguments 中填写参数： -DproxyHost=127.0.0.1 -DproxyPort=9876

2.3 使用系统代理

上面两种方法都可以设置系统，下面要怎么在程序中自动使用系统代理呢？

对于 HttpURLConnection 类来说，程序不用做任何变动，它会默认使用系统代理。但是 HttpClient 默认是不使用系统代理的，如果想让它默认使用系统代理，可以通过 SystemDefaultRoutePlanner 和 ProxySelector 来设置。示例代码如下：

参考

1. HttpClient Tutorial
2. 评测告诉你：那些免费代理悄悄做的龌蹉事儿
3. How to use Socks 5 proxy with Apache HTTP Client 4?
4. 使用ProxySelector选择代理服务器
5. Java Networking and Proxies

     这样做的最终效果就是修改了项目的运行方式。原先的运行方式是以tomcat为中心，由tomcat来启动和终止项目，现在是由我们的启动程序 为中心，由启动程序来负责启动和终止项目。就相当于现在流行的cs程序一样，有单独的启动脚本，在启动时进行环境预初始化，更新程序以及其它操作，待完成 之后再进行最终的项目启动。

     这篇主要讲解如何使用embeded tomcat在代码中进行启动和终止。网上的一般文章均为tomca5.x来做，这里使用了最新的tomcat7，因为tomcat7为embeded开 发，单独发布了org.apache.tomcat.embed包，以进行独立的embed开发。以下是相应的maven包

    使用了embed包中的core包，以及用于编译jsp的jasper包，然后是工具类以及进行上场记录的logging-juli包。开始写代码：

    上面使用了Tomcat类来进行启动类，在tomcat7以前均是使用一个叫Embed类来进行启动，在tomcat7之后，embed类被不建 议使用，而建议使用新的Tomcat类来进行启动了。然后设置主机名，端口，再设置一个工作目录。这个工作目录可以是任意目录，主要是tomcat需要这 个目录来记录一些东西，比如记录word信息，日志信息（如果配置了日志的话），以及临时文件存储等。

    上面的代码，首先设置我们的项目程序所在的appbase，即放项目代码的地方。在通常的tomcat配置中，这个目录一般是webapps。接 着设置一个listener，这个listener主要是负责启动一些比如html native支持程序以及ipv6等信息配置（可以忽略）。接着是配置一个关闭的注册端口，当向这个端口发送信息时，就可以达到关闭tomcat的目的 （后面会讲）。

    我们单独使用了一个Context来为这个host添加上下文，tomcat本身提供一个方法tomcat.addWeb方法来添加项目包，不过 由于这里需要单独设置一个tomcat的sessionName，所以使用与与tomcat.addWeb实现类似的方法来添加一个项目包。
    以上代码中有两个需要注意的listener，一个是DefaultWebXmlListener，这个是由tomcat加载一些默认的配置信 息，比如jspServlet，以及一些繁复的mime/type信息；加上这个，就不需要我们自己去写这么多的配置，因为每个项目都需要这些。这个配置 与tomcat目录下的conf/web.xml中的配置一样，只不过这里是代码化了。第二个是FixContextListener，这个主要是在项目 部署完后，将这个上下文设置为configured，表示已经配置好了（不然，tomcat启动时会报错，即相应上下文还未配置好）。
    配置OK了之后，就是启动tomcat了：

    启动tomcat，并让tomcat在关闭端口上监听。如果没有最后一句，程序将直接结束，保证监听之后，tomcat将一直监听关闭事件，待有关闭事件之后才结束当前程序。所以如果想要关闭当前的tomcat，只需要向关闭端口发送一些信息即可：

    这样即可达到关闭tomcat的目的。

     实际上看整个项目代码，项目代码的运行，就是一个配置一个基础的server.xml（即tomcat目录下的 conf/server.xml)，先配置运行端口，关闭监听端口；然后配置运行的host以及添加一个上下文context，最后就开始运行并开始监 听。对照这个程序，再看一下server.xml中的配置信息，就很容易明白以上这段代码了。

Redis有一系列的命令，特点是以NX结尾，NX是Not eXists的缩写，如SETNX命令就应该理解为：SET if Not eXists。这系列的命令非常有用，这里讲使用SETNX来实现分布式锁。

用SETNX实现分布式锁

利用SETNX非常简单地实现分布式锁。例如：某客户端要获得一个名字foo的锁，客户端使用下面的命令进行获取：

SETNX lock.foo <current Unix time + lock timeout + 1>

•  如返回1，则该客户端获得锁，把lock.foo的键值设置为时间值表示该键已被锁定，该客户端最后可以通过DEL lock.foo来释放该锁。
•  如返回0，表明该锁已被其他客户端取得，这时我们可以先返回或进行重试等对方完成或等待锁超时。

解决死锁

上面的锁定逻辑有一个问题：如果一个持有锁的客户端失败或崩溃了不能释放锁，该怎么解决？我们可以通过锁的键对应的时间戳来判断这种情况是否发生了，如果当前的时间已经大于lock.foo的值，说明该锁已失效，可以被重新使用。

发生这种情况时，可不能简单的通过DEL来删除锁，然后再SETNX一次，当多个客户端检测到锁超时后都会尝试去释放它，这里就可能出现一个竞态条件,让我们模拟一下这个场景：

1.  C0操作超时了，但它还持有着锁，C1和C2读取lock.foo检查时间戳，先后发现超时了。
2.  C1 发送DEL lock.foo
3.  C1 发送SETNX lock.foo 并且成功了。
4.  C2 发送DEL lock.foo
5.  C2 发送SETNX lock.foo 并且成功了。

这样一来，C1，C2都拿到了锁！问题大了！

幸好这种问题是可以避免D，让我们来看看C3这个客户端是怎样做的：

1. C3发送SETNX lock.foo 想要获得锁，由于C0还持有锁，所以Redis返回给C3一个0
2. C3发送GET lock.foo 以检查锁是否超时了，如果没超时，则等待或重试。
3. 反之，如果已超时，C3通过下面的操作来尝试获得锁：
   GETSET lock.foo <current Unix time + lock timeout + 1>
4. 通过GETSET，C3拿到的时间戳如果仍然是超时的，那就说明，C3如愿以偿拿到锁了。
5. 如果在C3之前，有个叫C4的客户端比C3快一步执行了上面的操作，那么C3拿到的时间戳是个未超时的值，这时，C3没有如期获得锁，需要再次等待或重试。留意一下，尽管C3没拿到锁，但它改写了C4设置的锁的超时值，不过这一点非常微小的误差带来的影响可以忽略不计。

注意：为了让分布式锁的算法更稳键些，持有锁的客户端在解锁之前应该再检查一次自己的锁是否已经超时，再去做DEL操作，因为可能客户端因为某个耗时的操作而挂起，操作完的时候锁因为超时已经被别人获得，这时就不必解锁了。

示例伪代码

根据上面的代码，我写了一小段Fake代码来描述使用分布式锁的全过程：

是的，要想这段逻辑可以重用，使用python的你马上就想到了Decorator，而用Java的你是不是也想到了那谁？AOP + annotation？行，怎样舒服怎样用吧，别重复代码就行。

引子

redis是一个很强大的数据结构存储的nosql数据库，很方便针对业务模型进行效率的优化。最近我的工作是负责对现有Java服务器框架进行整理，并将网络层与逻辑层脱离，以便于逻辑层和网络层的横向扩展。 尽管我在逻辑层上使用了AKKA作为核心框架，尽可能lockfree，但是还是免不了需要跨jvm的锁。所以我需要实现一个分布式锁。

官方的实现

官方在SETNX 这一页给了一个实现。

• C4 sends SETNX lock.foo in order to acquire the lock
• The crashed client C3 still holds it, so Redis will reply with 0 to C4.
• C4 sends GET lock.foo to check if the lock expired. If it is not, it will sleep for some time and retry from the start.
• Instead, if the lock is expired because the Unix time at lock.foo is older than the current Unix time, C4 tries to perform: GETSET lock.foo (current Unix timestamp + lock timeout + 1)
• Because of the GETSET semantic, C4 can check if the old value stored at key is still an expired timestamp. If it is, the lock was acquired.
• If another client, for instance C5, was faster than C4 and acquired the lock with the GETSET operation, the C4 GETSET operation will return a non expired timestamp. C4 will simply restart from the first step. Note that even if C4 set the key a bit a few seconds in the future this is not a problem.

但是使用官方推荐的getset实现的话，未竞争到锁的一方确实可以判断到自己未能竞争到锁，但却将持有锁一方的时间修改了，这样的直接后果就是，持有锁的一方无法解锁！！！

基于lua的实现

其实官方实现出现的问题，是因为使用redis独立的命令不能将get-check-set这个过程进行原子化，所以我决定引入redis-lua，将get-check-set这个过程使用lua脚本来实现。

加锁：

• script params: lock_key, current_timestamp, lock_timeout
• setnx lock_key (current_timestamp + lock_timeout). if not success, set lock_key (current_timestamp + lock_timeout) if current_timestamp > value
• client save current_timestamp(lock_create_timestamp)

解锁：

• script params: lock_key, lock_create_timestamp, lock_timeout
• delete if lock_create_timestamp + lock_timeout == value

具体的实现:

---lock

local now = tonumber(ARGV[1])
local timeout = tonumber(ARGV[2])
local to = now + timeout
local locked = redis.call('SETNX', KEYS[1], to)
if (locked == 1) then
 return 0
end
local kt = redis.call('type', KEYS[1]);
if (kt['ok'] ~= 'string') then
 return 2
end
local keyValue = tonumber(redis.call('get', KEYS[1]))
if (now > keyValue) then
    redis.call('set', KEYS[1], to)
 return 0
end
return 1

---unlock

local begin = tonumber(ARGV[1])
local timeout = tonumber(ARGV[2])
local kt = redis.call('type', KEYS[1]);
if (kt['ok'] == 'string') then
 local keyValue = tonumber(redis.call('get', KEYS[1]))
 if ((keyValue - begin) == timeout) then
        redis.call('del', KEYS[1])
 return 0
 end
end
return 1

已知问题

redis的分布式锁会有单点的问题。当然我们的业务量也没有达到挂掉专门做锁的redis单点的水平。

1. 为什么要实现javaBean与Map<String,Object>相互转换？

用过spring的都知道spring的MVC框架中有一个BaseCommandController对象，利用这个对象我们就可以很方便的将从 客户端传递过来的参数封装到一个JavaBean对象中去，而不需要我们 request.getParameter("name");bean.setName(name);了，从而也简化了不少的工作。如果大家用过 BeanUtils.populate的话，就知道，这个方法是可以很方便的将request提交的页面表单自动填写到你创建的对象中

2. 如何实现javaBean与Map<String,Object>相互转换？

方法1： 利用java.beans.Introspector和java.beans.PropertyDescriptor实现 javaBean与Map<String,Object>互转

方法2： 利用org.apache.commons.beanutils.BeanUtils工具类，BeanUtils.populate实现Map 转换为javaBean 

总结：  javaBean与Map<String,Object>互转利用到了java的内省（ Introspector ）和反射（reflect）机制。 其思路为： 通 过类 Introspector 来获取某个对象的 BeanInfo 信息，然后通过 BeanInfo 来获取属性的描述器 PropertyDescriptor，再利用属性描述器获取某个属性对应的 getter/setter 方法，然后通过反射机制来getter和 setter。

什么是内省？ 

内 省是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 PersonBean中有属性 name, 那我们可以通 过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规 则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最 好还是要搞清楚），这些 API 存放于包 java.beans 中。注意： PersonBean中属性mN的getter/setter方法必须满足javaBean命名规范，即getmN，不能写作getMN，否则转换失败。 详情参考  http://blog.renren.com/share/236384819/5598710664

传统的hash 算法只负责将原始内容尽量均匀随机地映射为一个签名值，原理上相当于伪随机数产生算法。产生的两个签名，如果相等，说明原始内容在一定概 率 下是相等的；如果不相等，除了说明原始内容不相等外，不再提供任何信息，因为即使原始内容只相差一个字节，所产生的签名也很可能差别极大。从这个意义 上来 说，要设计一个 hash 算法，对相似的内容产生的签名也相近，是更为艰难的任务，因为它的签名值除了提供原始内容是否相等的信息外，还能额外提供不相等的 原始内容的差异程度的信息。

而Google 的 simhash 算法产生的签名，可以用来比较原始内容的相似度时，便很想了解这种神奇的算法的原理。出人意料，这个算法并不深奥，其思想是非常清澈美妙的。

Simhash算法

simhash算法的输入是一个向量，输出是一个 f 位的签名值。为了陈述方便，假设输入的是一个文档的特征集合，每个特征有一定的权重。比如特征可以是文档中的词，其权重可以是这个词出现的次数。 simhash 算法如下：

1，将一个 f 维的向量 V 初始化为 0 ； f 位的二进制数 S 初始化为 0 ；

2，对每一个特征：用传统的 hash 算法对该特征产生一个 f 位的签名 b 。对 i=1 到 f ：

如果b 的第 i 位为 1 ，则 V 的第 i 个元素加上该特征的权重；

否则，V 的第 i 个元素减去该特征的权重。 

3，如果 V 的第 i 个元素大于 0 ，则 S 的第 i 位为 1 ，否则为 0 ；

4，输出 S 作为签名。

算法几何意义和原理

这个算法的几何意义非常明了。它首先将每一个特征映射为f 维空间的一个向量，这个映射规则具体是怎样并不重要，只要对很多不同的特征来说，它们对所对应的 向量是均匀随机分布的，并且对相同的特征来说对应的向量是唯一的就行。比如一个特征的 4 位 hash 签名的二进制表示为 1010 ，那么这个特征对应的  4 维向量就是 (1, -1, 1, -1) T ，即hash 签名的某一位为 1 ，映射到的向量的对应位就为 1 ，否则为 -1 。然后，将一个文档中所包含的各个特征对应的向量加权求和， 加权的系数等于该特征的权重。

得到的和向量即表征了这个文档，我们可以用向量之间的夹角来衡量对应文档之间的相似度。最后，为了得到一个 f 位的签名，需要 进一步将其压缩，如果和向量的某一维大于 0 ，则最终签名的对应位为 1 ，否则为 0 。这样的压缩相当于只留下了和向量所在的象限这个信息，而 64 位的签名可以 表示多达 2 64 个象限，因此只保存所在象限的信息也足够表征一个文档了。

比较相似度

海明距离： 两个码字的对应比特取值不同的比特数称为这两个码字的海明距离。一个有效编码集中, 任意两个码字的海明距离的最小值称为该编码集的海明距离。举例如下： 10101 和 00110 从第一位开始依次有第一位、第四、第五位不同，则海明距离为 3.

异或： 只有在两个比较的位不同时其结果是1 ，否则结果为 0 

  对每篇文档根据SimHash 算出签名后，再计算两个签名的海明距离（两个二进制异或后 1 的个数）即可。根据经验值，对 64 位的 SimHash ，海明距离在 3 以内的可以认为相似度比较高。

假设对64 位的 SimHash ，我们要找海明距离在 3 以内的所有签名。我们可以把 64 位的二进制签名均分成 4 块，每块 16 位。根据鸽巢原理（也成抽屉原理，见组合数学），如果两个签名的海明距离在 3 以内，它们必有一块完全相同。

我们把上面分成的4 块中的每一个块分别作为前 16 位来进行查找。 建立倒排索引。

如果库中有2^34 个（大概 10 亿）签名，那么匹配上每个块的结果最多有 2^(34-16)=262144 个候选结果 (假设数据是均匀分布， 16 位的数据，产生的像限为 2^16 个，则平均每个像限分布的文档数则 2^34/2^16 = 2^(34-16)) ，四个块返回的总结果数为 4* 262144 （大概 100 万）。原本需要比较 10 亿次，经过索引，大概就只需要处理 100 万次了。由此可见，确实大大减少了计算量。 

Java 代码实现：

Java代码  

1. package com.gemantic.nlp.commons.simhash;  
2.   
3. import java.math.BigInteger;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import java.util.StringTokenizer;  
7.   
8. public class SimHash {  
9.   
10.     private String tokens;  
11.   
12.     private BigInteger intSimHash;  
13.       
14.     private String strSimHash;  
15.   
16.     private int hashbits = 64;  
17.   
18.     public SimHash(String tokens) {  
19.         this.tokens = tokens;  
20.         this.intSimHash = this.simHash();  
21.     }  
22.   
23.     public SimHash(String tokens, int hashbits) {  
24.         this.tokens = tokens;  
25.         this.hashbits = hashbits;  
26.         this.intSimHash = this.simHash();  
27.     }  
28.   
29.     public BigInteger simHash() {  
30.         int[] v = new int[this.hashbits];  
31.         StringTokenizer stringTokens = new StringTokenizer(this.tokens);  
32.         while (stringTokens.hasMoreTokens()) {  
33.             String temp = stringTokens.nextToken();  
34.             BigInteger t = this.hash(temp);  
35.             for (int i = 0; i < this.hashbits; i++) {  
36.                 BigInteger bitmask = new BigInteger("1").shiftLeft(i);  
37.                  if (t.and(bitmask).signum() != 0) {  
38.                     v[i] += 1;  
39.                 } else {  
40.                     v[i] -= 1;  
41.                 }  
42.             }  
43.         }  
44.         BigInteger fingerprint = new BigInteger("0");  
45.         StringBuffer simHashBuffer = new StringBuffer();  
46.         for (int i = 0; i < this.hashbits; i++) {  
47.             if (v[i] >= 0) {  
48.                 fingerprint = fingerprint.add(new BigInteger("1").shiftLeft(i));  
49.                 simHashBuffer.append("1");  
50.             }else{  
51.                 simHashBuffer.append("0");  
52.             }  
53.         }  
54.         this.strSimHash = simHashBuffer.toString();  
55.         System.out.println(this.strSimHash + " length " + this.strSimHash.length());  
56.         return fingerprint;  
57.     }  
58.   
59.     private BigInteger hash(String source) {  
60.         if (source == null || source.length() == 0) {  
61.             return new BigInteger("0");  
62.         } else {  
63.             char[] sourceArray = source.toCharArray();  
64.             BigInteger x = BigInteger.valueOf(((long) sourceArray[0]) << 7);  
65.             BigInteger m = new BigInteger("1000003");  
66.             BigInteger mask = new BigInteger("2").pow(this.hashbits).subtract(  
67.                     new BigInteger("1"));  
68.             for (char item : sourceArray) {  
69.                 BigInteger temp = BigInteger.valueOf((long) item);  
70.                 x = x.multiply(m).xor(temp).and(mask);  
71.             }  
72.             x = x.xor(new BigInteger(String.valueOf(source.length())));  
73.             if (x.equals(new BigInteger("-1"))) {  
74.                 x = new BigInteger("-2");  
75.             }  
76.             return x;  
77.         }  
78.     }  
79.       
80.     /** 
81.      * 取两个二进制的异或，统计为1的个数，就是海明距离 
82.      * @param other 
83.      * @return 
84.      */  
85.   
86.     public int hammingDistance(SimHash other) {  
87.           
88.         BigInteger x = this.intSimHash.xor(other.intSimHash);  
89.         int tot = 0;  
90.           
91.         //统计x中二进制位数为1的个数  
92.         //我们想想，一个二进制数减去1，那么，从最后那个1（包括那个1）后面的数字全都反了，对吧，然后，n&(n-1)就相当于把后面的数字清0，  
93.         //我们看n能做多少次这样的操作就OK了。  
94.           
95.          while (x.signum() != 0) {  
96.             tot += 1;  
97.             x = x.and(x.subtract(new BigInteger("1")));  
98.         }  
99.         return tot;  
100.     }  
101.   
102.     /**  
103.      * calculate Hamming Distance between two strings  
104.      *  二进制怕有错，当成字符串，作一个，比较下结果 
105.      * @author   
106.      * @param str1 the 1st string  
107.      * @param str2 the 2nd string  
108.      * @return Hamming Distance between str1 and str2  
109.      */    
110.     public int getDistance(String str1, String str2) {    
111.         int distance;    
112.         if (str1.length() != str2.length()) {    
113.             distance = -1;    
114.         } else {    
115.             distance = 0;    
116.             for (int i = 0; i < str1.length(); i++) {    
117.                 if (str1.charAt(i) != str2.charAt(i)) {    
118.                     distance++;    
119.                 }    
120.             }    
121.         }    
122.         return distance;    
123.     }  
124.       
125.     /** 
126.      * 如果海明距离取3，则分成四块，并得到每一块的bigInteger值 ，作为索引值使用 
127.      * @param simHash 
128.      * @param distance 
129.      * @return 
130.      */  
131.     public List<BigInteger> subByDistance(SimHash simHash, int distance){  
132.         int numEach = this.hashbits/(distance+1);  
133.         List<BigInteger> characters = new ArrayList();  
134.           
135.         StringBuffer buffer = new StringBuffer();  
136.   
137.         int k = 0;  
138.         for( int i = 0; i < this.intSimHash.bitLength(); i++){  
139.             boolean sr = simHash.intSimHash.testBit(i);  
140.               
141.             if(sr){  
142.                 buffer.append("1");  
143.             }     
144.             else{  
145.                 buffer.append("0");  
146.             }  
147.               
148.             if( (i+1)%numEach == 0 ){  
149.                 BigInteger eachValue = new BigInteger(buffer.toString(),2);  
150.                 System.out.println("----" +eachValue );  
151.                 buffer.delete(0, buffer.length());  
152.                 characters.add(eachValue);  
153.             }  
154.         }  
155.   
156.         return characters;  
157.     }  
158.       
159.     public static void main(String[] args) {  
160.         String s = "This is a test string for testing";  
161.   
162.         SimHash hash1 = new SimHash(s, 64);  
163.         System.out.println(hash1.intSimHash + "  " + hash1.intSimHash.bitLength());  
164.           
165.         hash1.subByDistance(hash1, 3);  
166.   
167.         System.out.println("\n");  
168.         s = "This is a test string for testing, This is a test string for testing abcdef";  
169.         SimHash hash2 = new SimHash(s, 64);  
170.         System.out.println(hash2.intSimHash+ "  " + hash2.intSimHash.bitCount());  
171.         hash1.subByDistance(hash2, 3);  
172.         s = "This is a test string for testing als";  
173.         SimHash hash3 = new SimHash(s, 64);  
174.         System.out.println(hash3.intSimHash+ "  " + hash3.intSimHash.bitCount());  
175.         hash1.subByDistance(hash3, 3);  
176.         System.out.println("============================");  
177.         int dis = hash1.getDistance(hash1.strSimHash,hash2.strSimHash);  
178.           
179.         System.out.println(hash1.hammingDistance(hash2) + " "+ dis);  
180.           
181.         int dis2 = hash1.getDistance(hash1.strSimHash,hash3.strSimHash);  
182.           
183.         System.out.println(hash1.hammingDistance(hash3) + " " + dis2);  
184.           
185.   
186.   
187.     }  
188. }  

参考：   http://blog.sina.com.cn/s/blog_72995dcc010145ti.html

http://blog.sina.com.cn/s/blog_56d8ea900100y41b.html

http://blog.csdn.net/meijia_tts/article/details/7928579

Lambda 允许我们定义匿名方法(即那个 Lambda 表达式，或叫闭包)，作为一个功能性接口的实例。如果你不想把一个 Lambda 表达式写得过大，那么你可以把表达式的内容分离出来写在一个方法中，然后在放置 Lambda 表达式的位置上填上对那个方法的引用。

方法引用也应看作是一个 Lambda 表达式，所以它也需要一个明确的目标类型充当功能性接口的实例。简单说就是被引用的方法要与功能接口的 SAM(Single Abstract Method) 参数、返回类型相匹配。方法引用的引入避免了 Lambda 写复杂了可读性的问题，也使得逻辑更清晰。

为了应对方法引用这一概念， JDK8 又重新借用了 C++ 的那个 “::” 域操作符，全称为作用域解析操作符。

上面的表述也许不好明白，我看官方的那份 State of the Lambda 也觉得不怎么容易理解，特别是它举了那个例子很难让人望文生意。我用个自己写的例子来说明一下吧。

目前的 Eclipse-JDK8 版还不能支持方法引用的特性，幸好就是在昨天正式版的 NetBeans IDE 7.4 对 JDK8 有了较好的支持，所以在 NetBeans 7.4 中写测试代码。

说明：

1. Machine 是一个功能性接口，它只有一个抽象方法
2. start(Machine machine) 方法为 Lambda 表达式提供了一个上下文，表明它期盼接收一个 Machine 的功能性接口类型
3. start((id, task) -> id + ": " + task), 是传递了一个 Lambda 表达式给 start() 方法
4. start(TestJdk8::hello) 是把指向 TestJdk8::hello 方法的引用传递给了 start() 方法，这里可以理解 hello() 方法是 Lambda 表达式的另一种表现形式。

对应一下两个 start() 方法调用的参数，Lambda 表达式的参数列表 (id, task) 与 hello 方法的参数 (int id, String task) 是一致的，返回值类型也是一致的。

想像一下如果一个 Lambda 表达式的代码量很大，全部挤在一起作为 start() 方法的参数部分，混乱也不太方便于单步调试。所以可以把 Lambda 的实现挪出来放在一个单独的方法中，在使用处只放置一个对该方法的引用即可。借助于方法引用，JDK8  把方法与 Lambda 表达式巧妙的结合了起来，直接的说 Lambda 表达就是一个方法，它用自己的方法列表和返回值。

那么符合什么条件的方法可以作为 Lambda 表达式来用呢？答：方法签名与功能性接口的 SAM 一致即可。比如，可以进行下面的赋值：

有些什么样子的方法引用：

1. 静态方法 (ClassName::methName)
2. 对象的实例方法 (instanceRef::methName)
3. 对象的super 方法 (super::methName)
4. 类型的实例方法 (ClassName::methName, 引用时和静态方法是一样的，但这里的 methName 是个实例方法)
5. 类的构造方法 (ClassName::new)
6. 数组的构造方法 (TypeName[]::new)

第 1 条，静态方法以 ClassName 为作用域好理解，第 4 条中实例方法也可以用 ClassName::methName 的方式去引用，那么这里又有个约定了：如果实例方法用类型来引用的时候，那么调用时第一个参数将作为该引用方法的接收者，其余参数依次作为引用方法的参 数。举个例子：

上面的代码应该能有助于理解实例方法用类型来引用，如果引用的是泛型方法，类型写在 :: 之前。

同样当然对于第 2 条，引用实例方法时，SAM 的第一个参数也作为接收者，其作参数依次填充过去。

第 5 条，类的构造方法要用类型去引用，new 相当一个返回当前类型实例的实例方法，所以

数组是种类型，可以认为数组的构造方法是只接受一个整形参数，所以能这样引用数组的构造方法：

BTW:再次感叹下没有机器, 3.4G的语料,单机处理了10来个小时, 真是郁闷~~　要是有N台机器多好啊.

在很多时候,特别是处理大数据的时候,我们希望一道MapReduce过程就可以解决几个问题。这样可以避免再次读取数据。比如：在做文本聚类/分 类的时候，mapper读取语料，进行分词后，要同时算出每个词条(term)的term frequency以及它的document frequency.　前者对于每个词条来说其实是个向量,　它代表此词条在N篇文档各中的词频；而后者就是一个非负整数。 这时候就可以借助一种特殊的Writable类：GenericWritable.

用法是：继承这个类，然后把你要输出value的Writable类型加进它的CLASSES静态变量里,在后面的TermMapper和 TermReducer中我的value使用了三种ArrayWritable,IntWritable和我自已定义的TFWritable,所以要把三 者全加入TermWritable的CLASSES中。

Java代码  

1. package redpoll.examples;  
2.   
3. import org.apache.hadoop.io.GenericWritable;  
4. import org.apache.hadoop.io.Writable;  
5.   
6. /** 
7.  * Generic Writable class for terms. 
8.  * @author Jeremy Chow(coderplay@gmail.com) 
9.  */  
10. public class TermWritable extends GenericWritable {  
11.   private static Class<? extends Writable>[] CLASSES = null;  
12.   
13.   static {  
14.     CLASSES = (Class<? extends Writable>[]) new Class[] {  
15.         org.apache.hadoop.io.ArrayWritable.class,  
16.         org.apache.hadoop.io.IntWritable.class,  
17.         redpoll.examples.TFWritable.class  
18.         };  
19.   }  
20.   
21.   public TermWritable() {  
22.   }  
23.   
24.   public TermWritable(Writable instance) {  
25.     set(instance);  
26.   }  
27.   
28.   @Override  
29.   protected Class<? extends Writable>[] getTypes() {  
30.     return CLASSES;  
31.   }  
32. }  

 Mapper在collect数据时，用刚才定义的TermWritable来包装(wrap)要使用的Writable类。

Java代码  

1. package redpoll.examples;  
2.   
3. import java.io.IOException;  
4. import java.io.StringReader;  
5.   
6. import org.apache.commons.logging.Log;  
7. import org.apache.commons.logging.LogFactory;  
8. import org.apache.hadoop.io.IntWritable;  
9. import org.apache.hadoop.io.LongWritable;  
10. import org.apache.hadoop.io.Text;  
11. import org.apache.hadoop.mapred.JobConf;  
12. import org.apache.hadoop.mapred.MapReduceBase;  
13. import org.apache.hadoop.mapred.Mapper;  
14. import org.apache.hadoop.mapred.OutputCollector;  
15. import org.apache.hadoop.mapred.Reporter;  
16. import org.apache.lucene.analysis.Analyzer;  
17. import org.apache.lucene.analysis.Token;  
18. import org.apache.lucene.analysis.TokenStream;  
19. import org.apache.lucene.analysis.standard.StandardAnalyzer;  
20.   
21. /** 
22.  * A class provides for doing words segmenation and counting term TFs and DFs.<p> 
23.  * in: key is document id, value is a document instance. <br> 
24.  * output: 
25.  * <li>key is term, value is a <documentId, tf> pair</li> 
26.  * <li>key is term, value is document frequency corresponsing to the key</li> 
27.  * @author Jeremy Chow(coderplay@gmail.com) 
28.  */  
29. public class TermMapper extends MapReduceBase implements  
30.     Mapper<LongWritable, Document, Text, TermWritable> {  
31.   private static final Log log = LogFactory.getLog(TermMapper.class  
32.       .getName());  
33.     
34.   /* analyzer for words segmentation */  
35.   private Analyzer analyzer = null;  
36.      
37.   /* frequency weight for document title */  
38.   private IntWritable titleWeight = new IntWritable(2);  
39.   /* frequency weight for document content */  
40.   private IntWritable contentWeight = new IntWritable(1);  
41.   
42.     
43.   public void map(LongWritable key, Document value,  
44.       OutputCollector<Text, TermWritable> output, Reporter reporter)  
45.       throws IOException {  
46.     doMap(key, value.getTitle(), titleWeight, output, reporter);  
47.     doMap(key, value.getContent(), contentWeight, output, reporter);  
48.   }  
49.     
50.   private void doMap(LongWritable key, String value, IntWritable weight,  
51.       OutputCollector<Text, TermWritable> output, Reporter reporter)  
52.       throws IOException {  
53.     // do words segmentation  
54.     TokenStream ts = analyzer.tokenStream("dummy", new StringReader(value));  
55.     Token token = new Token();  
56.     while ((token = ts.next(token)) != null) {  
57.       String termString = new String(token.termBuffer(), 0, token.termLength());  
58.       Text term = new Text(termString);  
59.       // <term, <documentId,tf>>  
60.       TFWritable tf = new TFWritable(key, weight);  
61.       output.collect(term, new TermWritable(tf)); // wrap then collect  
62.       // <term, weight>  
63.       output.collect(term, new TermWritable(weight)); // wrap then collect  
64.     }  
65.   }  
66.       
67.   @Override  
68.   public void configure(JobConf job) {  
69.     String analyzerName = job.get("redpoll.text.analyzer");  
70.     try {  
71.       if (analyzerName != null)  
72.         analyzer = (Analyzer) Class.forName(analyzerName).newInstance();  
73.     } catch (Exception excp) {  
74.       excp.printStackTrace();  
75.     }  
76.     if (analyzer == null)  
77.       analyzer = new StandardAnalyzer();  
78.   }  
79.   
80. }  

Reduce如果想获取数据，则可以解包(unwrap)它：

Java代码  

1. package redpoll.examples;  
2.   
3. import java.io.IOException;  
4. import java.util.ArrayList;  
5. import java.util.Iterator;  
6.   
7. import org.apache.commons.logging.Log;  
8. import org.apache.commons.logging.LogFactory;  
9. import org.apache.hadoop.io.ArrayWritable;  
10. import org.apache.hadoop.io.IntWritable;  
11. import org.apache.hadoop.io.Text;  
12. import org.apache.hadoop.io.Writable;  
13. import org.apache.hadoop.mapred.MapReduceBase;  
14. import org.apache.hadoop.mapred.OutputCollector;  
15. import org.apache.hadoop.mapred.Reducer;  
16. import org.apache.hadoop.mapred.Reporter;  
17.   
18. /** 
19.  * Form a tf vector and caculate the df for terms. 
20.  * @author Jeremy Chow(coderplay@gmail.com) 
21.  */  
22. public class TermReducer extends MapReduceBase implements Reducer<Text, TermWritable, Text, Writable> {  
23.     
24.   private static final Log log = LogFactory.getLog(TermReducer.class.getName());  
25.     
26.   public void reduce(Text key, Iterator<TermWritable> values,  
27.       OutputCollector<Text, Writable> output, Reporter reporter)  
28.       throws IOException {  
29.     ArrayList<TFWritable> tfs = new ArrayList<TFWritable>();  
30.     int sum = 0;  
31. //    log.info("term:" + key.toString());  
32.     while (values.hasNext()) {  
33.       Writable value = values.next().get(); // unwrap  
34.       if (value  instanceof TFWritable) {  
35.         tfs.add((TFWritable) value );   
36.       }else {  
37.         sum += ((IntWritable) value).get();  
38.       }  
39.     }  
40.       
41.     TFWritable writables[] = new TFWritable[tfs.size()];  
42.     ArrayWritable aw = new ArrayWritable(TFWritable.class, tfs.toArray(writables));  
43.     // wrap again  
44.     output.collect(key, new TermWritable(aw));   
45.     output.collect(key, new TermWritable(new IntWritable(sum)));  
46.   }  
47.   
48. }  

 这儿collect的时候可以不再用TermWritable,只不过我在重新定义了OutputFormat，让它输出到两个不同的文件，而且输出的类型也是不一样的。

3.1、声明QueryParser类

在QueryParser.jj文件中，PARSER_BEGIN(QueryParser)和PARSER_END(QueryParser)之间，定义了QueryParser类。

其中最重要的一个函数是public Query parse(String query)函数，也即我们解析Lucene查询语法的时候调用的函数。

这是一个纯Java代码定义的函数，会直接拷贝到QueryParser.java文件中。

parse函数中，最重要的一行代码是调用Query res = TopLevelQuery(field)，而TopLevelQuery函数是QueryParser.jj中定义的语法分析器被JavaCC编译后会生成的函数。

3.2、声明词法分析器

在解析词法分析器之前，首先介绍一下JavaCC的词法状态的概念(lexical state)。

有可能存在如下的情况，在不同的情况下，要求的词法词法规则不同，比如我们要解析一个java文件(即满足java语法的表达式)，在默认的状态 DEFAULT下，是要求解析的对象(即表达式)满足java语言的词法规则，然而当出现"/**"的时候，其后面的表达式则不需要满足java语言的语 法规则，而是应该满足java注释的语法规则(要识别@param变量等)，于是我们做如下定义：

<*> 表示应用于任何状态。

(1) 应用于所有状态的变量

(2) 默认状态的Token

3.3、声明语法分析器

Lucene的语法规则如下：

(1) 从Query到Clause

一个Query查询语句，是由多个clause组成的，每个clause有修饰符Modifier，或为+, 或为-，clause之间的有连接符，或为AND，或为OR，或为NOT。

在Lucene的语法解析中NOT被算作Modifier，和-起相同作用。

此过程表达式如下：

(2) 一个子语句clause

由上面的分析我们可以知道，JavaCC使用的是编译原理里面的自上而下分析法，基本采用的是LL(1)的方法：

• 第一个L ：从左到右扫描输入串
• 第二个L ：生成的是最左推导
• (1)：向前看一个输入符号（lookahead)

JavaCC还提供LOOKAHEAD(n)，也即当仅读入下一个符号时，不足以判断接下来的如何解析，会出现Choice Conflict，则需要多读入几个符号，来进一步判断。

此处需要详细解析的是getFieldQuery：

protected Query getFieldQuery(String field, String queryText)  throws ParseException {

  //需要用analyzer对文本进行分词

  TokenStream source;

  try {

    source = analyzer.reusableTokenStream(field, new StringReader(queryText));

    source.reset();

  } catch (IOException e) {

    source = analyzer.tokenStream(field, new StringReader(queryText));

  }

  CachingTokenFilter buffer = new CachingTokenFilter(source);

  TermAttribute termAtt = null;

  PositionIncrementAttribute posIncrAtt = null;

  int numTokens = 0;

  boolean success = false;

  try {

    buffer.reset();

    success = true;

  } catch (IOException e) {

  }

  //得到TermAttribute和PositionIncrementAttribute，此两项将决定到底产生什么样的Query对象

  if (success) {

    if (buffer.hasAttribute(TermAttribute.class)) {

      termAtt = buffer.getAttribute(TermAttribute.class);

    }

    if (buffer.hasAttribute(PositionIncrementAttribute.class)) {

      posIncrAtt = buffer.getAttribute(PositionIncrementAttribute.class);

    }

  }

  int positionCount = 0;

  boolean severalTokensAtSamePosition = false;

  boolean hasMoreTokens = false;

  if (termAtt != null) {

    try {

      //遍历分词后的所有Token，统计Tokens的个数numTokens，以及positionIncrement的总数，即positionCount。

      //当有一次positionIncrement为0的时候，severalTokensAtSamePosition设为true，表示有多个Token处在同一个位置。

      hasMoreTokens = buffer.incrementToken();

      while (hasMoreTokens) {

        numTokens++;

        int positionIncrement = (posIncrAtt != null) ? posIncrAtt.getPositionIncrement() : 1;

        if (positionIncrement != 0) {

          positionCount += positionIncrement;

        } else {

          severalTokensAtSamePosition = true;

        }

        hasMoreTokens = buffer.incrementToken();

      }

    } catch (IOException e) {

    }

  }

  try {

    //重设buffer，以便生成phrase查询的时候，term和position可以重新遍历。

    buffer.reset();

    source.close();

  }

  catch (IOException e) {

  }

  if (numTokens == 0)

    return null;

  else if (numTokens == 1) {

    //如果分词后只有一个Token，则生成TermQuery

    String term = null;

    try {

      boolean hasNext = buffer.incrementToken();

      term = termAtt.term();

    } catch (IOException e) {

    }

    return newTermQuery(new Term(field, term));

  } else {

   //如果分词后不只有一个Token

    if (severalTokensAtSamePosition) {

   //如果有多个Token处于同一个位置

      if (positionCount == 1) {

        //并且处于同一位置的Token还全部处于第一个位置，则生成BooleanQuery，处于同一位置的Token之间是OR的关系

        BooleanQuery q = newBooleanQuery(true);

        for (int i = 0; i < numTokens; i++) {

          String term = null;

          try {

            boolean hasNext = buffer.incrementToken();

            term = termAtt.term();

          } catch (IOException e) {

          }

          Query currentQuery = newTermQuery(new Term(field, term));

          q.add(currentQuery, BooleanClause.Occur.SHOULD);

        }

        return q;

      }

      else {

        //如果有多个Token处于同一位置，但不是第一个位置，则生成MultiPhraseQuery。

        //所谓MultiPhraseQuery即其可以包含多个phrase，其又一个ArrayList<Term[]> termArrays，每一项都是一个Term的数组，属于同一个数组的Term表示在同一个位置。它有函数void add(Term[] terms)一次添加一个数组的Term。比如我们要搜索"microsoft app*"，其表示多个phrase，"microsoft apple"，"microsoft application"都算。此时用QueryParser.parse("\"microsoft app*\"")从而生成PhraseQuery是搜不出microsoft apple和microsoft application的，也不能搜出microsoft app，因为*一旦被引号所引，就不算通配符了。所以必须生成MultiPhraseQuery，首先用add(new Term[]{new Term("field", "microsoft")})将microsoft作为一个Term数组添加进去，然后用add(new Term[]{new Term("field", "app"), new Term("field", "apple"), new Term("field", "application")})作为一个Term数组添加进去(算作同一个位置的)，则三者都能搜的出来。

        MultiPhraseQuery mpq = newMultiPhraseQuery();

        mpq.setSlop(phraseSlop);

        List<Term> multiTerms = new ArrayList<Term>();

        int position = -1;

        for (int i = 0; i < numTokens; i++) {

          String term = null;

          int positionIncrement = 1;

          try {

            boolean hasNext = buffer.incrementToken();

            assert hasNext == true;

            term = termAtt.term();

            if (posIncrAtt != null) {

              positionIncrement = posIncrAtt.getPositionIncrement();

            }

          } catch (IOException e) {

          }

          if (positionIncrement > 0 && multiTerms.size() > 0) {

            //如果positionIncrement大于零，说明此Term和前一个Term已经不是同一个位置 了，所以原来收集在multiTerms中的Term都算作同一个位置，添加到MultiPhraseQuery中作为一项。并清除 multiTerms，以便重新收集相同位置的Term。

            if (enablePositionIncrements) {

              mpq.add(multiTerms.toArray(new Term[0]),position);

            } else {

              mpq.add(multiTerms.toArray(new Term[0]));

            }

            multiTerms.clear();

          }

          //将此Term收集到multiTerms中。

          position += positionIncrement;

          multiTerms.add(new Term(field, term));

        }

        //当遍历完所有的Token，同处于最后一个位置的Term已经收集到multiTerms中了，把他们加到MultiPhraseQuery中作为一项。

        if (enablePositionIncrements) {

          mpq.add(multiTerms.toArray(new Term[0]),position);

        } else {

          mpq.add(multiTerms.toArray(new Term[0]));

        }

        return mpq;

      }

    }

    else {

      //如果不存在多个Token处于同一个位置的情况，则直接生成PhraseQuery

      PhraseQuery pq = newPhraseQuery();

      pq.setSlop(phraseSlop);

      int position = -1;

      for (int i = 0; i < numTokens; i++) {

        String term = null;

        int positionIncrement = 1;

        try {

          boolean hasNext = buffer.incrementToken();

          assert hasNext == true;

          term = termAtt.term();

          if (posIncrAtt != null) {

            positionIncrement = posIncrAtt.getPositionIncrement();

          }

        } catch (IOException e) {

        }

        if (enablePositionIncrements) {

          position += positionIncrement;

          pq.add(new Term(field, term),position);

        } else {

          pq.add(new Term(field, term));

        }

      }

      return pq;

    }

  }

}

一、Lucene的查询语法

Lucene所支持的查询语法可见http://lucene.apache.org/java/3_0_1/queryparsersyntax.html

(1) 语法关键字

+ - && || ! ( ) { } [ ] ^ " ~ * ? : \

如果所要查询的查询词中本身包含关键字，则需要用\进行转义

(2) 查询词(Term)

Lucene支持两种查询词，一种是单一查询词，如"hello"，一种是词组(phrase)，如"hello world"。

(3) 查询域(Field)

在查询语句中，可以指定从哪个域中寻找查询词，如果不指定，则从默认域中查找。

查询域和查询词之间用:分隔，如title:"Do it right"。

:仅对紧跟其后的查询词起作用，如果title:Do it right，则仅表示在title中查询Do，而it right要在默认域中查询。

(4) 通配符查询(Wildcard)

支持两种通配符：?表示一个字符，*表示多个字符。

通配符可以出现在查询词的中间或者末尾，如te?t，test*，te*t，但决不能出现在开始，如*test，?test。

(5) 模糊查询(Fuzzy)

模糊查询的算法是基于Levenshtein Distance，也即当两个词的差别小于某个比例的时候，就算匹配，如roam~0.8，即表示差别小于0.2，相似度大于0.8才算匹配。

(6) 临近查询(Proximity)

在词组后面跟随~10，表示词组中的多个词之间的距离之和不超过10，则满足查询。

所谓词之间的距离，即查询词组中词为满足和目标词组相同的最小移动次数。

如索引中有词组"apple boy cat"。

如果查询词为"apple boy cat"~0，则匹配。

如果查询词为"boy apple cat"~2，距离设为2方能匹配，设为1则不能匹配。

如果查询词为"cat boy apple"~4，距离设为4方能匹配。

(7) 区间查询(Range)

区间查询包含两种，一种是包含边界，用[A TO B]指定，一种是不包含边界，用{A TO B}指定。

如date:[20020101 TO 20030101]，当然区间查询不仅仅用于时间，如title:{Aida TO Carmen}

(8) 增加一个查询词的权重(Boost)

可以在查询词后面加^N来设定此查询词的权重，默认是1，如果N大于1，则说明此查询词更重要，如果N小于1，则说明此查询词更不重要。

如jakarta^4 apache，"jakarta apache"^4 "Apache Lucene"

(9) 布尔操作符

布尔操作符包括连接符，如AND，OR，和修饰符，如NOT，+，-。

默认状态下，空格被认为是OR的关系，QueryParser.setDefaultOperator(Operator.AND)设置为空格为AND。

+表示一个查询语句是必须满足的(required)，NOT和-表示一个查询语句是不能满足的(prohibited)。

(10) 组合

可以用括号，将查询语句进行组合，从而设定优先级。

如(jakarta OR apache) AND website

Lucene的查询语法是由QueryParser来进行解析，从而生成查询对象的。

通过编译原理我们知道，解析一个语法表达式，需要经过词法分析和语法分析的过程，也即需要词法分析器和语法分析器。

QueryParser是通过JavaCC来生成词法分析器和语法分析器的。

二、JavaCC介绍

本节例子基本出于JavaCC tutorial的文章，http://www.engr.mun.ca/~theo/JavaCC-Tutorial/

JavaCC是一个词法分析器和语法分析器的生成器。

所谓词法分析器就是将一系列字符分成一个个的Token，并标记Token的分类。

例如，对于下面的C语言程序：

将被分成以下的Token:

标记了Token的类型后如下：

EOF表示文件的结束。

词法分析器工作过程如图所示：

此一系列Token将被传给语法分析器(当然并不是所有的Token都会传给语法分析器，本例中SPACE就例外)，从而形成一棵语法分析树来表示程序的结构。

JavaCC本身既不是一个词法分析器，也不是一个语法分析器，而是根据指定的规则生成两者的生成器。

2.1、第一个实例——正整数相加

下面我们来看第一个例子，即能够解析正整数相加的表达式，例如99+42+0+15。

(1) 生成一个adder.jj文件

此文件中写入的即生成词法分析器和语法分析器的规则。

(2) 设定选项，并声明类

STATIC选项默认是true，设为false，使得生成的函数不是static的。

PARSER_BEGIN和PARSER_END之间的java代码部分，此部分不需要通过JavaCC根据规则生成java代码，而是直接拷贝到生成的java代码中的。

(3) 声明一个词法分析器

第一二行表示空格和回车换行是不会传给语法分析器的。

第三行声明了一个Token，名称为PLUS，符号为“+”。

第四行声明了一个Token，名称为NUMBER，符号位一个或多个0-9的数的组合。

如果词法分析器分析的表达式如下：

• “123 + 456\n”，则分析为NUMBER, PLUS, NUMBER, EOF
• “123 - 456\n”，则报TokenMgrError，因为“-”不是一个有效的Token.
• “123 ++ 456\n”，则分析为NUMBER, PLUS, PLUS, NUMBER, EOF，词法分析正确，后面的语法分析将会错误。

(4) 声明一个语法分析器

语法分析器使用BNF表达式。

上述声明将生成start函数，称为Adder类的一个成员函数

语法分析器要求输入的语句必须以NUMBER开始，以EOF结尾，中间是零到多个PLUS和NUMBER的组合。

(5) 用javacc编译adder.jj来生成语法分析器和词法分析器

最后生成的adder.jj如下：

用JavaCC编译adder.jj生成如下文件：

• Adder.java：语法分析器。其中的main函数是完全从adder.jj中拷贝的，而start函数是被javacc由adder.jj描述的规则生成的。
• AdderConstants.java：一些常量，如PLUS, NUMBER, EOF等。
• AdderTokenManager.java：词法分析器。
• ParseException.java：用于在语法分析错误的时候抛出。
• SimpleCharStream.java：用于将一系列字符串传入词法分析器。
• Token.java：代表词法分析后的一个个Token。Token对象有一个整型域kind，来表示此Token的类型(PLUS, NUMBER, EOF)，有一个String类型的域image，来表示此Token的值。
• TokenMgrError.java：用于在词法分析错误的时候抛出。

下面我们对adder.jj生成的start函数进行分析：

(6) 运行Adder.java

如果输入“123+456”则不报任何错误。

如果输入“123++456”则报如下异常：

如果输入“123-456”则报如下异常：

2.2、扩展语法分析器

在上面的例子中的start函数中，我们仅仅通过语法分析器来判断输入的语句是否正确。

我们可以扩展BNF表达式，加入Java代码，使得经过语法分析后，得到我们想要的结果或者对象。

我们将start函数改写为：

生成的start函数如下：

从上面的例子，我们发现，把一个NUMBER取出，并解析为整型这一步是可以共用的，所以可以抽象为一个函数：

生成的函数如下：

2.3、第二个实例：计算器

(1) 生成一个calculator.jj文件

用于写入生成计算器词法分析器和语法分析器的规则。

(2) 设定选项，并声明类

previousValue用来记录上一次计算的结果。

(3) 声明一个词法分析器

我们想要支持小数，则有四种情况：没有小数，小数点在中间，小数点在前面，小数点在后面。则语法规则如下：

由于同一个表达式["0"-"9"]使用了多次，因而我们可以定义变量，如下：

(4) 声明一个语法分析器

我们想做的计算器包含多行，每行都是一个四则运算表达式，语法规则如下：

每一行的四则运算表达式如果只包含加法，则语法规则如下：

其中Primary()得到一个数的值：

(5) 扩展词法分析器和语法分析器

如果我们想支持减法，则需要在词法分析器中添加：

语法分析器应该变为：

如果我们想添加乘法和除法，则在词法分析器中应该加入：

对于加减乘除混合运算，则应该考虑优先级，乘除的优先级高于加减，应该先做乘除，再做加减：

下面我们要开始支持括号，负号，以及取得上一行四则运算表达式的值。

对于词法分析器，我们添加如下Token：

对于语法分析器，对于最基本的表达式，有四种情况：

其可以是一个NUMBER，也可以是上一行四则运算表达式的值PREVIOUS，也可以是被括号括起来的一个子语法表达式，也可以是取负的一个基本语法表达式。

(6) 用javacc编译calculator.jj来生成语法分析器和词法分析器

最后生成的calculator.jj如下：

生成的start函数如下：

final public void start(PrintStream printStream) throws ParseException, NumberFormatException {

  label_1:

  while (true) {

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case MINUS:

    case NUMBER:

    case OPEN_PAR:

    case PREVIOUS:

      ;

      break;

    default:

      jj_la1[0] = jj_gen;

      break label_1;

    }

    previousValue = Expression();

    printStream.println( previousValue ) ;

  }

}

final public double Expression() throws ParseException, NumberFormatException {

  double i ;

  double value ;

  value = Term();

  label_2:

  while (true) {

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case PLUS:

    case MINUS:

      ;

      break;

    default:

      jj_la1[1] = jj_gen;

      break label_2;

    }

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case PLUS:

      jj_consume_token(PLUS);

      i = Term();

      value += i ;

      break;

    case MINUS:

      jj_consume_token(MINUS);

      i = Term();

      value -= i ;

      break;

    default:

      jj_la1[2] = jj_gen;

      jj_consume_token(-1);

      throw new ParseException();

    }

  }

  {if (true) return value ;}

  throw new Error("Missing return statement in function");

}

final public double Term() throws ParseException, NumberFormatException {

  double i ;

  double value ;

  value = Primary();

  label_3:

  while (true) {

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case TIMES:

    case DIVIDE:

      ;

      break;

    default:

      jj_la1[3] = jj_gen;

      break label_3;

    }

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case TIMES:

      jj_consume_token(TIMES);

      i = Primary();

      value *= i ;

      break;

    case DIVIDE:

      jj_consume_token(DIVIDE);

      i = Primary();

      value /= i ;

      break;

    default:

      jj_la1[4] = jj_gen;

      jj_consume_token(-1);

      throw new ParseException();

    }

  }

  {if (true) return value ;}

  throw new Error("Missing return statement in function");

}

final public double Primary() throws ParseException, NumberFormatException {

  Token t ;

  double d ;

  switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

  case NUMBER:

    t = jj_consume_token(NUMBER);

    {if (true) return Double.parseDouble( t.image ) ;}

    break;

  case PREVIOUS:

    jj_consume_token(PREVIOUS);

    {if (true) return previousValue ;}

    break;

  case OPEN_PAR:

    jj_consume_token(OPEN_PAR);

    d = Expression();

    jj_consume_token(CLOSE_PAR);

    {if (true) return d ;}

    break;

  case MINUS:

    jj_consume_token(MINUS);

    d = Primary();

    {if (true) return -d ;}

    break;

  default:

    jj_la1[5] = jj_gen;

    jj_consume_token(-1);

    throw new ParseException();

  }

  throw new Error("Missing return statement in function");

}