Lucene-2.0学习文档

Lucene是apache组织的一个用java实现全文搜索引擎的开源项目。其功能非常的强大，api也很简单。总得来说用Lucene来进行建立和搜索和操作数据库是差不多的，Document可以看作是数据库的一行记录，Field可以看作是数据库的字段。用lucene实现搜索引擎就像用JDBC实现连接数据库一样简单。
值得一提的是：2006年6月1号Lucene2.0发布，它与以前广泛应用和介绍的Lucene 1.4.3并不兼容。有了很大的改进和优化，这里只介绍的是Lucene 2.0。
Lucene2.0的下载地址是http://apache.justdn.org/lucene/java/

大家先看一个例子，通过这个例子来对lucene的一个大概的认识。
一个Junit测试用例：(为了让代码清晰好看，我们将异常都抛出)
a)    这是一个建立文件索引的例子
public void testIndexHello() throws IOException{
        Date date1 = new Date();
        //可以说是创建一个新的写入工具
        //第一个参数是要索引建立在哪个目录里
        //第二个参数是新建一个文本分析器,这里用的是标准的大家也可以自己写一个
        //第三个参数如果是true，在建立索引之前先将c:\\\\index目录清空。
        IndexWriter writer = new IndexWriter("c:\\\\index",new StandardAnalyzer(),true);
        //这个是数据源的文件夹
        File file = new File("c:\\\\file");
        /**
         * 例子主要是将C:\\\\file目录下的文件的内容进行建立索引，将文件路径作为搜索内容的附属< span lang="EN-US">.
         */
        if(file.isDirectory()){
           String[] fileList = file.list();
            for (int i = 0; i < fileList.length; i++){
                //建立一个新的文档,它可以看作是数据库的一行记录
                Document doc = new Document();
              File f = new File(file, fileList[i]);
              Reader reader = new BufferedReader(new FileReader(f));
              doc.add(new Field("file",reader));//为doument添加field
              doc.add(new Field("path",f.getAbsolutePath(),Field.Store.YES,Field.Index.NO));
                writer.addDocument(doc);
            }
        }
        writer.close();//这一步是必须的，只有这样数据才会被写入索引的目录里
        Date date2 = new Date();
        System.out.println("用时"+(date2.getTime()-date1.getTime())+"毫秒");
}

注意：因为建立索引可能费时，如果最后输出的用时比较长，请不要奇怪。
b)一个通过索引来全文检索的例子
public void HelloSearch() throws IOException, ParseException{
        //和上面的IndexWriter一样是一个工具
        IndexSearcher indexSearcher = new IndexSearcher("c:\\\\index");
        QueryParser queryParser = new QueryParser("file",
                //这是一个分词器
                new StandardAnalyzer());
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //这个地方Query是抽象类大家也注意一下，下面会讲到的
        Query query = queryParser.parse(br.readLine());
        Hits hits = indexSearcher.search(query);
        Document doc = null;
        System.out.print("正搜索................");
        for (int i = 0; i < hits.length(); i++){
            doc = hits.doc(i);
            //注意这里输出的是什么
            System.out.println("内容是："+doc.get("file"));
            System.out.println("文件的路径是：" + doc.get("path"));
        }
    }

通过上面的两个例子应该可以看出Lucene还是比较简单的。

运行一下上面的两个例子，大家可能会说怎么doc.get(“file”);返回的是空呢,我们马上会讲到。

下面讲一下索引的建立
其实从上面的例子就可以看出建立索引就用到Document,IndexWriter,Field。
最简单的步骤就是：
首先分别new 一个Document，IndexWriter,Field
然后用Doument.add()方法加入Field,
其次用IndexWrtier.addDocument()方法加入Document。
最后调用一下IndexWriter.close()方法关闭输入索引，这一步非常的重要只有调用这个方法索引才会被写入索引的目录里，而这是被很多初学的人所忽略的。

Document没有什么好介绍的，把它的作用看成数据库中的一行记录就行。
Field是一个比较重要的也是比较复杂的：
看一下它的构造函数有5个：
Field(String name, byte[] value, Field.Store store)
Field(String name, Reader reader)
Field(String name, Reader reader, Field.TermVector termVector)
Field(String name, String value, Field.Store store, Field.Index index)
Field(String name, String value, Field.Store store, Field.Index index, Field.TermVector termVector)

