Lucene（全文检索）配置流程

（2）什么是全文检索
（3）Lucene配置流程（重点）
（4）什么是分词（难点）
（5）Lucene域的属性
（6）索引库维护
（7）Lucene复杂搜索（重点）
（8）中文分词器

全文检索就是先分词创建索引，再执行搜索的过程。
分词：就是将一段文字分成一个个单词

全文检索就将一段文字分成一个个单词去查询数据！！！

思考：电商网站内，我们都是通过输入关键词来搜索商品的。如果我们根据关键词，直接查询数据库，会有什么后果？
答：我们只能使用模糊搜索，来进行匹配，会导致很多数据匹配不到。所以，我们必须使用全文检索。

使用Lucene实现电商项目中图书类商品的索引和搜索功能。
3.2	配置步骤说明
（1）搭建环境（先下载Lucene）
（2）创建索引库
（3）搜索索引库

Lucene是开发全文检索功能的工具包，使用时从官方网站下载，并解压。
官方网站：Welcome to Apache Lucene 
下载地址：Index of /dist/lucene/java
下载版本：4.10.3（要求：jdk1.7及以上）

mysql5.1驱动包：mysql-connector-java-5.1.7-bin.jar
核心包：lucene-core-4.10.3.jar
分析器通用包：lucene-analyzers-common-4.10.3.jar
查询解析器包：lucene-queryparser-4.10.3.jar

（1）采集数据
（2）将数据转换成Lucene文档
（3）将文档写入索引库，创建索引

public class Book {
	private Integer bookId;  // 图书ID
	private String name;   // 图书名称
	private Float price;    // 图书价格
	private String pic;    // 图书图片
	private String description; // 图书描述
    // 补全get\set方法
}

package cn.gzsxt.lucene.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import cn.gzsxt.lucene.pojo.Book;

