全文搜索技术—Lucene

1.   内容安排

实现一个文件的搜索功能，通过关键字搜索文件，凡是文件名或文件内容包括关键字的文件都需要找出来。还可以根据中文词语进程查询，并且支持多种条件查询。

本案例中的原始内容就是磁盘上的文件，如下图：

2.   需求分析

2.1. 数据分类

我们生活中的数据总体分为两种：结构化数据和非结构化数据。

结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。

非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等磁盘上的文件

2.2. 非结构化数据查询方法

（1）顺序扫描法(Serial Scanning)

所谓顺序扫描，比如要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每一个文档，从头看到尾，如果此文档包含此字符串，则此文档为我们要找的文件，接着看下一个文件，直到扫描完所有的文件。如利用windows的搜索也可以搜索文件内容，只是相当的慢。

（2）全文检索(Full-text Search)

将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。

例如：字典。字典的拼音表和部首检字表就相当于字典的索引，对每一个字的解释是非结构化的，如果字典没有音节表和部首检字表，在茫茫辞海中找一个字只能顺序扫描。然而字的某些信息可以提取出来进行结构化处理，比如读音，就比较结构化，分声母和韵母，分别只有几种可以一一列举，于是将读音拿出来按一定的顺序排列，每一项读音都指向此字的详细解释的页数。我们搜索时按结构化的拼音搜到读音，然后按其指向的页数，便可找到我们的非结构化数据——也即对字的解释。

这种先建立索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。

2.3. 如何实现全文检索

可以使用Lucene实现全文检索。Lucene是apache下的一个开放源代码的全文检索引擎工具包。提供了完整的查询引擎和索引引擎，部分文本分析引擎。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。

2.4. 全文检索的应用场景

对于数据量大、数据结构不固定的数据可采用全文检索方式搜索，比如百度、Google等搜索引擎、论坛站内搜索、电商网站站内搜索等。

3.   Lucene实现全文检索的流程

3.1. 索引和搜索流程图

1、绿色表示索引过程，对要搜索的原始内容进行索引构建一个索引库，索引过程包括：

确定原始内容即要搜索的内容 —> 采集文档 —> 创建文档 —> 分析文档 —> 索引文档

2、红色表示搜索过程，从索引库中搜索内容，搜索过程包括：

用户通过搜索界面 —> 创建查询 —> 执行搜索，从索引库搜索 —> 渲染搜索结果

3.2. 创建索引

对文档索引的过程，将用户要搜索的文档内容进行索引，索引存储在索引库（index）中。

这里我们要搜索的文档是磁盘上的文本文件，根据案例描述：凡是文件名或文件内容包括关键字的文件都要找出来，这里要对文件名和文件内容创建索引。

3.2.1.    获得原始文档

原始文档是指要索引和搜索的内容。原始内容包括互联网上的网页、数据库中的数据、磁盘上的文件等。

本案例中的原始内容就是磁盘上的文件，如下图：

从互联网上、数据库、文件系统中等获取需要搜索的原始信息，这个过程就是信息采集，信息采集的目的是为了对原始内容进行索引。

在Internet上采集信息的软件通常称为爬虫或蜘蛛，也称为网络机器人，爬虫访问互联网上的每一个网页，将获取到的网页内容存储起来。

Lucene不提供信息采集的类库，需要自己编写一个爬虫程序实现信息采集，也可以通过一些开源软件实现信息采集，如下：

Nutch（http://lucene.apache.org/nutch）, Nutch是apache的一个子项目，包括大规模爬虫工具，能够抓取和分辨web网站数据。

jsoup（http://jsoup.org/ ），jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。

heritrix（http://sourceforge.net/projects/archive-crawler/files/），Heritrix 是一个由 java 开发的、开源的网络爬虫，用户可以使用它来从网上抓取想要的资源。其最出色之处在于它良好的可扩展性，方便用户实现自己的抓取逻辑。

本案例我们要获取磁盘上文件的内容，可以通过文件流来读取文本文件的内容，对于pdf、doc、xls等文件可通过第三方提供的解析工具读取文件内容，比如Apache POI读取doc和xls的文件内容。

3.2.2.    创建文档对象

获取原始内容的目的是为了索引，在索引前需要将原始内容创建成文档（Document），文档中包括一个一个的域（Field），域中存储内容。

这里我们可以将磁盘上的一个文件当成一个document，Document中包括一些Field（file_name文件名称、file_path文件路径、file_size文件大小、file_content文件内容），如下图：

注意：每个Document可以有多个Field，不同的Document可以有不同的Field，同一个Document可以有相同的Field（域名和域值都相同）

每个文档都有一个唯一的编号，就是文档id。

3.2.3.    分析文档

将原始内容创建为包含域（Field）的文档（document），需要再对域中的内容进行分析，分析的过程是经过对原始文档提取单词、将字母转为小写、去除标点符号、去除停用词等过程生成最终的语汇单元，可以将语汇单元理解为一个一个的单词。

比如下边的文档经过分析如下：

原文档内容：

Lucene is a Java full-text search engine.  Lucene is not a complete

application, but rather a code library and API that can easily be used

to add search capabilities to applications.

分析后得到的语汇单元：

lucene、java、full、search、engine。。。。

每个单词叫做一个Term，不同的域中拆分出来的相同的单词是不同的term。term中包含两部分一部分是文档的域名，另一部分是单词的内容。

例如：文件名中包含apache和文件内容中包含的apache是不同的term。

3.2.4.    创建索引

对所有文档分析得出的语汇单元进行索引，索引的目的是为了搜索，最终要实现只搜索被索引的语汇单元从而找到Document（文档）。

注意：创建索引是对语汇单元索引，通过词语找文档，这种索引的结构叫倒排索引结构。

传统方法是根据文件找到该文件的内容，在文件内容中匹配搜索关键字，这种方法是顺序扫描方法，数据量大、搜索慢。

倒排索引结构是根据内容（词语）找文档，如下图：

倒排索引结构也叫反向索引结构，包括索引和文档两部分，索引即词汇表，它的规模较小，而文档集合较大。

3.3. 查询索引

查询索引也是搜索的过程。搜索就是用户输入关键字，从索引（index）中进行搜索的过程。根据关键字搜索索引，根据索引找到对应的文档，从而找到要搜索的内容（这里指磁盘上的文件）。

