用 Hadoop 进行分布式数据处理，第 1 部分: 入门

A variable-length format for positive integers is defined where the high-order bit of each byte indicates whether more bytes remain to be read. The low-order seven bits are appended as increasingly more significant bits in the resulting integer value. Thus values from zero to 127 may be stored in a single byte, values from 128 to 16,383 may be stored in two bytes, and so on.

可变格式的整型定义：最高位表示是否还有字节要读取，低七位就是就是具体的有效位，添加到

结果数据中。比如00000001 最高位表示0，那么说明这个数就是一个字节表示，有效位是后面的七位0000001，值为1。10000010 00000001 第一个字节最高位为1，表示后面还有字节，第二位最高位0表示到此为止了，即就是两个字节，那么具体的值注意，是从最后一个字节的七位有效数放在最前面，依次放置，最后是第一个自己的七位有效位，所以这个数表示 0000001 0000010，换算成整数就是130

VInt Encoding Example

Lucene源代码中进行存储和读取是这样的。OutputStream是负责写：

tomcat和jdk都安装好；

二：nutch-0.9.tar.gz
        将下载到的tar.gz包，解压到/opt目录下并改名：
        #gunzip -xf nutch-0.9.tar.gz |tar xf
        #mv nutch-0.9.tar.gz /usr/local/nutch
      
       测试环境是否设置成功：运行：/urs/local/nutch/bin/nutch看一下有没有命令参数输出，如果有说明没问题。

       抓取过程：#cd /opt/nutch
                         #mkdir urls
                         #vi nutch.txt 输入www.aicent.net
                         #vi conf/crawl-urlfilter.txt 加入以下信息：利用正则表达式对网站url抓取筛选。
                        /**** accept hosts in MY.DOMAIN.NAME******/
                                +^http://([a-z0-9]*\.)*aicent.net/
                       #vi nutch/nutch-site.xml（给自己的蜘蛛取一个名字）设置如下：
   <configuration>
<property>
    <name>http.agent.name</name>
    <value>test/unique</value>
</property>
</configuration>

                开始抓取：#bin/nutch crawl urls -dir crawl -detpth 5 -thread 10 >& crawl.log

等待一会，时间依据网站的大小，和设置的抓取深度。

三：apache-tomcat

                在这里，当你看到每次检索的页面为0里，需要修改一下参数，因为tomcat中的nutch的检索路径不对造成的。
                #vi /usr/local/tomcat/webapps/ROOT/WEB-INF/classes/nutch-site.xml
<property>
<name>searcher.dir</name>
<value>/opt/nutch/crawl</value>抓取网页所在的路径
<description>My path to nutch's searcher dir.</description>
</property>

                #/opt/tomcat/bin/startup.sh

OK,搞定。。。

问题汇总：

运行：sh ./bin/nutch crawl urls -dir crawl -depth 3 -threads 60 -topN 100 >&./logs/nutch_log.log

1.Exception in thread "main" java.io.IOException: Job failed!
        at org.apache.hadoop.mapred.JobClient.runJob(JobClient.java:604)
        at org.apache.nutch.crawl.Injector.inject(Injector.java:162)
        at org.apache.nutch.crawl.Crawl.main(Crawl.java:115)
网上查有说是JDK版本的问题，不能用JDK1.6，于是安装1.5。但是还是同样的问题，奇怪啊。
于是继续google，发现有如下的可能：

Injector: Converting injected urls to crawl db entries.
Exception in thread "main" java.io.IOException: Job failed!
        at org.apache.hadoop.mapred.JobClient.runJob(JobClient.java:604)
        at org.apache.nutch.crawl.Injector.inject(Injector.java:162)
        at org.apache.nutch.crawl.Crawl.main(Crawl.java:115)

说明：一般为crawl-urlfilters.txt中配置问题，比如过滤条件应为
+^http://www.ihooyo.com ,而配置成了 http://www.ihooyo.com 这样的情况就引起如上错误。

但是自己的配置根本就没有问题啊。
在Logs目录下面除了生成nutch_log.log还自动生成一个log文件：hadoop.log
发现有错误出现：