public class BookDao {
	public List<Book> getAll() {
		// 数据库链接
		Connection connection = null;
		// 预编译statement
		PreparedStatement preparedStatement = null;
		// 结果集
		ResultSet resultSet = null;
		// 图书列表
		List<Book> list = new ArrayList<Book>();
		try {
			// 加载数据库驱动
			Class.forName("com.mysql.jdbc.Driver");
			// 连接数据库
			connection = DriverManager.getConnection(
					"jdbc:mysql://localhost:3306/lucene", "root", "gzsxt");

			// SQL语句
			String sql = "SELECT * FROM book";
			// 创建preparedStatement
			preparedStatement = connection.prepareStatement(sql);

			// 获取结果集
			resultSet = preparedStatement.executeQuery();

			// 结果集解析
			while (resultSet.next()) {
				Book book = new Book();
				book.setBookId(resultSet.getInt("id"));
				book.setName(resultSet.getString("name"));
				book.setPrice(resultSet.getFloat("price"));
				book.setPic(resultSet.getString("pic"));
				book.setDescription(resultSet.getString("description"));
				list.add(book);
			}
		} catch (Exception e) {
			e.printStackTrace();
			
		}finally {
			
			if(null!=resultSet){
				try {
					resultSet.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(null!=preparedStatement){
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(null!=connection){
				try {
					connection.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		return list;
	}
}

package cn.gzsxt.lucene.test;

import java.util.List;

import org.junit.Test;
import cn.gzsxt.lucene.dao.BookDao;
import cn.gzsxt.lucene.pojo.Book;

public class BookDaoTest {

	@Test
	public void getAll(){
		BookDao dao = new BookDao();
		List<Book> books = dao.getAll();
		
		for (Book book : books) {
			System.out.println("图书id:"+book.getBookId()+",图书名称:"+book.getName());
		}
	}
}

public List<Document> getDocuments(List<Book> books){
		// Document对象集合
		List<Document> docList = new ArrayList<Document>();
		// Document对象
		Document doc = null;
		for (Book book : books) {
			// 创建Document对象，同时要创建field对象
			doc = new Document();
			// 根据需求创建不同的Field
			Field id = new TextField("id", book.getBookId().toString(),	Store.YES);
			Field name = new TextField("name", book.getName(), Store.YES);
			Field price = new TextField("price", book.getPrice().toString(),Store.YES);
			Field pic = new TextField("pic", book.getPic(), Store.YES);
			Field desc = new TextField("description",	book.getDescription(), Store.YES);
			// 把域（Field）添加到文档（Document）中
			doc.add(id);
			doc.add(name);
			doc.add(price);
			doc.add(pic);
			doc.add(desc);

			docList.add(doc);
	}
	return docList;
}

@Test
	public void createIndex(){
		try {
			BookDao dao = new BookDao();
			
			// 分析文档，对文档中的field域进行分词
			Analyzer analyzer = new StandardAnalyzer();
			// 创建索引
			// 1) 创建索引库目录
			Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));
			// 2) 创建IndexWriterConfig对象
			IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST, analyzer);
			// 3) 创建IndexWriter对象
			IndexWriter writer = new IndexWriter(directory, cfg);
			// 4) 通过IndexWriter对象添加文档对象（document）
			writer.addDocuments(dao.getDocuments(dao.getAll()));
			
			// 5) 关闭IndexWriter
			writer.close();
			System.out.println("创建索引库成功");
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

@Test
	public void searchDocumentByIndex(){
		try {
			// 1、 创建查询（Query对象）
			// 创建分析器
			Analyzer analyzer = new StandardAnalyzer();
			QueryParser queryParser = new QueryParser("name", analyzer);
			Query query = queryParser.parse("name:java教程");
			// 2、 执行搜索
			// a) 指定索引库目录
			Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));
			// b) 创建IndexReader对象
			IndexReader reader = DirectoryReader.open(directory);
			// c) 创建IndexSearcher对象
			IndexSearcher searcher = new IndexSearcher(reader);
			// d) 通过IndexSearcher对象执行查询索引库，返回TopDocs对象
			// 第一个参数：查询对象
			// 第二个参数：最大的n条记录
			TopDocs topDocs = searcher.search(query, 10);
			// e) 提取TopDocs对象中前n条记录
			ScoreDoc[] scoreDocs = topDocs.scoreDocs;
			System.out.println("查询出文档个数为：" + topDocs.totalHits);
			for (ScoreDoc scoreDoc : scoreDocs) {
				// 文档对象ID
				int docId = scoreDoc.doc;
				Document doc = searcher.doc(docId);
				// f) 输出文档内容
				System.out.println("===============================");
				System.out.println("文档id:" + docId);
				System.out.println("图书id:" + doc.get("id"));
				System.out.println("图书name:" + doc.get("name"));
				System.out.println("图书price:" + doc.get("price"));
				System.out.println("图书pic:" + doc.get("pic"));
				System.out.println("图书description:" + doc.get("description"));
			}
			// g) 关闭IndexReader
			reader.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

分词是全文检索的核心。
所谓的分词，就是将一段文本，根据一定的规则，拆分成一个一个词。
Lucene是根据分析器实现分词的。针对不同的语言提供了不同的分析器。并且提供了一个通用的标准分析器StandardAnalyzer

@Override
  protected TokenStreamComponents createComponents(final String fieldName, final Reader reader) {
    final StandardTokenizer src = new StandardTokenizer(getVersion(), reader);
    src.setMaxTokenLength(maxTokenLength);
    TokenStream tok = new StandardFilter(getVersion(), src);
    tok = new LowerCaseFilter(getVersion(), tok);
    tok = new StopFilter(getVersion(), tok, stopwords);
    return new TokenStreamComponents(src, tok) {
      @Override
      protected void setReader(final Reader reader) throws IOException {
        src.setMaxTokenLength(StandardAnalyzer.this.maxTokenLength);
        super.setReader(reader);
      }
    };
  }

（1）分词的时候，是以域为单位的。不同的域，相互独立。
       同一个域中，拆分出来相同的词，视为同一个词（Term）
       不同的域中，拆分出来相同的词，不是同一个词。

       其中，Term是Lucene最小的语汇单元，不可再细分。

（2）分词的时候经历了一系列的过滤器。如大小写转换、去除停用词等。

（1）索引库中有两个区域：索引区、文档区。
（2）文档区存放的是文档。Lucene给每一个文档自动加上一个文档编号docID。
（3）索引区存放的是索引。注意：
索引是以域为单位的，不同的域，彼此相互独立。
索引是根据分词规则创建出来的，根据索引就能找到对应的文档。

问题：我们已经知道，Lucene是在写入文档时，完成分词、索引的。那Lucene是怎么知道的呢？
答：Lucene是根据文档中的域的属性，来确定是否要分词、创建索引的。所以，我们必须搞清楚域有哪些属性。

只有设置了分词属性为true，lucene才会对这个域进行分词处理。

在实际的开发中，有一些字段是不需要分词的，比如商品id，商品图片等。
而有一些字段是必须分词的，比如商品名称，描述信息等。

只有设置了索引属性为true，lucene才为这个域的Term词创建索引。
在实际的开发中，有一些字段是不需要创建索引的，比如商品的图片等。我们只需要对参与搜索的字段做索引处理。

只有设置了存储属性为true，在查找的时候，才能从文档中获取这个域的值。
在实际开发中，有一些字段是不需要存储的。比如：商品的描述信息。
因为商品描述信息，通常都是大文本数据，读的时候会造成巨大的IO开销。而描述信息是不需要经常查询的字段，这样的话就白白浪费了cpu的资源了。
因此，像这种不需要经常查询，又是大文本的字段，通常不会存储到索引库。

（1）三大属性彼此独立。
（2）通常分词是为了创建索引。
（3）不存储这个域文本内容，也可以对这个域先分词、创建索引。

Field类	                                       数据类型    Analyzed是否分词 Indexed是否索引	 Stored是否存储
StringField(FieldName, FieldValue,Store.YES))	字符串	    N	              Y	                 Y或N
LongField(FieldName, FieldValue,Store.YES)	Long型	    Y	              Y	                  Y或N
FloatField(FieldName, FieldValue,Store.YES)	Float型	    Y	               Y	          Y或N
StoredField(FieldName, FieldValue) 	重载方法，支持多种类型  N	               N	           Y
TextField(FieldName, FieldValue, Store.NO)	字符串	    Y	               Y	         Y或N

是否分词：要分词，因为要将图书的名称内容分词索引，根据关键搜索图书名称抽取的词。
是否索引：要索引。
是否存储：要存储。

是否分词：要分词，lucene对数字型的值只要有搜索需求的都要分词和索引，因为lucene对数字型的内容要特殊分词处理，本例子可能要根据价格范围搜索，  需要分词和索引。
是否索引：要索引
是否存储：要存储

是否分词：不分词
是否索引：不索引
是否存储：要存储

是否分词：要分词
是否索引：要索引
是否存储：因为图书描述内容量大，不在查询结果页面直接显示，不存储。

不存储是来不在lucene的索引文件中记录，节省lucene的索引文件空间，如果要在详情页面显示描述，思路：
从lucene中取出图书的id，根据图书的id查询关系数据库中book表得到描述信息。

public List<Document> getDocuments(List<Book> books){
		// Document对象集合
		List<Document> docList = new ArrayList<Document>();
		// Document对象
		Document doc = null;
		for (Book book : books) {
			// 创建Document对象，同时要创建field对象
			doc = new Document();
		
			// 图书ID
			// 参数：域名、域中存储的内容、是否存储
			// 不分词、索引、要存储
			// Field id = new TextField("id", book.getId().toString(),Store.YES);
			Field id = new StoredField("id", book.getBookId().toString());
			// 图书名称
			// 分词、索引、存储
			Field name = new TextField("name", book.getName(),Store.YES);
			// 图书价格
			// 分词、索引、存储
			Field price = new FloatField("price", book.getPrice(), Store.YES);
			// 图书图片
			// 不分词、不索引、要存储
			Field pic = new StoredField("pic", book.getPic());
			// 图书描述
			// 分词、索引、不存储
			Field desc = new TextField("description",book.getDescription(), Store.NO);


			// 把域（Field）添加到文档（Document）中
			doc.add(id);
			doc.add(name);
			doc.add(price);
			doc.add(pic);
			doc.add(desc);

			docList.add(doc);
		}

		return docList;
	}

（1）去索引库目录中，手动清空索引库。
（2）重新创建索引库。
（3）使用Luke验证分词、索引效果。

在第4节，我们需要重新创建索引的时候，是去索引库目录下，手动删除的。
而在实际的开发中，我们可能压根就不知道索引库在哪，就算知道，我们也不可能每次都去手动删除，非常之麻烦！！！
所以，我们必须学习如何维护索引库，使用程序来操作索引库。
需要注意的是，索引是与文档紧密相连的，因此对索引的维护，实际上就是对文档的增删改。

	@Test
	public void deleteIndex() throws Exception {
		// 1、指定索引库目录
		Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));
		// 2、创建IndexWriterConfig
		IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST,
				new StandardAnalyzer());
		// 3、 创建IndexWriter
		IndexWriter writer = new IndexWriter(directory, cfg);
		// 4、通过IndexWriter来删除索引
		// 删除指定索引
		writer.deleteDocuments(new Term("name", "apache"));
		// 5、关闭IndexWriter
		writer.close();
		
		System.out.println("删除成功");
		
	}

@Test
	public void deleteIndex() throws Exception {
		// 1、指定索引库目录
		Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));
		// 2、创建IndexWriterConfig
		IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST,
				new StandardAnalyzer());
		// 3、 创建IndexWriter
		IndexWriter writer = new IndexWriter(directory, cfg);
		// 4、通过IndexWriter来删除索引
		// 删除指定索引
		writer.deleteAll();
		// 5、关闭IndexWriter
		writer.close();
		
		System.out.println("清空索引库成功");
		
	}