3.3.1.    用户查询接口

全文检索系统提供用户搜索的界面供用户提交搜索的关键字，搜索完成展示搜索结果。

比如：

Lucene不提供制作用户搜索界面的功能，需要根据自己的需求开发搜索界面。

3.3.2.    创建查询

用户输入查询关键字执行搜索之前需要先构建一个查询对象，查询对象中可以指定查询要搜索的Field文档域、查询关键字等，查询对象会生成具体的查询语法，比如：

　　语法 “fileName:spring.txt”表示要搜索Field域的内容为“spring.txt”的文档

　　语法 “lucene AND java” 表示要搜索即包括关键字“lucene”也包括“java”的文档。

3.3.3.    执行查询

搜索索引过程：

1.根据查询语法在倒排索引词典表中分别找出对应搜索词的索引，从而找到索引所链接的文档链表。

比如搜索语法为“lucene AND java”表示搜索出的文档中即要包括lucene也要包括java。

2、由于是AND，所以要对包含lucene或java词语的链表进行交集，得到文档链表应该包括每一个搜索词语

3、获取文档中的Field域数据。

3.3.4.    渲染结果

以一个友好的界面将查询结果展示给用户，用户根据搜索结果找自己想要的信息，为了帮助用户很快找到自己的结果，提供了很多展示的效果，比如搜索结果中将关键字高亮显示，百度提供的快照等。

4.   配置开发环境

4.1. Lucene下载

Lucene是开发全文检索功能的工具包，从官方网站下载Lucene4.10.3，并解压。

官方网站：http://lucene.apache.org/

版本：lucene4.10.3

Jdk要求：1.7以上

IDE：Eclipse

4.2. 使用的jar包

Lucene包：

lucene-core-4.10.3.jar

lucene-analyzers-common-4.10.3.jar

lucene-queryparser-4.10.3.jar

其它：

commons-io-2.4.jar

junit-4.9.jar

5.   功能一：创建索引库

使用indexwriter对象创建索引

5.1. 实现步骤

第一步：创建一个java工程，并导入jar包。

第二步：创建一个indexwriter对象。

　　1）指定索引库的存放位置Directory对象

　　2）指定一个分析器，对文档内容进行分析。

第二步：创建document对象。

第三步：创建field对象，将field添加到document对象中。

第四步：使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写入索引库。

第五步：关闭IndexWriter对象。

5.2. Field域的属性

是否分析：是否对域的内容进行分词处理。前提是我们要对域的内容进行查询。

　　　　分词的作用是为了索引

　　 需要分词: 文件名称, 文件内容

　　 不需要分词: 不需要索引的域不需要分词,还有就是分词后无意义的域不需要分词

比如: id, 身份证号

是否索引：将Field分析后的词或整个Field值进行索引，只有索引方可搜索到。

　　比如：商品名称、商品简介分析后进行索引，订单号、身份证号不用分析但也要索引，这些将来都要作为查询条件。

　　　　索引的的目的是为了搜索.

　　 需要搜索的域就一定要创建索引,只有创建了索引才能被搜索出来

　　   不需要搜索的域可以不创建索引

　　  需要索引: 文件名称, 文件内容, id, 身份证号等

　　不需要索引: 比如图片地址不需要创建索引, e:\\xxx.jpg，因为根据图片地址搜索无意义

是否存储：将Field值存储在文档中，存储在文档中的Field才可以从Document中获取

　　　　比如：商品名称、订单号，凡是将来要从Document中获取的Field都要存储。

　　　　存储的目的是为了显示.

　　　　是否存储看个人需要,存储就是将内容放入Document文档对象中保存出来,会额外占用磁盘空间, 如果搜索的时候需要马上显示出来可以放入document中也就是要存储,这样查询显示速度快, 如果不是马上立刻需要显示出来,则不需要存储,因为额外占用磁盘空间不划算.

　　是否存储的标准：是否要将内容展示给用户

 

Field类	数据类型	Analyzed 是否分析	Indexed 是否索引	Stored 是否存储	说明
StringField(FieldName, FieldValue,Store.YES))	字符串	N	Y	Y或N	这个Field用来构建一个字符串Field，但是不会进行分析，会将整个串存储在索引中，比如(订单号,姓名等) 是否存储在文档中用Store.YES或Store.NO决定
LongField(FieldName, FieldValue,Store.YES)	Long型	Y	Y	Y或N	这个Field用来构建一个Long数字型Field，进行分析和索引，比如(价格) 是否存储在文档中用Store.YES或Store.NO决定
StoredField(FieldName, FieldValue)	重载方法，支持多种类型	N	N	Y	这个Field用来构建不同类型Field 不分析，不索引，但要Field存储在文档中(如图片,因为要存放图片地址)
TextField(FieldName, FieldValue, Store.NO) 或 TextField(FieldName, reader)	字符串 或 流	Y	Y	Y或N	如果是一个Reader, lucene猜测内容比较多,会采用Unstored的策略.

5.3. 代码实现

//创建索引
    @Test
    public void createIndex() throws Exception {

        //指定索引库存放的路径
        //D:\temp\0108\index
        Directory directory = FSDirectory.open(new File("D:\\temp\\0108\\index"));
        //索引库还可以存放到内存中
        //Directory directory = new RAMDirectory();
        //创建一个标准分析器
        Analyzer analyzer = new StandardAnalyzer();
        //创建indexwriterCofig对象
        //第一个参数： Lucene的版本信息，可以选择对应的lucene版本也可以使用LATEST
        //第二根参数：分析器对象
        IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, analyzer);
        //创建indexwriter对象
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //原始文档的路径D:\01.课程\04.lucene\01.参考资料\searchsource
        File dir = new File("D:\\01.课程\\04.lucene\\01.参考资料\\searchsource");
        for (File f : dir.listFiles()) {
            //文件名
            String fileName = f.getName();
            //文件内容
            String fileContent = FileUtils.readFileToString(f);
            //文件路径
            String filePath = f.getPath();
            //文件的大小
            long fileSize  = FileUtils.sizeOf(f);
            //创建文件名域
            //第一个参数：域的名称
            //第二个参数：域的内容
            //第三个参数：是否存储
            Field fileNameField = new TextField("filename", fileName, Store.YES);
            //文件内容域
            Field fileContentField = new TextField("content", fileContent, Store.YES);
            //文件路径域（不分析、不索引、只存储）
            Field filePathField = new StoredField("path", filePath);
            //文件大小域
            Field fileSizeField = new LongField("size", fileSize, Store.YES);

            //创建document对象
            Document document = new Document();
            document.add(fileNameField);
            document.add(fileContentField);
            document.add(filePathField);
            document.add(fileSizeField);
            //创建索引，并写入索引库
            indexWriter.addDocument(document);
        }
        //关闭indexwriter
        indexWriter.close();
    }