在Field中有三个内部类：Field.Index,Field.Store,Field.termVector，而构造函数也用到了它们。
注意：termVector是Lucene 1.4新增的它提供一种向量机制来进行模糊查询的这个不常用，默认是false不过是什么对于一般查询无影响。
它们的不同的组合，在全文检索中有着不同的作用。看看下面的表吧:
Field.Index         Field.Store             说明
TOKENIZED(分词)     YES                     文章的标题或内容(如果是内容的话不能太长)是可以被搜索的

TOKENIZED           NO                      文章的标题或内容(内容可以很长)也是可以被看过的

NO                  YES                     这是不能被搜索的，它只是被搜索内容的附属物。如URL等

UN_TOKENIZED        YES/NO                  不被分词，它作为一个整体被搜索,搜一部分是搜不出来的

NO                  NO                      没有这种用法

而对于
Field(String name, Reader reader)
Field(String name, Reader reader, Field.TermVector termVector)
他们是Field.Index.TOKENIZED和Field.Store.NO的。这就是为什么我们在上面的例子中会出现文章的内容为 null了。因为它只是被索引了，而并没有被存储下来。如果一定要看到文章的内容的话可以通过文章的路径得到,毕竟文章的路径是作为搜索的附属物被搜索出来了。而我们在Web开发的时候一般是将大数据放在数据库中，不会放在文件系统中，更不会放在索引目录里，因为它太大了操作会加大服务器的负担。

下面介绍一下IndexWriter:
它就是一个写入索引的写入器,它的任务比较简单：
1.用addDocument()将已经准备好写入索引的document们加入
2.调用close()将索引写入索引目录
先看一下它的构造函数:
IndexWriter(Directory d, Analyzer a, boolean create)
IndexWriter(File path, Analyzer a, boolean create)
IndexWriter(String path, Analyzer a, boolean create)

可见构造它需要一个索引文件目录，一个分析器(一般用标准的这个)，最后一个参数是标识是否清空索引目录
它有一些设置参数的功能如：设置Field的最大长度
看个例子：
public void IndexMaxField() throws IOException{
        IndexWriter indexWriter= new IndexWriter("c:\\\\index",new StandardAnalyzer(),true);
        Document doc1 = new Document();
        doc1.add(new Field("name1","程序员之家",Field.Store.YES,Field.Index.TOKENIZED));
        Document doc2 = new Document();
        doc2.add(new Field("name2","Welcome to the Home of programers",Field.Store.YES,Field.Index.TOKENIZED));
        indexWriter.setMaxFieldLength(5);
        indexWriter.addDocument(doc1);
        indexWriter.setMaxFieldLength(3);
        indexWriter.addDocument(doc1);
        indexWriter.setMaxFieldLength(0);
        indexWriter.addDocument(doc2);
        indexWriter.setMaxFieldLength(3);
        indexWriter.addDocument(doc2);
        indexWriter.close();
}

public void SearcherMaxField() throws ParseException, IOException{
        Query query = null;
        Hits hits = null;
        IndexSearcher indexSearcher= null;
        QueryParser queryParser= null;
        queryParser = new QueryParser("name1",new StandardAnalyzer());
        query = queryParser.parse("程序员");
        indexSearcher= new IndexSearcher("c:\\\\index");
        hits = indexSearcher.search(query);
        System.out.println("您搜的是：程序员");
        System.out.println("找到了"+hits.length()+"个结果");
        System.out.println("它们分别是：");
        for (int i = 0; i < hits.length(); i++){
            Document doc = hits.doc(i);
            System.out.println(doc.get("name1"));
        }
        query = queryParser.parse("程序员之家");
        indexSearcher= new IndexSearcher("c:\\\\index");
        hits = indexSearcher.search(query);
        System.out.println("您搜的是：程序员之家");
        System.out.println("找到了"+hits.length()+"个结果");
        System.out.println("它们分别是：");
        for (int i = 0; i < hits.length(); i++){
            Document doc = hits.doc(i);
            System.out.println(doc.get("name1"));
        }
        queryParser = new QueryParser("name2",new StandardAnalyzer());
        query = queryParser.parse("Welcome");
        indexSearcher= new IndexSearcher("c:\\\\index");
        hits = indexSearcher.search(query);
        System.out.println("您搜的是：Welcome");
        System.out.println("找到了"+hits.length()+"个结果");
        System.out.println("它们分别是：");
        for (int i = 0; i < hits.length(); i++){
            Document doc = hits.doc(i);
            System.out.println(doc.get("name2"));
        }
        query = queryParser.parse("the");
        indexSearcher= new IndexSearcher("c:\\\\index");
        hits = indexSearcher.search(query);
        System.out.println("您搜的是：the");
        System.out.println("找到了"+hits.length()+"个结果");
        System.out.println("它们分别是：");
        for (int i = 0; i < hits.length(); i++){
            Document doc = hits.doc(i);
            System.out.println(doc.get("name2"));
        }
        query = queryParser.parse("home");
        indexSearcher= new IndexSearcher("c:\\\\index");
        hits = indexSearcher.search(query);
        System.out.println("您搜的是：home");
        System.out.println("找到了"+hits.length()+"个结果");
        System.out.println("它们分别是：");
        for (int i = 0; i < hits.length(); i++){
            Document doc = hits.doc(i);
            System.out.println(doc.get("name2"));
        }
}