// 修改索引
	@Test
	public void updateIndex() throws Exception {
		// 1、指定索引库目录
		Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));
		// 2、创建IndexWriterConfig
		IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST,
				new StandardAnalyzer());
		// 3、 创建IndexWriter
		IndexWriter writer = new IndexWriter(directory, cfg);
		// 4、通过IndexWriter来修改索引
		// a)、创建修改后的文档对象
		Document document = new Document();

		// 文件名称
		Field filenameField = new StringField("name", "updateIndex", Store.YES);
		document.add(filenameField);

		// 修改指定索引为新的索引
		writer.updateDocument(new Term("name", "apache"), document);

		// 5、关闭IndexWriter
		writer.close();
		
		System.out.println("更新成功");
	}

问题：我们在入门示例中，已经知道Lucene是通过IndexSearcher对象，来执行搜索的。那我们为什么还要继续学习Lucene呢？
答：因为在实际的开发中，我们的查询的业务是相对复杂的，比如我们在通过关键词查找的时候，往往进行价格、商品类别的过滤。
而Lucene提供了一套查询方案，供我们实现复杂的查询。

执行查询之前，必须创建一个查询Query查询对象。
Query自身是一个抽象类，不能实例化，必须通过其它的方式来实现初始化。
在这里，Lucene提供了两种初始化Query查询对象的方式。

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

	QueryParser会将用户输入的查询表达式解析成Query对象实例。如下代码：