@Test
    public void testIndexCreate() throws Exception{
        //创建文档列表,保存多个Docuemnt
        List<Document> docList = new ArrayList<Document>();

        //指定文件所在目录
        File dir = new File("E:\\01.参考资料\\searchsource");
        //循环文件夹取出文件
        for(File file : dir.listFiles()){
            //文件名称
            String fileName = file.getName();
            //文件内容
            String fileContext = FileUtils.readFileToString(file);
            //文件大小
            Long fileSize = FileUtils.sizeOf(file);

            //文档对象,文件系统中的一个文件就是一个Docuemnt对象
            Document doc = new Document();

            //第一个参数:域名
            //第二个参数:域值
            //第三个参数:是否存储,是为yes,不存储为no
            /*TextField nameFiled = new TextField("fileName", fileName, Store.YES);
            TextField contextFiled = new TextField("fileContext", fileContext, Store.YES);
            TextField sizeFiled = new TextField("fileSize", fileSize.toString(), Store.YES);*/

            //是否分词:要,因为它要索引,并且它不是一个整体,分词有意义
            //是否索引:要,因为要通过它来进行搜索
            //是否存储:要,因为要直接在页面上显示
            TextField nameFiled = new TextField("fileName", fileName, Store.YES);

            //是否分词: 要,因为要根据内容进行搜索,并且它分词有意义
            //是否索引: 要,因为要根据它进行搜索
            //是否存储: 可以要也可以不要,不存储搜索完内容就提取不出来
            TextField contextFiled = new TextField("fileContext", fileContext, Store.NO);

            //是否分词: 要, 因为数字要对比,搜索文档的时候可以搜大小, lunene内部对数字进行了分词算法
            //是否索引: 要, 因为要根据大小进行搜索
            //是否存储: 要, 因为要显示文档大小
            LongField sizeFiled = new LongField("fileSize", fileSize, Store.YES);

            //将所有的域都存入文档中
            doc.add(nameFiled);
            doc.add(contextFiled);
            doc.add(sizeFiled);

            //将文档存入文档集合中
            docList.add(doc);
        }

        //创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
        Analyzer analyzer = new IKAnalyzer();
        //指定索引和文档存储的目录
        Directory directory = FSDirectory.open(new File("E:\\dic"));
        //创建写对象的初始化对象
        IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
        //创建索引和文档写对象
        IndexWriter indexWriter = new IndexWriter(directory, config);

        //将文档加入到索引和文档的写对象中
        for(Document doc : docList){
            indexWriter.addDocument(doc);
        }
        //提交
        indexWriter.commit();
        //关闭流
        indexWriter.close();
    }

5.4. 使用Luke工具查看索引文件

6.   功能二：查询索引

6.1. 实现步骤

第一步：创建一个Directory对象，也就是索引库存放的位置。

第二步：创建一个indexReader对象，需要指定Directory对象。

第三步：创建一个indexsearcher对象，需要指定IndexReader对象

第四步：创建一个TermQuery对象，指定查询的域和查询的关键词。

第五步：执行查询。

第六步：返回查询结果。遍历查询结果并输出。

第七步：关闭IndexReader对象

6.2. IndexSearcher搜索方法

方法	说明
indexSearcher.search(query, n)	根据Query搜索，返回评分最高的n条记录
indexSearcher.search(query, filter, n)	根据Query搜索，添加过滤策略，返回评分最高的n条记录
indexSearcher.search(query, n, sort)	根据Query搜索，添加排序策略，返回评分最高的n条记录
indexSearcher.search(booleanQuery, filter, n, sort)	根据Query搜索，添加过滤策略，添加排序策略，返回评分最高的n条记录

6.3. 代码实现

//查询索引库
    @Test
    public void searchIndex() throws Exception {
        //指定索引库存放的路径
        //D:\temp\0108\index
        Directory directory = FSDirectory.open(new File("D:\\temp\\0108\\index"));
        //创建indexReader对象
        IndexReader indexReader = DirectoryReader.open(directory);
        //创建indexsearcher对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //创建查询
        Query query = new TermQuery(new Term("filename", "apache"));
        //执行查询
        //第一个参数是查询对象，第二个参数是查询结果返回的最大值
        TopDocs topDocs = indexSearcher.search(query, 10);
        //查询结果的总条数
        System.out.println("查询结果的总条数："+ topDocs.totalHits);
        //遍历查询结果
        //topDocs.scoreDocs存储了document对象的id
        for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
            //scoreDoc.doc属性就是document对象的id
            //根据document的id找到document对象
            Document document = indexSearcher.doc(scoreDoc.doc);
            System.out.println(document.get("filename"));
            //System.out.println(document.get("content"));
            System.out.println(document.get("path"));
            System.out.println(document.get("size"));
        }
        //关闭indexreader对象
        indexReader.close();
    }

@Test
    public void testIndexSearch() throws Exception{

        //创建分词器(创建索引和所有时所用的分词器必须一致)
        Analyzer analyzer = new IKAnalyzer();
        //创建查询对象,第一个参数:默认搜索域, 第二个参数:分词器
        //默认搜索域作用:如果搜索语法中指定域名从指定域中搜索,如果搜索时只写了查询关键字,则从默认搜索域中进行搜索
        QueryParser queryParser = new QueryParser("fileContext", analyzer);
        //查询语法=域名:搜索的关键字
        Query query = queryParser.parse("fileName:web");

        //指定索引和文档的目录
        Directory dir = FSDirectory.open(new File("E:\\dic"));
        //索引和文档的读取对象
        IndexReader indexReader = IndexReader.open(dir);
        //创建索引的搜索对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
        TopDocs topdocs = indexSearcher.search(query, 5);
        //一共搜索到多少条记录
        System.out.println("=====count=====" + topdocs.totalHits);
        //从搜索结果对象中获取结果集
        ScoreDoc[] scoreDocs = topdocs.scoreDocs;

        for(ScoreDoc scoreDoc : scoreDocs){
            //获取docID
            int docID = scoreDoc.doc;
            //通过文档ID从硬盘中读取出对应的文档
            Document document = indexReader.document(docID);
            //get域名可以取出值 打印
            System.out.println("fileName:" + document.get("fileName"));
            System.out.println("fileSize:" + document.get("fileSize"));
            System.out.println("============================================================");
        }

    }