它的运行结果为:
----------------------------------------------
您搜的是：程序员
找到了2个结果
它们分别是：
程序员之家
程序员之家
您搜的是：程序员之家
找到了1个结果
它们分别是：
程序员之家
您搜的是：Welcome
找到了2个结果
它们分别是：
Welcome to the Home of programers
Welcome to the Home of programers
您搜的是：the
找到了0个结果
它们分别是：
您搜的是：home
找到了1个结果
它们分别是：
Welcome to the Home of programers
-----------------------------------------------
总结一下：
1.设置Field的长度限制只是限制了搜索。如果用了Field.Store.YES的话还是会全部被保存进索引目录里的。
2.为什么搜the没有搜出来呢是因为lucene分析英文的时候不会搜索the to of 等无用的词(搜这些词是无意义的)。
3.New StandardAnlayzer()对于英文的分词是按空格和一些无用的词，而中文呢，就是全部的单个的字。
4.设置Field的最大长度是以0开头和数组一样。
程序员之家----------3--------程序员之
                                    0 1 2 3
Welcome to the home of programmers------3------Welcome to the home of programmers
                                                   0           1         2
大家还可以试一下别的，以便加深一下印象

到现在我们已经可以用lucene建立索引了
下面介绍一下几个功能来完善一下：
1．索引格式
其实索引目录有两种格式，一种是除配置文件外，每一个Document独立成为一个文件（这种搜索起来会影响速度）。另一种是全部的Document成一个文件，这样属于复合模式就快了。
2.索引文件可放的位置：
索引可以存放在两个地方1.硬盘，2.内存
放在硬盘上可以用FSDirectory()，放在内存的用RAMDirectory()不过一关机就没了
FSDirectory.getDirectory(File file, boolean create)
FSDirectory.getDirectory(String path, boolean create)两个工厂方法返回目录
New RAMDirectory()就直接可以
再和IndexWriter(Directory d, Analyzer a, boolean create)一配合就行了
如：
IndexWrtier indexWriter = new IndexWriter(FSDirectory.getDirectory(“c:\\\\index”,true),new StandardAnlyazer(),true);
IndexWrtier indexWriter = new IndexWriter(new RAMDirectory(),new StandardAnlyazer(),true);
3.索引的合并
这个可用IndexWriter.addIndexes(Directory[] dirs)将目录加进去
来看个例子:
public void UniteIndex() throws IOException{
        /* FS */
        IndexWriter writerDisk = new IndexWriter(FSDirectory.getDirectory("c:\\\\indexDisk", true),new StandardAnalyzer(),true);
        Document docDisk = new Document();
        docDisk.add(new Field("name","程序员之家",Field.Store.YES,Field.Index.TOKENIZED));
        writerDisk.addDocument(docDisk);
        Document docDisk1 = new Document();
        docDisk1.add(new Field("name","IndexSearcher indexSearcher =new IndexSearcher",Field.Store.YES,Field.Index.TOKENIZED));
        writerDisk.addDocument(docDisk1);

        /* RAM */
        RAMDirectory ramDir = new RAMDirectory();
        IndexWriter writerRam = new IndexWriter(ramDir,new StandardAnalyzer(),true);
        Document docRam = new Document();
        docRam.add(new Field("name","程序员杂志",Field.Store.YES,Field.Index.TOKENIZED));
        writerRam.addDocument(docRam);

        /* Notice here: the method of "close()" */
        writerRam.close();
        /* Unite */
        writerDisk.addIndexes(new Directory[]{ramDir});
        writerDisk.close();
    }

    public void UniteSearch() throws ParseException, IOException{
        QueryParser queryParser = new QueryParser("name",new StandardAnalyzer());
        Query query = queryParser.parse("程序员");
        IndexSearcher indexSearcher =new IndexSearcher("c:\\\\indexDisk");
        Hits hits = indexSearcher.search(query);
        System.out.println("找到了"+hits.length()+"结果");
        for(int i=0;i<hits.length();i++){
            Document doc = hits.doc(i);
            System.out.println(doc.get("name"));
        }
}