2009-07-22 22:20:55,501 INFO  crawl.Crawl - crawl started in: crawl
2009-07-22 22:20:55,501 INFO  crawl.Crawl - rootUrlDir = urls
2009-07-22 22:20:55,502 INFO  crawl.Crawl - threads = 60
2009-07-22 22:20:55,502 INFO  crawl.Crawl - depth = 3
2009-07-22 22:20:55,502 INFO  crawl.Crawl - topN = 100
2009-07-22 22:20:55,603 INFO  crawl.Injector - Injector: starting
2009-07-22 22:20:55,604 INFO  crawl.Injector - Injector: crawlDb: crawl/crawldb
2009-07-22 22:20:55,604 INFO  crawl.Injector - Injector: urlDir: urls
2009-07-22 22:20:55,605 INFO  crawl.Injector - Injector: Converting injected urls to crawl db entries.
2009-07-22 22:20:56,574 INFO  plugin.PluginRepository - Plugins: looking in: /opt/nutch/plugins
2009-07-22 22:20:56,720 INFO  plugin.PluginRepository - Plugin Auto-activation mode: [true]
2009-07-22 22:20:56,720 INFO  plugin.PluginRepository - Registered Plugins:
2009-07-22 22:20:56,720 INFO  plugin.PluginRepository -         the nutch core extension points (nutch-extensionpoints)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Basic Query Filter (query-basic)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Basic URL Normalizer (urlnormalizer-basic)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Basic Indexing Filter (index-basic)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Html Parse Plug-in (parse-html)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Basic Summarizer Plug-in (summary-basic)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Site Query Filter (query-site)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         HTTP Framework (lib-http)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Text Parse Plug-in (parse-text)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Regex URL Filter (urlfilter-regex)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Pass-through URL Normalizer (urlnormalizer-pass)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Http Protocol Plug-in (protocol-http)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Regex URL Normalizer (urlnormalizer-regex)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         OPIC Scoring Plug-in (scoring-opic)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         CyberNeko HTML Parser (lib-nekohtml)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         JavaScript Parser (parse-js)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         URL Query Filter (query-url)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Regex URL Filter Framework (lib-regex-filter)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository - Registered Extension-Points:
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Nutch Summarizer (org.apache.nutch.searcher.Summarizer)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Nutch URL Normalizer (org.apache.nutch.net.URLNormalizer)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Nutch Protocol (org.apache.nutch.protocol.Protocol)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Nutch Analysis (org.apache.nutch.analysis.NutchAnalyzer)
2009-07-22 22:20:56,721 INFO  plugin.PluginRepository -         Nutch URL Filter (org.apache.nutch.net.URLFilter)
2009-07-22 22:20:56,722 INFO  plugin.PluginRepository -         Nutch Indexing Filter (org.apache.nutch.indexer.IndexingFilter)
2009-07-22 22:20:56,722 INFO  plugin.PluginRepository -         Nutch Online Search Results Clustering Plugin (org.apache.nutch.clustering.OnlineClusterer)
2009-07-22 22:20:56,722 INFO  plugin.PluginRepository -         HTML Parse Filter (org.apache.nutch.parse.HtmlParseFilter)
2009-07-22 22:20:56,722 INFO  plugin.PluginRepository -         Nutch Content Parser (org.apache.nutch.parse.Parser)
2009-07-22 22:20:56,722 INFO  plugin.PluginRepository -         Nutch Scoring (org.apache.nutch.scoring.ScoringFilter)
2009-07-22 22:20:56,722 INFO  plugin.PluginRepository -         Nutch Query Filter (org.apache.nutch.searcher.QueryFilter)
2009-07-22 22:20:56,722 INFO  plugin.PluginRepository -         Ontology Model Loader (org.apache.nutch.ontology.Ontology)
2009-07-22 22:20:56,786 WARN  regex.RegexURLNormalizer - can't find rules for scope 'inject', using default
2009-07-22 22:20:56,829 WARN  mapred.LocalJobRunner - job_2319eh
java.lang.RuntimeException: java.net.UnknownHostException: jackliu: jackliu
        at org.apache.hadoop.io.SequenceFile$Writer.<init>(SequenceFile.java:617)
        at org.apache.hadoop.io.SequenceFile$Writer.<init>(SequenceFile.java:591)
        at org.apache.hadoop.io.SequenceFile.createWriter(SequenceFile.java:364)
        at org.apache.hadoop.io.SequenceFile.createWriter(SequenceFile.java:390)
        at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.startPartition(MapTask.java:294)
        at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.sortAndSpillToDisk(MapTask.java:355)
        at org.apache.hadoop.mapred.MapTask$MapOutputBuffer.access$100(MapTask.java:231)
        at org.apache.hadoop.mapred.MapTask.run(MapTask.java:180)
        at org.apache.hadoop.mapred.LocalJobRunner$Job.run(LocalJobRunner.java:126)