6.4. TopDocs

Lucene搜索结果可通过TopDocs遍历，TopDocs类提供了少量的属性，如下：

方法或属性	说明
totalHits	匹配搜索条件的总记录数
scoreDocs	顶部匹配记录

注意：

Search方法需要指定匹配记录数量 n：indexSearcher.search(query, n)

TopDocs.totalHits：是匹配索引库中所有记录的数量

TopDocs.scoreDocs：匹配相关度高的前边记录数组，scoreDocs的长度小于等于search方法指定的参数n

7.   功能三：支持中文分词

7.1. 分析器（Analyzer）的执行过程

如下图是语汇单元的生成过程：

从一个Reader字符流开始，创建一个基于Reader的Tokenizer分词器，经过三个TokenFilter生成语汇单元Token。

要看分析器的分析效果，只需要看Tokenstream中的内容就可以了。每个分析器都有一个方法tokenStream，返回一个tokenStream对象。

7.2. 分析器的分词效果

//查看标准分析器的分词效果
    public void testTokenStream() throws Exception {
        //创建一个标准分析器对象
        Analyzer analyzer = new StandardAnalyzer();
        //获得tokenStream对象
        //第一个参数：域名，可以随便给一个
        //第二个参数：要分析的文本内容
        TokenStream tokenStream = analyzer.tokenStream("test", "The Spring Framework provides a comprehensive programming and configuration model.");
        //添加一个引用，可以获得每个关键词
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        //添加一个偏移量的引用，记录了关键词的开始位置以及结束位置
        OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
        //将指针调整到列表的头部
        tokenStream.reset();
        //遍历关键词列表，通过incrementToken方法判断列表是否结束
        while(tokenStream.incrementToken()) {
            //关键词的起始位置
            System.out.println("start->" + offsetAttribute.startOffset());
            //取关键词
            System.out.println(charTermAttribute);
            //结束位置
            System.out.println("end->" + offsetAttribute.endOffset());
        }
        tokenStream.close();
    }

7.3. 中文分析器

7.3.1.    Lucene自带中文分词器

• StandardAnalyzer：

单字分词：就是按照中文一个字一个字地进行分词。如：“我爱中国”，
效果：“我”、“爱”、“中”、“国”。

• CJKAnalyzer

二分法分词：按两个字进行切分。如：“我是中国人”，效果：“我是”、“是中”、“中国”“国人”。

上边两个分词器无法满足需求。

• SmartChineseAnalyzer

对中文支持较好，但扩展性差，扩展词库，禁用词库和同义词库等不好处理

7.3.2.   
第三方中文分析器

• paoding： 庖丁解牛最新版在 https://code.google.com/p/paoding/ 中最多支持Lucene 3.0，且最新提交的代码在 2008-06-03，在svn中最新也是2010年提交，已经过时，不予考虑。
• mmseg4j：最新版已从 https://code.google.com/p/mmseg4j/ 移至 https://github.com/chenlb/mmseg4j-solr，支持Lucene 4.10，且在github中最新提交代码是2014年6月，从09年～14年一共有：18个版本，也就是一年几乎有3个大小版本，有较大的活跃度，用了mmseg算法。
• IK-analyzer： 最新版在https://code.google.com/p/ik-analyzer/上，支持Lucene 4.10从2006年12月推出1.0版开始， IKAnalyzer已经推出了4个大版本。最初，它是以开源项目Luence为应用主体的，结合词典分词和文法分析算法的中文分词组件。从3.0版本开 始，IK发展为面向Java的公用分词组件，独立于Lucene项目，同时提供了对Lucene的默认优化实现。在2012版本中，IK实现了简单的分词 歧义排除算法，标志着IK分词器从单纯的词典分词向模拟语义分词衍化。 但是也就是2012年12月后没有在更新。
• ansj_seg：最新版本在 https://github.com/NLPchina/ansj_seg tags仅有1.1版本，从2012年到2014年更新了大小6次，但是作者本人在2014年10月10日说明：“可能我以后没有精力来维护ansj_seg了”，现在由”nlp_china”管理。2014年11月有更新。并未说明是否支持Lucene，是一个由CRF（条件随机场）算法所做的分词算法。
• imdict-chinese-analyzer：最新版在 https://code.google.com/p/imdict-chinese-analyzer/ ，
  最新更新也在2009年5月，下载源码，不支持Lucene 4.10 。是利用HMM（隐马尔科夫链）算法。
• Jcseg：最新版本在git.oschina.net/lionsoul/jcseg，支持Lucene 4.10，作者有较高的活跃度。利用mmseg算法。

7.3.3.   
IKAnalyzer

使用方法：

第一步：把jar包添加到工程中

第二步：把配置文件和扩展词典和停用词词典添加到classpath下

注意：mydict.dic和ext_stopword.dic文件的格式为UTF-8，注意是无BOM 的UTF-8 编码。

使用EditPlus.exe保存为无BOM 的UTF-8 编码格式，如下图：

7.4. Analyzer使用时机

7.4.1.   
索引时使用Analyzer

输入关键字进行搜索，当需要让该关键字与文档域内容所包含的词进行匹配时需要对文档域内容进行分析，需要经过Analyzer分析器处理生成语汇单元（Token）。分析器分析的对象是文档中的Field域。当Field的属性tokenized（是否分词）为true时会对Field值进行分析，如下图：

对于一些Field可以不用分析：

1、不作为查询条件的内容，比如文件路径

2、不是匹配内容中的词而匹配Field的整体内容，比如订单号、身份证号等。

