1.功能

实现全文检索。
生活中遇到两类数据：结构化数据（例如数据库）和非结构化数据（例如电脑磁盘下一堆文档文件）。对于结构化数据查询速度非常快，但对于非结构化数据检索起来束手无策。借鉴结构化数据检索的思想，可以将文档结构化（建立索引）从而进行全文检索。

2.流程 （索引 和 搜索）

全文检索流程图

3.具体过程

3.1 创建索引：

3.1.1.获得原始文档：磁盘读取
3.1.2.创建文档对象：原始文档 ---> Document (一个一个的域（Name,Value对）

Document长这样


倒排索引表长这样

3.2 查询索引：

3.2.1 用户查询接口界面

查询接口界面

3.2.2 创建查询

语法“fileName:lucene”

3.2.3 执行查询

查询语句中的关键词作为term,去倒排索引表中查找文档ID列表

3.2.4 渲染结果

代码开发部分

1. 配置开发环境

1.1 Lucene下载
地址： http://lucene.apache.org/
版本：lucene4.10.3
JDK:1.7+
IDE: eclipse
1.2 使用的Jar包
Lucene包：
lucene-analyzers-common-4.10.3.jar
lucene-analyzers-smartcn-4.10.3.jar
lucene-core-4.10.3.jar
lucene-queryparser-4.10.3.jar
其他：
commons-io-2.4.jar
IKAnalyzer2012FF_u1.jar
junit-4.9.jar

2. 创建索引库

使用indexwriter对象创建索引
2.1 实现步骤：
第一步：创建Java project，导包
第二步：创建一个indexwriter对象
1）指定索引库存放位置Directory对象
2）指定一个分析器，对文档内容进行分析
第三步：创建Document对象
第四步：创建field,将field添加到Document
第五步：使用indexwriter对象将Document对象写入索引库，此过程进行索引创建。并将索引和Document对象写入索引库
第六步：关闭indexwriter对象

package com.itheima.lucene;
import java.io.File;
import org.apache.commons.io.FileUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.LongField;
import org.apache.lucene.document.StoredField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;

/*
 * Lucene入门
 * 创建索引，查询索引
 * */
public class FirstLucene {
    
    @Test
    public void testIndex() throws Exception{
//      第一步：创建Java project，导包
//      第二步：创建一个indexwriter对象
        Directory directory = FSDirectory.open(new File("D:\\temp\\index"));
        Analyzer analyzer = new StandardAnalyzer();
        IndexWriterConfig config = new IndexWriterConfig(Version.LATEST,analyzer);
        IndexWriter indexWriter = new IndexWriter(directory,config);
//                    1）指定索引库存放位置Directory对象
//                    2）指定一个分析器，对文档内容进行分析

//      第四步：创建field,将field添加到Document
        File f = new File("E:\\Lucene&solr\\searchsource");
        File[] listFiles = f.listFiles();
        for(File file:listFiles){
//          第三步：创建Document对象
            Document document = new Document();
            
            //文件名称
            String file_name = file.getName();//Y,Y,X
            Field fileNameField = new TextField("fileName",file_name,Store.YES);
    
            //文件大小
            long file_size = FileUtils.sizeOf(file);
            Field fileSizeField = new LongField("fileSize",file_size,Store.YES);
            
            //文件路径
            String file_path = file.getPath(); //N,N,Y
            Field filePathField = new StoredField("filePath",file_path);
            
            //文件内容
            String file_content = FileUtils.readFileToString(file);//Y,Y,X
            Field fileContentField = new TextField("fileContent",file_content,Store.NO);
            
            document.add(fileNameField);  
            document.add(fileSizeField);
            document.add(filePathField);
            document.add(fileContentField);
//          第四步：使用indexwriter对象将Document对象写入索引库，此过程进行索引创建。并将索引和Document对象写入索引库
            indexWriter.addDocument(document);
        }

//      第六步：关闭indexwriter对象
        indexWriter.close();
    }
}

3. 查询索引

3.1 实现步骤：
第一步：创建一个Directory对象，也就是索 引库的位置
第二步：创建一个indexReader对象，需要制定Directory对象（该对象用来和索引库沟通）
第三步：创建一个indexsearcher对象，需要制定indexReader对象 （基于流的搜索）
第四步：创建一个TermQuery对象，指定查询的域和查询的关键词
第五步：执行查询
第六步：返回查询结果，遍历结果并输出
第七步：关闭IndexReader对象

@Test
    public void testSearch() throws Exception{
//      第一步：创建一个Directory对象，也就是索 引库的位置
        Directory directory = FSDirectory.open(new File("D:\\temp\\index")); //磁盘上的库
//      第二步：创建一个indexReader对象，需要制定Directory对象（该对象用来和索引库沟通）
        IndexReader indexReader = DirectoryReader.open(directory);
//      第三步：创建一个indexsearcher对象，需要制定indexReader对象 （基于流的搜索）
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
//      第四步：创建一个TermQuery对象，指定查询的域和查询的关键词
        TermQuery query = new TermQuery(new Term("fileContent","spring"));
//      第五步：执行查询
        TopDocs topDocs = indexSearcher.search(query, 2); 
//      第六步：返回查询结果，遍历结果并输出
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for(ScoreDoc scoreDoc : scoreDocs){
            int doc = scoreDoc.doc;
            Document document = indexSearcher.doc(doc);
            String fileName = document.get("fileName");
            System.out.println(fileName);
            String fileContent = document.get("fileContent");
            System.out.println(fileContent);
            String fileSize = document.get("fileSize");
            System.out.println(fileSize);
            String filePath = document.get("filePath");
            System.out.println(filePath);
            System.out.println("-------------");
        }
//      第七步：关闭IndexReader对象
        indexReader.close();
    }

4.支持中文分词

IKAnalyzer使用，可扩展
1.导包
2.在src下放入

IKAnalyzer使用需要放入的文件

查看中文分词器的使用效果

@Test
    public void testTokenStream() throws Exception {
        // 创建一个标准分析器对象
//      Analyzer analyzer = new StandardAnalyzer();
//      Analyzer analyzer = new CJKAnalyzer();
//      Analyzer analyzer = new SmartChineseAnalyzer();
        Analyzer analyzer = new IKAnalyzer();
        // 获得tokenStream对象
        // 第一个参数：域名，可以随便给一个
        // 第二个参数：要分析的文本内容
//      TokenStream tokenStream = analyzer.tokenStream("test",
//              "The Spring Framework provides a comprehensive programming and configuration model.");
        TokenStream tokenStream = analyzer.tokenStream("test",
                "高富帅可以用二维表结构来逻辑表达实现的数据");
        // 添加一个引用，可以获得每个关键词
        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();
    }

5.Lucene所以库查询（详细）

5.1使用Query子类查询

5.1.1 MatchAllDocsQuery --- 查询索引目录中的所有文档

public IndexSearcher getIndexSearch() throws Exception{
//      第一步：创建一个Directory对象，也就是索 引库的位置
        Directory directory = FSDirectory.open(new File("D:\\temp\\index")); //磁盘上的库
//      第二步：创建一个indexReader对象，需要制定Directory对象（该对象用来和索引库沟通）
        IndexReader indexReader = DirectoryReader.open(directory);
//      第三步：创建一个indexsearcher对象，需要制定indexReader对象 （基于流的搜索）
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        return indexSearcher;
    }
    public void printResult(IndexSearcher indexSearcher,MatchAllDocsQuery query) throws Exception{
        //第五步：执行查询
        TopDocs topDocs = indexSearcher.search(query, 2); 
//      第六步：返回查询结果，遍历结果并输出
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for(ScoreDoc scoreDoc : scoreDocs){
            int doc = scoreDoc.doc;
            Document document = indexSearcher.doc(doc);
            String fileName = document.get("fileName");
            System.out.println(fileName);
            String fileContent = document.get("fileContent");
            System.out.println(fileContent);
            String fileSize = document.get("fileSize");
            System.out.println(fileSize);
            String filePath = document.get("filePath");
            System.out.println(filePath);
            System.out.println("-------------");
        }
    }
    // 查询所有
    @Test
    public void testMatchAllDocsQuery() throws Exception{
        IndexSearcher indexSearcher = getIndexSearch();
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        printResult(indexSearcher,query);
        indexSearcher.getIndexReader().close();
        
    }

5.1.2 TermQuery --- 精准查询
5.1.3 NumericRangeQuery --- 根据数值范围查询

//根据数值范围查询
    @Test
    public void testNumericRangeQuery() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        
        Query query = NumericRangeQuery.newLongRange("fileSize", 47L, 200L, false, true);
        System.out.println(query);
        printResult(indexSearcher, query);
        //关闭资源
        indexSearcher.getIndexReader().close();
    }