这个例子是将内存中的索引合并到硬盘上来.
注意：合并的时候一定要将被合并的那一方的IndexWriter的close()方法调用。

4.对索引的其它操作:
IndexReader类是用来操作索引的，它有对Document,Field的删除等操作。

下面一部分的内容是：全文的搜索
全文的搜索主要是用：IndexSearcher,Query,Hits,Document(都是Query的子类),有的时候用QueryParser
主要步骤：
1.new QueryParser(Field字段，new 分析器)
2.Query query = QueryParser.parser(“要查询的字串”);这个地方我们可以用反射api看一下query究竟是什么类型
3.new IndexSearcher(索引目录).search(query);返回Hits
4.用Hits.doc(n);可以遍历出Document
5.用Document可得到Field的具体信息了。
其实1　，2两步就是为了创建Query 实例，究竟是什么类型的看分析器了。
拿以前的例子来说吧
        QueryParser queryParser = new QueryParser("name",new StandardAnalyzer());
        Query query = queryParser.parse("程序员");
        /*这里返回的就是org.apache.lucene.search.PhraseQuery*/
        IndexSearcher indexSearcher =new IndexSearcher("c:\\\\indexDisk");
        Hits hits = indexSearcher.search(query);

不管是什么类型，无非返回的就是Query的子类，我们完全可以不用这两步直接new个Query的子类的实例就ok了，不过一般还是用这两步因为它返回的是PhraseQuery这个是非常强大的query子类它可以进行多字搜索用QueryParser可以设置各个关键字之间的关系这个是最常用的了。

IndexSearcher:
其实IndexSearcher它内部自带了一个IndexReader用来读取索引的，IndexSearcher有个close()方法，这个方法不是用来关闭IndexSearcher的是用来关闭自带的IndexReader。
QueryParser呢可以用parser.setOperator()来设置各个关键字之间的关系（与还是）它可以自动通过空格从字串里面将关键字分离出来。
注意：用QueryParser搜索的时候分析器一定的和建立索引时候用的分析器是一样的。

Query:
可以看一个lucene2.0的帮助文档有很多的子类:
BooleanQuery, ConstantScoreQuery, ConstantScoreRangeQuery, DisjunctionMaxQuery（分离）, FilteredQuery, MatchAllDocsQuery, MultiPhraseQuery（短语）, MultiTermQuery, PhraseQuery, PrefixQuery, RangeQuery, SpanQuery, TermQuery
各自有用法看一下文档就能知道它们的用法了

下面一部分讲一下lucene的分析器:
分析器是由分词器和过滤器组成的，拿英文来说吧分词器就是通过空格把单词分开，过滤器就是把the,to,of等词去掉不被搜索和索引。
我们最常用的是StandardAnalyzer()它是lucene的标准分析器它集成了内部的许多的分析器。

最后一部分了：lucene的高级搜索了
1.排序
Lucene有内置的排序用IndexSearcher.search(query,sort)但是功能并不理想。我们需要自己实现自定义的排序。
这样的话得实现两个接口: ScoreDocComparator, SortComparatorSource

用IndexSearcher.search(query,new Sort(new SortField(String Field,SortComparatorSource)));

就看个例子吧：
这是一个建立索引的例子：
public void IndexSort() throws IOException{
        IndexWriter writer = new IndexWriter("C:\\\\indexStore",new StandardAnalyzer(),true);
        Document doc = new Document();
        doc.add(new Field("sort","1",Field.Store.YES,Field.Index.TOKENIZED));
        writer.addDocument(doc);
        doc = new Document();
        doc.add(new Field("sort","4",Field.Store.YES,Field.Index.TOKENIZED));
        writer.addDocument(doc);
        doc = new Document();
        doc.add(new Field("sort","3",Field.Store.YES,Field.Index.TOKENIZED));
        writer.addDocument(doc);
        doc = new Document();
        doc.add(new Field("sort","5",Field.Store.YES,Field.Index.TOKENIZED));
        writer.addDocument(doc);
        doc = new Document();
        doc.add(new Field("sort","9",Field.Store.YES,Field.Index.TOKENIZED));
        writer.addDocument(doc);
        doc = new Document();
        doc.add(new Field("sort","6",Field.Store.YES,Field.Index.TOKENIZED));
        writer.addDocument(doc);
        doc = new Document();
        doc.add(new Field("sort","7",Field.Store.YES,Field.Index.TOKENIZED));
        writer.addDocument(doc);
        writer.close();
}