7.4.2.   
搜索时使用Analyzer

对搜索关键字进行分析和索引分析一样，使用Analyzer对搜索关键字进行分析、分词处理，使用分析后每个词语进行搜索。比如：搜索关键字：spring web ，经过分析器进行分词，得出：spring  web拿词去索引词典表查找 ，找到索引链接到Document，解析Document内容。

对于匹配整体Field域的查询可以在搜索时不分析，比如根据订单号、身份证号查询等。

       注意：搜索使用的分析器要和索引使用的分析器一致。

8.  
功能四：索引库的维护

8.1. 索引库的添加

8.1.1.   
步骤

向索引库中添加document对象。

第一步：先创建一个indexwriter对象

第二步：创建一个document对象

第三步：把document对象写入索引库

第四步：关闭indexwriter。

8.1.2.   
代码实现

//添加索引
    @Test
    public void addDocument() throws Exception {
        //索引库存放路径
        Directory directory = FSDirectory.open(new File("D:\\temp\\0108\\index"));

        IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, new IKAnalyzer());
        //创建一个indexwriter对象
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //创建一个Document对象
        Document document = new Document();
        //向document对象中添加域。
        //不同的document可以有不同的域，同一个document可以有相同的域。
        document.add(new TextField("filename", "新添加的文档", Store.YES));
        document.add(new TextField("content", "新添加的文档的内容", Store.NO));
        document.add(new TextField("content", "新添加的文档的内容第二个content", Store.YES));
        document.add(new TextField("content1", "新添加的文档的内容要能看到", Store.YES));
        //添加文档到索引库
        indexWriter.addDocument(document);
        //关闭indexwriter
        indexWriter.close();

    }

8.2. 索引库删除

8.2.1.    删除全部

//删除全部索引
    @Test
    public void deleteAllIndex() throws Exception {
        IndexWriter indexWriter = getIndexWriter();
        //删除全部索引
        indexWriter.deleteAll();
        //关闭indexwriter
        indexWriter.close();
    }

说明：将索引目录的索引信息全部删除，直接彻底删除，无法恢复。

此方法慎用！！

 

8.2.2.   
指定查询条件删除

//根据查询条件删除索引
    @Test
    public void deleteIndexByQuery() throws Exception {
        IndexWriter indexWriter = getIndexWriter();
        //创建一个查询条件
        Query query = new TermQuery(new Term("filename", "apache"));
        //根据查询条件删除
        indexWriter.deleteDocuments(query);
        //关闭indexwriter
        indexWriter.close();
    }

@Test
    public void testIndexDel() throws Exception{
        //创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
        Analyzer analyzer = new IKAnalyzer();
        //指定索引和文档存储的目录
        Directory directory = FSDirectory.open(new File("E:\\dic"));
        //创建写对象的初始化对象
        IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
        //创建索引和文档写对象
        IndexWriter indexWriter = new IndexWriter(directory, config);

        //删除所有
        //indexWriter.deleteAll();

        //根据名称进行删除
        //Term词元,就是一个词, 第一个参数:域名, 第二个参数:要删除含有此关键词的数据
        indexWriter.deleteDocuments(new Term("fileName", "apache"));

        //提交
        indexWriter.commit();
        //关闭
        indexWriter.close();
    }

8.3. 索引库的修改

原理就是先删除后添加。

//修改索引库
    @Test
    public void updateIndex() throws Exception {
        IndexWriter indexWriter = getIndexWriter();
        //创建一个Document对象
        Document document = new Document();
        //向document对象中添加域。
        //不同的document可以有不同的域，同一个document可以有相同的域。
        document.add(new TextField("filename", "要更新的文档", Store.YES));
        document.add(new TextField("content", "2013年11月18日 - Lucene 简介 Lucene 是一个基于 Java 的全文信息检索工具包,它不是一个完整的搜索应用程序,而是为你的应用程序提供索引和搜索功能。", Store.YES));
        indexWriter.updateDocument(new Term("content", "java"), document);
        //关闭indexWriter
        indexWriter.close();
    }

/**
     * 更新就是按照传入的Term进行搜索,如果找到结果那么删除,将更新的内容重新生成一个Document对象
     * 如果没有搜索到结果,那么将更新的内容直接添加一个新的Document对象
     * @throws Exception
     */
    @Test
    public void testIndexUpdate() throws Exception{
        //创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
        Analyzer analyzer = new IKAnalyzer();
        //指定索引和文档存储的目录
        Directory directory = FSDirectory.open(new File("E:\\dic"));
        //创建写对象的初始化对象
        IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
        //创建索引和文档写对象
        IndexWriter indexWriter = new IndexWriter(directory, config);

        //根据文件名称进行更新
        Term term = new Term("fileName", "web");
        //更新的对象
        Document doc = new Document();
        doc.add(new TextField("fileName", "xxxxxx", Store.YES));
        doc.add(new TextField("fileContext", "think in java xxxxxxx", Store.NO));
        doc.add(new LongField("fileSize", 100L, Store.YES));

        //更新
        indexWriter.updateDocument(term, doc);

        //提交
        indexWriter.commit();
        //关闭
        indexWriter.close();
    }

9.  
功能五：索引库的查询（重点）

对要搜索的信息创建Query查询对象，Lucene会根据Query查询对象生成最终的查询语法，类似关系数据库Sql语法一样Lucene也有自己的查询语法，比如：“name:lucene”表示查询Field的name为“lucene”的文档信息。

可通过两种方法创建查询对象：

1）使用Lucene提供Query子类

Query是一个抽象类，lucene提供了很多查询对象，比如TermQuery项精确查询，NumericRangeQuery数字范围查询等。

如下代码：

 Query query = new TermQuery(new Term("name", "lucene"));

   2）使用QueryParse解析查询表达式

QueryParse会将用户输入的查询表达式解析成Query对象实例。

如下代码：

QueryParser queryParser = new QueryParser("name", new IKAnalyzer());

       Query query = queryParser.parse("name:lucene");

9.1. 使用query的子类查询

9.1.1.    TermQuery

TermQuery，通过项查询，TermQuery不使用分析器所以建议匹配不分词的Field域查询，比如订单号、分类ID号等。

指定要查询的域和要查询的关键词。