QueryParser queryParser = new QueryParser("name", new IKAnalyzer());
Query query = queryParser.parse("name:lucene");

/**
	 * Query子类查询之 TermQuery
	 *  
	 * 特点：不会再对查询的关键词做分词处理。
	 * 
	 * 需要：查询书名与java教程相关书。
	 */
@Test
	public void queryByTermQuery(){
		//1、获取一个查询对象
		Query query = new TermQuery(new Term("name", "编程思想"));
		doSearch(query);
		
	}
   private void doSearch(Query query) {
		try {
			
			
			//2、创建一个查询的执行对象
			//指定索引库的目录
			Directory d = FSDirectory.open(new File("F:\\lucene\\0719"));
			//创建流对象
			IndexReader reader = DirectoryReader.open(d);
			//创建搜索执行对象
			IndexSearcher searcher = new IndexSearcher(reader);
			
			//3、执行搜索
			TopDocs result = searcher.search(query, 10);
			
			//4、提出结果集，获取图书的信息
			int totalHits = result.totalHits;
			System.out.println("共查询到"+totalHits+"条满足条件的数据!");
			System.out.println("-----------------------------------------");
			//提取图书信息。
			//score即相关度。即搜索的关键词和 图书名称的相关度，用来做排序处理
			ScoreDoc[] scoreDocs = result.scoreDocs;
			
			for (ScoreDoc scoreDoc : scoreDocs) {
				/**
				 * scoreDoc.doc的返回值，是文档的id， 即 将文档写入索引库的时候，lucene自动给这份文档做的一个编号。
				 * 
				 * 获取到这个文档id之后，即可以根据这个id，找到这份文档。
				 */
				int docId = scoreDoc.doc;
				System.out.println("文档在索引库中的编号:"+docId);
				
				//从文档中提取图书的信息
				Document doc = searcher.doc(docId);
				System.out.println("图书id:"+doc.get("id"));
				System.out.println("图书name:"+doc.get("name"));
				System.out.println("图书price:"+doc.get("price"));
				System.out.println("图书pic:"+doc.get("pic"));
				System.out.println("图书description:"+doc.get("description"));
				System.out.println();
				System.out.println("------------------------------------");
				
			}
			
			//关闭连接，释放资源
			if(null!=reader){
				reader.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

/**
	 * Query子类查询  之  NumricRangeQuery
	 * 需求：查询所有价格在[60,80)之间的书
	 * @param query
	 */
@Test
    public void queryByNumricRangeQuery(){
    	/**
    	 * 第一个参数：要搜索的域
    	 * 第二个参数：最小值
    	 * 第三个参数：最大值
    	 * 第四个参数：是否包含最小值
    	 * 第五个参数：是否包含最大值
    	 */
    	Query query = NumericRangeQuery.newFloatRange("price", 60.0f, 80.0f, true, false);
    	
    	doSearch(query);
    }

/**
     * Query子类查询  之  BooelanQuery查询   组合条件查询
     * 
     * 需求：查询书名包含java，并且价格区间在[60,80)之间的书。
     */
    @Test
    public void queryBooleanQuery(){
    	//1、要使用BooelanQuery查询，首先要把单个创建出来，然后再通过BooelanQuery组合
    	Query price = NumericRangeQuery.newFloatRange("price", 60.0f, 80.0f, true, false);
    	Query name = new TermQuery(new Term("name", "java"));
    	
    	//2、创建BooleanQuery实例对象
    	BooleanQuery query = new BooleanQuery();
    	query.add(name, Occur.MUST_NOT);
    	query.add(price, Occur.MUST);
    	/**
    	 * MSUT  表示必须满足                          对应的是  +
    	 * MSUT_NOT  必须不满足                   应对的是  -
    	 * SHOULD  可以满足也可以不满足     没有符号
    	 * 
    	 * SHOULD 与MUST、MUST_NOT组合的时候，SHOULD就没有意义了。
    	 */
    	
    	doSearch(query);
    }

域名:关键字
实例：name:java

条件1 AND 条件2  
条件1 OR 条件2
条件1 NOT 条件2

/**
	 * 查询解析器查询  之  QueryParser查询
	 */
@Test
	public void queryByQueryParser(){
		try {
			
			//1、加载分词器
			Analyzer analyzer = new StandardAnalyzer();
			
			/**
			 * 2、创建查询解析器实例对象
			 * 第一个参数：默认搜索的域。
			 *          如果在搜索的时候，没有特别指定搜索的域，则按照默认的域进行搜索
			 *          如何在搜索的时候指定搜索域呢？
			 *          答：格式  域名：关键词        即   name:java教程
			 * 
			 * 第二个参数：分词器   ，对关键词做分词处理
			 */
			QueryParser parser = new QueryParser("description", analyzer);
			
			Query query = parser.parse("name:java教程");
			
			doSearch(query);
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

7.3.4	MultiFieldQueryParser
通过MulitFieldQueryParse对多个域查询。
/**
	 * 查询解析器查询  之  MultiFieldQueryParser查询
	 *  
	 *     特点：同时指定多个搜索域，并且对关键做分词处理
	 */
	@Test
	public void queryByMultiFieldQueryParser(){
		try {
			
			//1、定义多个搜索的  name、description
			String[] fields = {"name","description"};
			//2、加载分词器
			Analyzer analyzer = new StandardAnalyzer();
			
			//3、创建 MultiFieldQueryParser实例对象
			MultiFieldQueryParser mParser = new MultiFieldQueryParser(fields, analyzer);
			
			Query query = mParser.parse("lucene教程");
			
			doSearch(query);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

学过英文的都知道，英文是以单词为单位的，单词与单词之间以空格或者逗号句号隔开。
而中文的语义比较特殊，很难像英文那样，一个汉字一个汉字来划分。
所以需要一个能自动识别中文语义的分词器。

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

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

IKAnalyzer继承Lucene的Analyzer抽象类，使用IKAnalyzer和Lucene自带的分析器方法一样，将Analyzer测试代码改为IKAnalyzer测试中文分词效果。

如果使用中文分词器ik-analyzer，就在索引和搜索程序中使用一致的分词器ik-analyzer。

（1）打开Luke，不要指定Lucene目录。否则看不到效果
（2）在分词器栏，手动输入IkAnalyzer的全路径
org.wltea.analyzer.lucene.IKAnalyzer

// 创建中文分词器
Analyzer analyzer = new IKAnalyzer();

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">  
<properties>  
    <comment>IK Analyzer 扩展配置</comment>
    <!-- 用户可以在这里配置自己的扩展字典 -->
     <entry key="ext_dict">mydict.dic</entry> 
     <!-- 用户可以在这里配置自己的扩展停用词字典    -->
    <entry key="ext_stopwords">ext_stopword.dic</entry>
</properties>

思路：（1）使用全文检索来解决问题
         （2）数据源由数据库变成一堆文件。
         （3）从一堆文件中，读出里面的内容，转成文档，创建索引库。
         （4）创建索引库之后，再根据关键词搜索索引库，找出文件的名称。

问题：如何读文件的内容？
答：txt文本，直接使用IO即可。
        doc|docx  使用POI读取内容。