5.1.3 BooleanQuery --- 组合查询

@Test
    public void testBooleanQuery() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        
        BooleanQuery booleanQuery = new BooleanQuery();
        
        Query query1 = new TermQuery(new Term("fileName","apache"));
        Query query2 = new TermQuery(new Term("fileName","lucene"));
        //  select * from user where id =1 or name = 'safdsa'
        booleanQuery.add(query1, Occur.MUST);
        booleanQuery.add(query2, Occur.SHOULD);
        System.out.println(booleanQuery);
        printResult(indexSearcher, booleanQuery);
        //关闭资源
        indexSearcher.getIndexReader().close();
    }

5.2使用queryparser查询

通过queryparser创建query

//条件解释的对象查询
    @Test
    public void testQueryParser() throws Exception {
        IndexSearcher indexSearcher = getIndexSearcher();
        //参数1： 默认查询的域  
        //参数2：采用的分析器
        QueryParser queryParser = new QueryParser("fileName",new IKAnalyzer());
        // *:*   域：值
        Query query = queryParser.parse("fileName:lucene is apache OR fileContent:lucene is apache");
        
        printResult(indexSearcher, query);
        //关闭资源
        indexSearcher.getIndexReader().close();
    }

总结

1.案例：磁盘的文件（文件内容）
2.为什么要用全文检索？
结构化数据 vs 非结构化数据
3.什么是全文检索？
4.全文检索的实现手段
5.Lunce是什么？
6.Lunce的使用？实现流程？
创建索引：
查询索引：
7.创建索引的代码实现
8.查询索引的代码实现
9.中文分词器
标准分析器
cjk分析器
Smart分析器
IK分析器(重点)
10.中文分词器使用时机：创建索引IK，查询索引IK
11.索引的维护：增删改
12.查询索引：
子类查询
Queryparse