@Test
    public void testIndexTermQuery() throws Exception{

        //创建词元:就是词,
        Term term = new Term("fileName", "apache");
        //使用TermQuery查询,根据term对象进行查询
        TermQuery termQuery = new TermQuery(term);

        //指定索引和文档的目录
        Directory dir = FSDirectory.open(new File("E:\\dic"));
        //索引和文档的读取对象
        IndexReader indexReader = IndexReader.open(dir);
        //创建索引的搜索对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
        TopDocs topdocs = indexSearcher.search(termQuery, 5);
        //一共搜索到多少条记录
        System.out.println("=====count=====" + topdocs.totalHits);
        //从搜索结果对象中获取结果集
        ScoreDoc[] scoreDocs = topdocs.scoreDocs;

        for(ScoreDoc scoreDoc : scoreDocs){
            //获取docID
            int docID = scoreDoc.doc;
            //通过文档ID从硬盘中读取出对应的文档
            Document document = indexReader.document(docID);
            //get域名可以取出值 打印
            System.out.println("fileName:" + document.get("fileName"));
            System.out.println("fileSize:" + document.get("fileSize"));
            System.out.println("============================================================");
        }
    }

//使用Termquery查询

     @Test

     public void testTermQuery() throws Exception {

         IndexSearcher indexSearcher = getIndexSearcher();

         //创建查询对象

         Query query = new TermQuery(new Term("content", "lucene"));

         //执行查询

         TopDocs topDocs = indexSearcher.search(query, 10);

         //共查询到的document个数

         System.out.println("查询结果总数量：" + topDocs.totalHits);

         //遍历查询结果

         for (ScoreDoc scoreDoc : topDocs.scoreDocs) {

              Document document = indexSearcher.doc(scoreDoc.doc);

              System.out.println(document.get("filename"));

              //System.out.println(document.get("content"));

              System.out.println(document.get("path"));

              System.out.println(document.get("size"));

         }

         //关闭indexreader

         indexSearcher.getIndexReader().close();

     }

9.1.2.    NumericRangeQuery

可以根据数值范围查询。

@Test
    public void testNumericRangeQuery() throws Exception{

        //根据数字范围查询
        //查询文件大小,大于100 小于1000的文章
        //第一个参数:域名      第二个参数:最小值,  第三个参数:最大值, 第四个参数:是否包含最小值,   第五个参数:是否包含最大值
        Query query = NumericRangeQuery.newLongRange("fileSize", 100L, 1000L, true, true);        

        //指定索引和文档的目录
        Directory dir = FSDirectory.open(new File("E:\\dic"));
        //索引和文档的读取对象
        IndexReader indexReader = IndexReader.open(dir);
        //创建索引的搜索对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
        TopDocs topdocs = indexSearcher.search(query, 5);
        //一共搜索到多少条记录
        System.out.println("=====count=====" + topdocs.totalHits);
        //从搜索结果对象中获取结果集
        ScoreDoc[] scoreDocs = topdocs.scoreDocs;

        for(ScoreDoc scoreDoc : scoreDocs){
            //获取docID
            int docID = scoreDoc.doc;
            //通过文档ID从硬盘中读取出对应的文档
            Document document = indexReader.document(docID);
            //get域名可以取出值 打印
            System.out.println("fileName:" + document.get("fileName"));
            System.out.println("fileSize:" + document.get("fileSize"));
            System.out.println("============================================================");
        }
    }

//数值范围查询

@Test

public void testNumericRangeQuery() throws Exception {

IndexSearcher indexSearcher = getIndexSearcher();

//创建查询

//参数：

//1.域名

//2.最小值

//3.最大值

//4.是否包含最小值

//5.是否包含最大值

Query query = NumericRangeQuery.newLongRange("size", 1l, 1000l, true, true);

//执行查询

printResult(query, indexSearcher);

}

9.1.3.    BooleanQuery

可以组合查询条件。

@Test
    public void testBooleanQuery() throws Exception{

        //布尔查询,就是可以根据多个条件组合进行查询
        //文件名称包含apache的,并且文件大小大于等于100 小于等于1000字节的文章
        BooleanQuery query = new BooleanQuery();

        //根据数字范围查询
        //查询文件大小,大于100 小于1000的文章
        //第一个参数:域名      第二个参数:最小值,  第三个参数:最大值, 第四个参数:是否包含最小值,   第五个参数:是否包含最大值
        Query numericQuery = NumericRangeQuery.newLongRange("fileSize", 100L, 1000L, true, true);

        //创建词元:就是词,
        Term term = new Term("fileName", "apache");
        //使用TermQuery查询,根据term对象进行查询
        TermQuery termQuery = new TermQuery(term);

        //Occur是逻辑条件
        //must相当于and关键字,是并且的意思
        //should,相当于or关键字或者的意思
        //must_not相当于not关键字, 非的意思
        //注意:单独使用must_not  或者 独自使用must_not没有任何意义
        query.add(termQuery, Occur.MUST);
        query.add(numericQuery, Occur.MUST);

        //指定索引和文档的目录
        Directory dir = FSDirectory.open(new File("E:\\dic"));
        //索引和文档的读取对象
        IndexReader indexReader = IndexReader.open(dir);
        //创建索引的搜索对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
        TopDocs topdocs = indexSearcher.search(query, 5);
        //一共搜索到多少条记录
        System.out.println("=====count=====" + topdocs.totalHits);
        //从搜索结果对象中获取结果集
        ScoreDoc[] scoreDocs = topdocs.scoreDocs;

        for(ScoreDoc scoreDoc : scoreDocs){
            //获取docID
            int docID = scoreDoc.doc;
            //通过文档ID从硬盘中读取出对应的文档
            Document document = indexReader.document(docID);
            //get域名可以取出值 打印
            System.out.println("fileName:" + document.get("fileName"));
            System.out.println("fileSize:" + document.get("fileSize"));
            System.out.println("============================================================");
        }
    }

//组合条件查询

@Test

public void testBooleanQuery() throws Exception {

IndexSearcher indexSearcher = getIndexSearcher();

//创建一个布尔查询对象

BooleanQuery query = new BooleanQuery();

//创建第一个查询条件

Query query1 = new TermQuery(new Term("filename", "apache"));

Query query2 = new TermQuery(new Term("content", "apache"));

//组合查询条件

query.add(query1, Occur.MUST);

query.add(query2, Occur.MUST);

//执行查询

printResult(query, indexSearcher);

}