Caused by: java.net.UnknownHostException: jackliu: jackliu
        at java.net.InetAddress.getLocalHost(InetAddress.java:1353)
        at org.apache.hadoop.io.SequenceFile$Writer.<init>(SequenceFile.java:614)
        ... 8 more

也就是Host配置错误，于是：
Add the following to your /etc/hosts file
127.0.0.1    jackliu

这次再次运行，结果成功！

2:http://127.0.0.1:8080/nutch-0.9
 输入nutch进行查询，结果报错：
 HTTP Status 500 -

type Exception report

message

description The server encountered an internal error () that prevented it from fulfilling this request.

exception

org.apache.jasper.JasperException: /search.jsp(151,22) Attribute value  language + "/include/header.html" is quoted with " which must be escaped when used within the value
 org.apache.jasper.compiler.DefaultErrorHandler.jspError(DefaultErrorHandler.java:40)
 org.apache.jasper.compiler.ErrorDispatcher.dispatch(ErrorDispatcher.java:407)
 org.apache.jasper.compiler.ErrorDispatcher.jspError(ErrorDispatcher.java:198)
 org.apache.jasper.compiler.Parser.parseQuoted(Parser.java:299)
 org.apache.jasper.compiler.Parser.parseAttributeValue(Parser.java:249)
 org.apache.jasper.compiler.Parser.parseAttribute(Parser.java:211)
 org.apache.jasper.compiler.Parser.parseAttributes(Parser.java:154)
 org.apache.jasper.compiler.Parser.parseInclude(Parser.java:867)
 org.apache.jasper.compiler.Parser.parseStandardAction(Parser.java:1134)
 org.apache.jasper.compiler.Parser.parseElements(Parser.java:1461)
 org.apache.jasper.compiler.Parser.parse(Parser.java:137)
 org.apache.jasper.compiler.ParserController.doParse(ParserController.java:255)
 org.apache.jasper.compiler.ParserController.parse(ParserController.java:103)
 org.apache.jasper.compiler.Compiler.generateJava(Compiler.java:170)
 org.apache.jasper.compiler.Compiler.compile(Compiler.java:332)
 org.apache.jasper.compiler.Compiler.compile(Compiler.java:312)
 org.apache.jasper.compiler.Compiler.compile(Compiler.java:299)
 org.apache.jasper.JspCompilationContext.compile(JspCompilationContext.java:586)
 org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:317)
 org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:342)
 org.apache.jasper.servlet.JspServlet.service(JspServlet.java:267)
 javax.servlet.http.HttpServlet.service(HttpServlet.java:717)

note The full stack trace of the root cause is available in the Apache Tomcat/6.0.20 logs.

分析：查看nutch Web应用根目录下的search.jsp可知，是引号匹配的问题。

<jsp:include page="<%= language + "/include/header.html"%>"/>  //line 152 search.jsp

第一个引号和后面第一个出现的引号进行匹配，而不是和这一行最后一个引号进行匹配，所以问题就出现了。

解决方法：

将该行代码修改为：<jsp:include page="<%= language+urlsuffix %>"/>

这里我们定一个字符串urlsuffix，我们把它定义在language字符串定义之后，

  String language =   // line 116 search.jsp
    ResourceBundle.getBundle("org.nutch.jsp.search", request.getLocale())
    .getLocale().getLanguage();
 String urlsuffix="/include/header.html";

修改完成后，为确保修改成功，重启一下Tomcat服务器，进行搜索，不再报错。

3.无法查询结果？
  对比nutch_log.log的结果发现和网上描述的不同，而且crawl里面只有两个文件夹segments和crawldb，后来重新爬了一次
  发现这次是好的，奇怪不知道为什么上次爬的失败了。
 