下面是搜索的例子:
public void SearchSort1() throws IOException, ParseException{
        IndexSearcher indexSearcher = new IndexSearcher("C:\\\\indexStore");
        QueryParser queryParser = new QueryParser("sort",new StandardAnalyzer());
        Query query = queryParser.parse("4");
        Hits hits = indexSearcher.search(query);
        System.out.println("有"+hits.length()+"个结果");
        Document doc = hits.doc(0);
        System.out.println(doc.get("sort"));
}

public void SearchSort2() throws IOException, ParseException{
        IndexSearcher indexSearcher = new IndexSearcher("C:\\\\indexStore");
        //这个地方前面没有提到，它是用于范围的Query可以看一下帮助文档.
        Query query = new RangeQuery(new Term("sort","1"),new Term("sort","9"),true);
        Hits hits = indexSearcher.search(query,new Sort(new SortField("sort",new MySortComparatorSource())));
        System.out.println("有"+hits.length()+"个结果");
        for(int i=0;i<hits.length();i++){
            Document doc = hits.doc(i);
            System.out.println(doc.get("sort"));
        }
}

public class MyScoreDocComparator implements ScoreDocComparator{
    private Integer[]sort;
    public MyScoreDocComparator(String s,IndexReader reader, String fieldname) throws IOException{
        sort = new Integer[reader.maxDoc()];
        for(int i = 0;i<reader.maxDoc();i++){
            Document doc =reader.document(i);
            sort[i]=new Integer(doc.get("sort"));
        }
    }

    public int compare(ScoreDoc i, ScoreDoc j){
        if(sort[i.doc]>sort[j.doc])
            return 1;
        if(sort[i.doc]<sort[j.doc])
            return -1;
        return 0;
    }
    public int sortType(){
        return SortField.INT;
    }
    public Comparable sortValue(ScoreDoc i){
        // TODO 自动生成方法存根
        return new Integer(sort[i.doc]);
    }
}

public class MySortComparatorSource implements SortComparatorSource{
    private static final long serialVersionUID = -9189690812107968361L;
    public ScoreDocComparator newComparator(IndexReader reader, String fieldname)
            throws IOException{
        if(fieldname.equals("sort"))
            return new MyScoreDocComparator("sort",reader,fieldname);
        return null;
    }
}
SearchSort1()输出的结果没有排序,SearchSort2()就排序了。

2.多域搜索MultiFieldQueryParser
如果想输入关键字而不想关心是在哪个Field里的就可以用MultiFieldQueryParser了。

用它的构造函数即可后面的和一个Field一样。
MultiFieldQueryParser. parse(String[] queries, String[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)                                          ~~~~~~~~~~~~~~~~~

第三个参数比较特殊这里也是与以前lucene1.4.3不一样的地方
看一个例子就知道了

String[] fields = {"filename", "contents", "description"};
BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
                BooleanClause.Occur.MUST,//在这个Field里必须出现的
                BooleanClause.Occur.MUST_NOT};//在这个Field里不能出现
MultiFieldQueryParser.parse("query", fields, flags, analyzer);

2.多索引搜索MultiSearcher
在构造的时候传进去一个Searcher数组即可

3.过滤器Filter
看个例子：
public void FilterTest() throws IOException, ParseException{
        IndexWriter indexWriter = new IndexWriter("C:\\\\FilterTest",new StandardAnalyzer(),true);
        Document doc = new Document();
        doc.add(new Field("name","程序员之家",Field.Store.YES,Field.Index.TOKENIZED));
        indexWriter.addDocument(doc);
        doc=new Document();
        doc.add(new Field("name","程序员杂志",Field.Store.YES,Field.Index.TOKENIZED));
        indexWriter.addDocument(doc);
        indexWriter.close();
        Query query = null;
        Hits hits = null;
        IndexSearcher indexSearcher = new IndexSearcher("C:\\\\FilterTest");
        QueryParser queryParser = new QueryParser("name",new StandardAnalyzer());
        query = queryParser.parse("程序");
        hits = indexSearcher.search(query,new Filter(){
            @Override
            public BitSet bits(IndexReader reader) throws IOException
            {
                BitSet bit = new BitSet(reader.maxDoc());
                for(int i=0;i<reader.maxDoc();i++)
                {
                    //将以“杂志”后缀的过滤掉
                    if(reader.document(i).get("name").enth("杂志"))
                        continue;
                    bit.set(i);
                }
                return bit;
            }
        });
        System.out.println(hits.length());
        for(int i=0;i<hits.length();i++){
            doc =hits.doc(i);
            System.out.println(doc.get("name"));
        }
}