Occur.MUST：必须满足此条件，相当于and

Occur.SHOULD：应该满足，但是不满足也可以，相当于or

Occur.MUST_NOT：必须不满足。相当于not

9.1.4.    MatchAllDocsQuery

使用MatchAllDocsQuery查询索引目录中的所有文档

@Test
    public void testMathAllQuery() throws Exception{

        //查询所有文档
        MatchAllDocsQuery query = new MatchAllDocsQuery();

        //指定索引和文档的目录
        Directory dir = FSDirectory.open(new File("E:\\dic"));
        //索引和文档的读取对象
        IndexReader indexReader = IndexReader.open(dir);
        //创建索引的搜索对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
        TopDocs topdocs = indexSearcher.search(query, 5);
        //一共搜索到多少条记录
        System.out.println("=====count=====" + topdocs.totalHits);
        //从搜索结果对象中获取结果集
        ScoreDoc[] scoreDocs = topdocs.scoreDocs;

        for(ScoreDoc scoreDoc : scoreDocs){
            //获取docID
            int docID = scoreDoc.doc;
            //通过文档ID从硬盘中读取出对应的文档
            Document document = indexReader.document(docID);
            //get域名可以取出值 打印
            System.out.println("fileName:" + document.get("fileName"));
            System.out.println("fileSize:" + document.get("fileSize"));
            System.out.println("============================================================");
        }
    }

@Test

public void testMatchAllDocsQuery() throws Exception {

IndexSearcher indexSearcher = getIndexSearcher();

//创建查询条件

Query query = new MatchAllDocsQuery();

//执行查询

printResult(query, indexSearcher);

}

9.2. 使用queryparser查询

通过QueryParser也可以创建Query，QueryParser提供一个Parse方法，此方法可以直接根据查询语法来查询。Query对象执行的查询语法可通过System.out.println(query);查询。

需要使用到分析器。建议创建索引时使用的分析器和查询索引时使用的分析器要一致。

9.2.1.    QueryParser

需要加入queryParser依赖的jar包。

9.2.1.1    程序实现

@Test
    public void testQueryParser() throws Exception{

        //创建分词器(创建索引和所有时所用的分词器必须一致)
        Analyzer analyzer = new IKAnalyzer();
        //创建查询对象,第一个参数:默认搜索域, 第二个参数:分词器
        //默认搜索域作用:如果搜索语法中指定域名从指定域中搜索,如果搜索时只写了查询关键字,则从默认搜索域中进行搜索
        QueryParser queryParser = new QueryParser("fileContext", analyzer);
        //查询语法=域名:搜索的关键字
        Query query = queryParser.parse("fileName:web");

        //指定索引和文档的目录
        Directory dir = FSDirectory.open(new File("E:\\dic"));
        //索引和文档的读取对象
        IndexReader indexReader = IndexReader.open(dir);
        //创建索引的搜索对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
        TopDocs topdocs = indexSearcher.search(query, 5);
        //一共搜索到多少条记录
        System.out.println("=====count=====" + topdocs.totalHits);
        //从搜索结果对象中获取结果集
        ScoreDoc[] scoreDocs = topdocs.scoreDocs;

        for(ScoreDoc scoreDoc : scoreDocs){
            //获取docID
            int docID = scoreDoc.doc;
            //通过文档ID从硬盘中读取出对应的文档
            Document document = indexReader.document(docID);
            //get域名可以取出值 打印
            System.out.println("fileName:" + document.get("fileName"));
            System.out.println("fileSize:" + document.get("fileSize"));
            System.out.println("============================================================");
        }

    }

@Test

public void testQueryParser() throws Exception {

IndexSearcher indexSearcher = getIndexSearcher();

//创建queryparser对象

//第一个参数默认搜索的域

//第二个参数就是分析器对象

QueryParser queryParser = new QueryParser("content", new IKAnalyzer());

Query query = queryParser.parse("Lucene是java开发的");

//执行查询

printResult(query, indexSearcher);

}

9.2.1.2    查询语法

1、基础的查询语法，关键词查询：

　　域名+“：”+搜索的关键字

　　例如：content:java

2、范围查询

　　域名+“:”+[最小值 TO 最大值]

　　例如：size:[1 TO 1000]

　　范围查询在lucene中不支持数值类型，支持字符串类型。在solr中支持数值类型。

3、组合条件查询

　　1）+条件1 +条件2：两个条件之间是并且的关系and

　　　　例如：+filename:apache +content:apache

　　2）+条件1 条件2：必须满足第一个条件，应该满足第二个条件

　　　　例如：+filename:apache content:apache

　　3）条件1 条件2：两个条件满足其一即可。

　　　　例如：filename:apache content:apache

　　4）-条件1 条件2：必须不满足条件1，要满足条件2

　　　　例如：-filename:apache content:apache

Occur.MUST 查询条件必须满足，相当于and	+（加号）
Occur.SHOULD 查询条件可选，相当于or	空（不用符号）
Occur.MUST_NOT 查询条件不能满足，相当于not非	-（减号）

　　第二种写法：

　　　　条件1 AND 条件2

　　　　条件1 OR 条件2

　　　　条件1 NOT 条件2

9.2.2.    MulitFieldQueryParser

可以指定多个默认搜索域

@Test
    public void testMultiFieldQueryParser() throws Exception{
        //创建分词器(创建索引和所有时所用的分词器必须一致)
        Analyzer analyzer = new IKAnalyzer();

        String [] fields = {"fileName","fileContext"};
        //从文件名称和文件内容中查询,只有含有apache的就查出来
        MultiFieldQueryParser multiQuery = new MultiFieldQueryParser(fields, analyzer);
        //输入需要搜索的关键字
        Query query = multiQuery.parse("apache");

        //指定索引和文档的目录
        Directory dir = FSDirectory.open(new File("E:\\dic"));
        //索引和文档的读取对象
        IndexReader indexReader = IndexReader.open(dir);
        //创建索引的搜索对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
        TopDocs topdocs = indexSearcher.search(query, 5);
        //一共搜索到多少条记录
        System.out.println("=====count=====" + topdocs.totalHits);
        //从搜索结果对象中获取结果集
        ScoreDoc[] scoreDocs = topdocs.scoreDocs;

        for(ScoreDoc scoreDoc : scoreDocs){
            //获取docID
            int docID = scoreDoc.doc;
            //通过文档ID从硬盘中读取出对应的文档
            Document document = indexReader.document(docID);
            //get域名可以取出值 打印
            System.out.println("fileName:" + document.get("fileName"));
            System.out.println("fileSize:" + document.get("fileSize"));
            System.out.println("============================================================");
        }
    }