4.cached.jsp explain.jsp等都有上面3的错误，更正过去就OK了。

5.今天花了一上午和半个下午的时间终于搞定了nutch的安装和配置了。明天继续学习。

顺序很重要：
    String[] phrase = new String[] {"fox", "quick"};
assertFalse("hop flop", matched(phrase, 2));
assertTrue("hop hop slop", matched(phrase, 3));

原理如下图所示：


对于查询关键字quick和fox，只需要fox移动一个位置即可匹配quick brown fox。而对于fox和quick这两个关键字
需要将fox移动三个位置。移动的距离越大，那么这项记录的score就越小，被查询出来的可能行就越小了。

SpanQuery利用位置信息查询更有意思的查询：

SpanQuery type         Description
SpanTermQuery         Used in conjunction with the other span query types. On its own, it’s
                                        functionally equivalent to TermQuery.
SpanFirstQuery         Matches spans that occur within the first part of a field.
SpanNearQuery         Matches spans that occur near one another.
SpanNotQuery         Matches spans that don’t overlap one another.
SpanOrQuery             Aggregates matches of span queries.

SpanFirstQuery：To query for spans that occur within the first n positions of a field, use Span-FirstQuery.



quick = new SpanTermQuery(new Term("f", "quick"));
brown = new SpanTermQuery(new Term("f", "brown"));
red = new SpanTermQuery(new Term("f", "red"));
fox = new SpanTermQuery(new Term("f", "fox"));
lazy = new SpanTermQuery(new Term("f", "lazy"));
sleepy = new SpanTermQuery(new Term("f", "sleepy"));
dog = new SpanTermQuery(new Term("f", "dog"));
cat = new SpanTermQuery(new Term("f", "cat"));

SpanFirstQuery sfq = new SpanFirstQuery(brown, 2);
assertNoMatches(sfq);
sfq = new SpanFirstQuery(brown, 3);
assertOnlyBrownFox(sfq);

SpanNearQuery：

彼此相邻的跨度

      首先，强调一下PhraseQuery对象，这个对象不属于跨度查询类，但能完成跨度查询功能。

      匹配到的文档所包含的项通常是彼此相邻的，考虑到原文档中在查询项之间可能有一些中间项，或为了能查询倒排的项，PhraseQuery设置了slop因子，但是这个slop因子指2个项允许最大间隔距离，不是传统意义上的距离，是按顺序组成给定的短语，所需要移动位置的次数，这表示PhraseQuery是必须按照项在文档中出现的顺序计算跨度的，如quick brown fox为文档，则quick fox2个项的slop为1，quick向后移动一次.而fox quick需要quick向后移动3次，所以slop为3

      其次，来看一下SpanQuery的子类SpanTermQuery。

      它能跨度查询，并且不一定非要按项在文档中出现的顺序，可以用一个独立的标记表示查询对象必须按顺序，或允许按倒过来的顺序完成匹配。匹配的跨度也不是指移动位置的次数，是指从第一个跨度的起始位置到最后一个跨度的结束位置。

      在SpanNearQuery中将SpanTermQuery对象作为SpanQuery对象使用的效果，与使用PharseQuery的效果非常相似。在SpanNearQuery的构造函数中的第三个参数为inOrder标志，设置这个标志，表示按项在文档中出现的顺序倒过来的顺序。

      如:the quick brown fox jumps over the lazy dog这个文档

      public void testSpanNearQuery() throws Exception{

           SpanQuery[] quick_brown_dog=new SpanQuery[]{quick,brown,dog};

           SpanNearQuery snq=new SpanNearQuery(quick_brown_dog,0,true);//按正常顺序,跨度为0,对三个项进行查询

           assertNoMatches(snq);//无法匹配

           SpanNearQuery snq=new SpanNearQuery(quick_brown_dog,4,true);//按正常顺序,跨度为4,对三个项进行查询

           assertNoMatches(snq);//无法匹配

           SpanNearQuery snq=new SpanNearQuery(quick_brown_dog,4,true);//按正常顺序,跨度为5,对三个项进行查询

           assertOnlyBrownFox(snq);//匹配成功    

           SpanNearQuery snq=new SpanNearQuery(new SpanQuery[]{lazy,fox},3,false);//按相反顺序,跨度为3,对三个项进行查询

           assertOnlyBrownFox(snq);//匹配成功   

           //下面使用PhraseQuery进行查询，因为是按顺序，所以lazy和fox必须要跨度为5

           PhraseQuery pq=new PhraseQuery();

           pq.add(new Term("f","lazy"));

           pq.add(new Term("f","lazy"));

           pq.setslop(4);

           assertNoMatches(pq);//跨度4无法匹配

           //PharseQuery,slop因子为5

           pq.setSlop(5);

           assertOnlyBrownFox(pq);          

      }


3.PhrasePrefixQuery 主要用来进行同义词查询的：
    IndexWriter writer = new IndexWriter(directory, new WhitespaceAnalyzer(), true);
    Document doc1 = new Document();
    doc1.add(Field.Text("field", "the quick brown fox jumped over the lazy dog"));
    writer.addDocument(doc1);
    Document doc2 = new Document();
    doc2.add(Field.Text("field","the fast fox hopped over the hound"));
    writer.addDocument(doc2);

    PhrasePrefixQuery query = new PhrasePrefixQuery();
    query.add(new Term[] {new Term("field", "quick"), new Term("field", "fast")});
    query.add(new Term("field", "fox"));

    Hits hits = searcher.search(query);
    assertEquals("fast fox match", 1, hits.length());
    query.setSlop(1);
    hits = searcher.search(query);
    assertEquals("both match", 2, hits.length());

int *binarySearch(int val, int array[], int n)

{

int m = n/2;

if(n <= 0) return NULL;

if(val == array[m]) return array + m;

if(val < array[m]) return binarySearch(val, array, m);

else return binarySearch(val, array+m+1, n-m-1);

}

对于有n个元素的数组来说，二元搜索算法进行最多1+log2(n)次比较。 如果有一百万元素，大概比较20次，也就是最多20次递归执行binarySearch()函数。

3.Index dates
 Document doc = new Document();
 doc.add(Field.Keyword("indexDate", new Date()));

4.Tuning indexing performance
 IndexWriter          System property                            Default value          Description
 --------------------------------------------------------------------------------------------------
 mergeFactor          org.apache.lucene.mergeFactor        10       Controls segment merge  frequency and size
 maxMergeDocs     org.apache.lucene.maxMergeDocs   Integar.MAX_VALUE    Limits the number of  documents per segement
 minMergeDocs         org.apache.lucene.minMergeDocs     10     Controls the amount of   RAM used when indexing

mergeFactor控制写入硬盘前内存中缓存的document数量，同时控制merge index segments的频率。其默认值是10，即存满10个
documents后就必须写入硬盘，而且如果segment的数量达到10的级数的时候会merge成一个segment，当然maxMergeDocs限制了每个
segment最大能够保存的document数量。mergeFactor越大的话就越能利用RAM，提高index的效率，但是mergeFactor越高也就意味着
merge的频率就越低，会可能导致segments的数量很大（因为没有merge），这样search的时候就需要打开更多的segment文件，也就
降低了search的效率。minMergeDocs is another IndexWriter instance variable that affects indexing performance. Its
value controls how many Documents have to be buffered before they’re merged to a segment.也即是说minMergeDocs也具有
mergeFactor控制缓存document数量的功能。

5.RAMDirectory帮助利用RAM，也可以采用集群或者多线程的方式充分利用硬件和软件资源，提高index的效率。

6.有时候对于每个field可能希望控制其大小，比如只对前1000个term做index，这个时候就需要使用maxFieldLength来控制。

7.IndexWriter’s optimize()方法就是将segments进行merge，降低segments的数量从而减少search的时候读取index的时间。

8.注意多线程环境下的工作：an index-modifying IndexReader operation can’t be executed
while an index-modifying IndexWriter operation is in progress.为了防止误用，Lucene在使用某些API时会给
index上锁。

1.TermQuery常用，对一个Term（最小的索引块，包含一个field名字和值）进行索引查询。
Term直接与QueryParser.parse里面的key和field直接对应。

 IndexSearcher searcher = new IndexSearcher(directory);
 Term t = new Term("isbn", "1930110995");
 Query query = new TermQuery(t);
 Hits hits = searcher.search(query);