@Test

public void testMultiFiledQueryParser() throws Exception {

IndexSearcher indexSearcher = getIndexSearcher();

//可以指定默认搜索的域是多个

String[] fields = {"filename", "content"};

//创建一个MulitFiledQueryParser对象

MultiFieldQueryParser queryParser = new MultiFieldQueryParser(fields, new IKAnalyzer());

Query query = queryParser.parse("java and apache");

System.out.println(query);

//执行查询

printResult(query, indexSearcher);

}

10.  总结

全文检索算法(倒排索引算法):

将文件中的内容提取出来, 将文字拆封成一个一个的词(分词), 将这些词组成索引(字典中的目录), 搜索的时候先搜索索引,通过索引找文档,这个过程就叫做全文检索.

分词: 去掉停用词(a, an, the ,的, 地, 得, 啊, 嗯 ,呵呵),因为搜索的时候搜索这些词没有意义,将句子拆分成词,去掉标点符号和空格

优点: 搜索速度快

缺点: 因为创建的索引需要占用磁盘空间,所以这个算法会使用掉更多的磁盘空间,这是用空间换时间

原理:

相当于字典,分为目录和正文两部分,查询的时候通过先查目录,然后通过目录上标注的页数去正文页查找需要的内容

Lucene概念

什么是lucene

Lucene是apache旗下的顶级项目,是一个全文检索工具包

Lucene就是一个可以创建全文检索引擎系统的一堆jar包.可以使用它来构建全文检索引擎系统,但是它不能独立运

全文检索引擎系统

放在tomcat下可以独立运行,对外提供全文检索服务.

Lucene应用领域

1. 互联网全文检索引擎(比如百度,  谷歌,  必应)
2. 站内全文检索引擎(淘宝, 京东搜索功能)
3. 优化数据库查询(因为数据库中使用like关键字是全表扫描也就是顺序扫描算法,查询慢)

Lucene下载

官方网站：http://lucene.apache.org/

版本：lucene4.10.3

Jdk要求：1.7以上

IDE：Eclipse

Lucene结构

索引:

域名:词  这样的形式,

它里面有指针执行这个词来源的文档

索引库: 放索引的文件夹(这个文件夹可以自己随意创建,在里面放索引就是索引库)

Term词元: 就是一个词, 是lucene中词的最小单位

文档:

Document对象,一个Document中可以有多个Field域对象,Field域对象中是key   value键值对的形式:有域名和域值,

一个document就是数据库表中的一条记录, 一个Filed域对象就是数据库表中的一行一列

这是一个通用的存储结构.

创建索引和所有时所用的分词器必须一致

域的详细介绍

是否分词:

分词的作用是为了索引

需要分词: 文件名称, 文件内容

不需要分词: 不需要索引的域不需要分词,还有就是分词后无意义的域不需要分词

比如: id, 身份证号

是否索引:

索引的的目的是为了搜索.

需要搜索的域就一定要创建索引,只有创建了索引才能被搜索出来

不需要搜索的域可以不创建索引

需要索引: 文件名称, 文件内容, id, 身份证号等

不需要索引: 比如图片地址不需要创建索引, e:\\xxx.jpg

因为根据图片地址搜索无意义

是否存储:

存储的目的是为了显示.

是否存储看个人需要,存储就是将内容放入Document文档对象中保存出来,会额外占用磁盘空间, 如果搜索的时候需要马上显示出来可以放入document中也就是要存储,这样查询显示速度快, 如果不是马上立刻需要显示出来,则不需要存储,因为额外占用磁盘空间不划算.

域的各种类型

 

Field类	数据类型	Analyzed 是否分析	Indexed 是否索引	Stored 是否存储	说明
StringField(FieldName, FieldValue,Store.YES))	字符串	N	Y	Y或N	这个Field用来构建一个字符串Field，但是不会进行分析，会将整个串存储在索引中，比如(订单号,姓名等) 是否存储在文档中用Store.YES或Store.NO决定
LongField(FieldName, FieldValue,Store.YES)	Long型	Y	Y	Y或N	这个Field用来构建一个Long数字型Field，进行分析和索引，比如(价格) 是否存储在文档中用Store.YES或Store.NO决定
StoredField(FieldName, FieldValue)	重载方法，支持多种类型	N	N	Y	这个Field用来构建不同类型Field 不分析，不索引，但要Field存储在文档中
TextField(FieldName, FieldValue, Store.NO) 或 TextField(FieldName, reader)	字符串 或 流	Y	Y	Y或N	如果是一个Reader, lucene猜测内容比较多,会采用Unstored的策略.

注意:lucene底层的算法,钱数是要分词的,因为要根据价钱进行对比

例如: 大于12.5元的小于100元的商品搜索出来

文档的更新

更新就是按照传入的Term进行搜索,如果找到结果那么删除,将更新的内容重新生成一个Document对象

如果没有搜索到结果,那么将更新的内容直接添加一个新的Document对象

文档的删除

可以根据某个域的内容进行删除

还可以一次删除所有

搜索

TermQuery:

根据词进行搜索(只能从文本中进行搜索)

QueryParser:

根据域名进行搜索,可以设置默认搜索域,推荐使用. (只能从文本中进行搜索)

NumericRangeQuery:

从数值范围进行搜索

BooleanQuery:

组合查询,可以设置组合条件,not and or.从多个域中进行查询

must相当于and关键字,是并且的意思

should,相当于or关键字或者的意思

must_not相当于not关键字, 非的意思

注意:单独使用must_not  或者 独自使用must_not没有任何意义

MatchAllDocsQuery:

查询出所有文档

MultiFieldQueryParser:

可以从多个域中进行查询,只有这些域中有关键词的存在就查询出来.