2.RangeQuery用于区间查询,RangeQuery的第三个参数表示是开区间还是闭区间。
QueryParser会构建从begin到end之间的N个查询进行查询。

 Term begin, end;
 Searcher searcher = new IndexSearcher(dbpath);
 begin = new Term("pubmonth","199801");
 end = new Term("pubmonth","199810");
 RangeQuery query = new RangeQuery(begin, end, true);

RangeQuery本质是比较大小。所以如下查询也是可以的，但是意义就于上面不大一样了，总之是大小的比较
设定了一个区间，在区间内的都能够搜索出来，这里就存在一个比较大小的原则，比如字符串会首先比较第一个字符，这样与字符长度没有关系。
begin = new Term("pubmonth","19");
 end = new Term("pubmonth","20");
 RangeQuery query = new RangeQuery(begin, end, true);


3.PrefixQuery.对于TermQuery，必须完全匹配（用Field.Keyword生成的字段）才能够查询出来。
这就制约了查询的灵活性，PrefixQuery只需要匹配value的前面任何字段即可。如Field为name，记录
中那么有jackliu,jackwu,jackli,那么使用jack就可以查询出所有的记录。QueryParser creates a PrefixQuery
for a term when it ends with an asterisk (*) in query expressions.

 IndexSearcher searcher = new IndexSearcher(directory);
 Term term = new Term("category", "/technology/computers/programming");
 PrefixQuery query = new PrefixQuery(term);
 Hits hits = searcher.search(query);

4.BooleanQuery.上面所有的查询都是基于单个field的查询，多个field怎么查询呢，BooleanQuery
就是解决多个查询的问题。通过add(Query query, boolean required, boolean prohibited)加入
多个查询.通过BooleanQuery的嵌套可以组合非常复杂的查询。
 
 IndexSearcher searcher = new IndexSearcher(directory);
 TermQuery searchingBooks =
 new TermQuery(new Term("subject","search"));

 RangeQuery currentBooks =
 new RangeQuery(new Term("pubmonth","200401"),
  new Term("pubmonth","200412"),true);
  
 BooleanQuery currentSearchingBooks = new BooleanQuery();
 currentSearchingBooks.add(searchingBook s, true, false);
 currentSearchingBooks.add(currentBooks, true, false);
 Hits hits = searcher.search(currentSearchingBooks);

BooleanQuery的add方法有两个boolean参数：
true＆false：表明当前加入的子句是必须要满足的；
false＆true：表明当前加入的子句是不可以被满足的；
false＆false：表明当前加入的子句是可选的；
true＆true：错误的情况。

QueryParser handily constructs BooleanQuerys when multiple terms are specified.
Grouping is done with parentheses, and the prohibited and required flags are
set when the –, +, AND, OR, and NOT operators are specified.

5.PhraseQuery进行更为精确的查找。它能够对索引文本中的两个或更多的关键词的位置进行
限定。如搜查包含A和B并且A、B之间还有一个文字。Terms surrounded by double quotes in
QueryParser parsed expressions are translated into a PhraseQuery.
The slop factor defaults to zero, but you can adjust the slop factor
by adding a tilde (~) followed by an integer.
For example, the expression "quick fox"~3

6.WildcardQuery.WildcardQuery比PrefixQuery提供了更细的控制和更大的灵活性，这个最容易
理解和使用。

7.FuzzyQuery.这个Query比较特别，它会查询与关键字长得很像的其他记录。QueryParser
supports FuzzyQuery by suffixing a term with a tilde (~),for exmaple wuzza~.

 public void testFuzzy() throws Exception {
  indexSingleFieldDocs(new Field[] {
  Field.Text("contents", "fuzzy"),
  Field.Text("contents", "wuzzy")
  });
  IndexSearcher searcher = new IndexSearcher(directory);
  Query query = new FuzzyQuery(new Term("contents", "wuzza"));
  Hits hits = searcher.search(query);
  assertEquals("both close enough", 2, hits.length());
  assertTrue("wuzzy closer than fuzzy",
  hits.score(0) != hits.score(1));
  assertEquals("wuzza bear","wuzzy", hits.doc(0).get("contents"));
 }