Lucene的基本使用

1、了解搜索技术

2、搜索引擎的原理

索引：类似于书的目录

3、实现搜索技术的方式

方式1：数据库搜索

利用SQL语句进行模糊搜索：

select * from items where title like “%上海%”;

select * from items where title like “上海%”;----走索引

问题：

在数据量很大的情况下，模糊搜索不一定走索引，因此效率就会很低。

方式2：Lucene技术

解决在海量数据的情况下，利用倒排索引技术，实现快速的搜索、打分、排序等功能

4、倒排索引技术

创建倒排索引，分为以下几步：

1）创建文档列表：

l  lucene首先对原始文档数据进行编号（DocID），形成列表，就是一个文档列表

2）创建倒排索引列表

l  然后对文档中数据进行分词，得到词条（Term）。对词条进行编号，以词条创建索引。然后记录下包含该词条的所有文档编号（及其它信息）。

拉斯跳槽 ---》拉斯、跳槽 –》0234

l  倒排索引创建索引的流程：

1）  首先把所有的原始数据进行编号，形成文档列表

2）  把文档数据进行分词，得到很多的词条，以词条为索引。保存包含这些词条的文档的编号信息。

l  搜索的过程：

1）  当用户输入任意的内容时，首先对用户输入的内容进行分词，得到用户要搜索的所有词条

2）  然后拿着这些词条去倒排索引列表中进行匹配。找到这些词条就能找到包含这些词条的所有文档的编号。

3）  然后根据这些编号去文档列表中找到文档

5、Lucene技术的增、删、改、查

1）导入依赖和插件

 <dependencies>
     <!-- Junit单元测试 -->
     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
     </dependency>
     <!-- lucene核心库 -->
     <dependency>
         <groupId>org.apache.lucene</groupId>
         <artifactId>lucene-core</artifactId>
         <version>4.10.2</version>
     </dependency>
     <!-- Lucene的查询解析器 -->
     <dependency>
         <groupId>org.apache.lucene</groupId>
         <artifactId>lucene-queryparser</artifactId>
         <version>4.10.2</version>
     </dependency>
     <!-- lucene的默认分词器库 -->
     <dependency>
         <groupId>org.apache.lucene</groupId>
         <artifactId>lucene-analyzers-common</artifactId>
         <version>4.10.2</version>
     </dependency>
     <!-- lucene的高亮显示 -->
     <dependency>
         <groupId>org.apache.lucene</groupId>
         <artifactId>lucene-highlighter</artifactId>
         <version>4.10.2</version>
     </dependency>
     <!--IK分词器-->
     <dependency>
         <groupId>com.janeluo</groupId>
         <artifactId>ikanalyzer</artifactId>
         <version>2012_u6</version>
     </dependency>
 </dependencies>

 <build>
 <plugins>
     <!-- java编译插件 -->
     <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.2</version>
         <configuration>
             <source>1.8</source>
             <target>1.8</target>
         </configuration>
     </plugin>
 </plugins>
 </build>

2）创建索引

 public class LuceneCreateTest {
     @Test
     public void testCreate() throws IOException {
         //创建文档对象
         Document document = new Document();

         //创建并添加字段信息，参数：字段的名称、字段的值、是否储存，这里选用Store.YES代表存储到文档列表
         //Store.NO代表不存储
         document.add(new StringField("id","1", Field.Store.YES));
         //这里的title字段需要用TextField，即创建索引又会被分词，StringField会创建索引，但是不会被分词
         document.add(new TextField("title","谷歌之父跳槽facebook,屌爆了", Field.Store.YES));

         //索引目录类，指定索引在硬盘中的位置
         Directory directory = FSDirectory.open(new File("indexDir"));

         //创建分词器对象
         // Analyzer analyzer = new StandardAnalyzer();
         //引用IK分词器
         Analyzer analyzer = new IKAnalyzer();

         //索引写出工具的配置对象
         IndexWriterConfig conf = new IndexWriterConfig(Version.LATEST,analyzer);
         //创建索引的写出工具类，参数：索引的目录和配置信息
         IndexWriter indexWriter = new IndexWriter(directory,conf);

         //把文档交给IndexWriter
         indexWriter.addDocument(document);

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

3）批量创建索引

 @Test
 public void testCreate2() throws IOException {
     //创建文档的集合
     Collection<Document> docs = new ArrayList<>();

     //创建文档对象
     Document document1 = new Document();
     document1.add(new StringField("id","1", Field.Store.YES));
     document1.add(new TextField("title","谷歌地图之父跳槽facebook", Field.Store.YES));
     docs.add(document1);

     //创建文档对象
     Document document2 = new Document();
     document2.add(new StringField("id","2", Field.Store.YES));
     document2.add(new TextField("title","谷歌地图创始人拉斯离开谷歌加盟Facebook", Field.Store.YES));
     docs.add(document2);

     // 创建文档对象
     Document document3 = new Document();
     document3.add(new StringField("id", "3", Field.Store.YES));
     document3.add(new TextField("title", "谷歌地图创始人拉斯离开谷歌加盟Facebook", Field.Store.YES));
     docs.add(document3);

     // 创建文档对象
     Document document4 = new Document();
     document4.add(new StringField("id", "4", Field.Store.YES));
     //document4.add(new TextField("title", "谷歌地图之父跳槽Facebook与Wave项目取消有关", Field.Store.YES));
     Field field = new TextField("title","谷歌地图之父跳槽Facebook与Wave项目取消有关", Field.Store.YES);
     //设置激励因子，作弊
     field.setBoost(10.0f);
     document4.add(field);
     docs.add(document4);

     // 创建文档对象
     Document document5 = new Document();
     document5.add(new StringField("id", "5", Field.Store.YES));
     document5.add(new TextField("title", "谷歌地图之父拉斯加盟社交网站Facebook", Field.Store.YES));
     docs.add(document5);

     //索引目录类，指定索引在硬盘的位置
     Directory directory = FSDirectory.open(new File("indexDir"));

     //引入IK分词器
     Analyzer analyzer = new IKAnalyzer();
     //索引写出工具的配置对象
     IndexWriterConfig config = new IndexWriterConfig(Version.LATEST,analyzer);

     //设置打开方式：openMode.APPEND会在索引的基础上追加新索引
     config.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
     //创建索引的写出工具类，参数：索引的目录和配置信息
     IndexWriter indexWriter = new IndexWriter(directory,config);

     //把文档集合交给IndexWriter
     indexWriter.addDocuments(docs);
     //提交
     indexWriter.commit();
     //关闭
     indexWriter.close();
 }

4）删除索引

 /*
     * 删除索引
     * 注意事项：
     *   1、一般，为了进行精确删除，我们会根据唯一字段来删除，比如ID
     *   2、如果是用Term删除，要求ID也必须是字符串类型
     * */
     @Test
     public void testDelete() throws IOException {
         //创建目录对象
         Directory directory = FSDirectory.open(new File("indexDir"));
         //创建配置对象
         IndexWriterConfig config = new IndexWriterConfig(Version.LATEST,new IKAnalyzer());
         //创建索引写出工具
         IndexWriter writer = new IndexWriter(directory,config);
         //根据词条进行删除
         // writer.deleteDocuments(new Term("id","2"));
         //根据query对象删除，如果ID是数值类型，那么我们可以用数值范围查询锁定一个具体的ID
 //        Query query = NumericRangeQuery.newLongRange("2d",2L,2L,true,true);
 ////        writer.deleteDocuments(query);

         //删除所有
         writer.deleteAll();
         //提交
         writer.commit();
         //关闭
         writer.close();
     }

5）查询索引

 @Test
 public void testSearch() throws IOException, ParseException {
     //索引目录对象
     Directory directory = FSDirectory.open(new File("indexDir"));

     //索引读取工具
     IndexReader reader = DirectoryReader.open(directory);
     //索引搜索工具
     IndexSearcher indexSearcher = new IndexSearcher(reader);

     //索引查询解析器，两个参数：默认要查询字段的名称、分词器
    // QueryParser parser = new QueryParser("title",new IKAnalyzer());

     //多字段查询解析器
     QueryParser parser = new MultiFieldQueryParser(new String[]{"id","title"},new IKAnalyzer());
     //创建查询对象
     Query query = parser.parse("硅谷地图之父拉斯");

     //搜索数据，两个参数：查询条件对象，要查询的最大结果条数（总共就5个文档，如果不知道文档数据数据，也可以
     //使用Integer.MAX_VALUE）
     //返回的结果是 按照匹配度排名得分前N名的文档信息（包括查询到的总条数信息、所有符合条件的文档的编号信息）
     //topDocs:两个属性：总记录数、文档数组
     TopDocs topDocs = indexSearcher.search(query,10);

     //获取总条数
     System.out.println("本次搜索共找到" + topDocs.totalHits + "条数据");
     //获取得分文档对象（ScoreDoc）数组 ScoreDao中包含：文档的编号、文档的得分
     ScoreDoc[] scoreDocs = topDocs.scoreDocs;
     for (ScoreDoc scoreDoc : scoreDocs) {
         //取出文档编号
         int docID = scoreDoc.doc;
         //根据编号去找文档
         Document document = reader.document(docID);

         System.out.println("id" + document.get("id"));
         System.out.println("title" + document.get("title"));

         //取出文档得分
         System.out.println("得分：" + scoreDoc.score);
     }

6）为了查询的方便，可以把上边的公共的部分代码抽取出来

 //抽取公共的方法,提取一个查询数据的通用方法
 public void search(Query query) throws IOException {
     //索引目录对象
     Directory directory = FSDirectory.open(new File("indexDir"));

     //索引读取对象
     IndexReader reader = DirectoryReader.open(directory);
     //索引搜索工具
     IndexSearcher searcher = new IndexSearcher(reader);

     //搜索数据，两个参数：查询条件对象，要查询的最大结果条数
     //返回的结果是 按照匹配度排名得分前N名的文档信息（包括查询到的总条数信息、所有符合条件的文档的编号信息）
     //topDocs:两个属性：总记录数、文档数组

     TopDocs topDocs = searcher.search(query,10);
     //获取总条数
     System.out.println("本次搜索共找到" + topDocs.totalHits + "条数据");
     //获取得分文档对象
     ScoreDoc[] scoreDocs = topDocs.scoreDocs;
     for (ScoreDoc scoreDoc : scoreDocs) {
         //取出文档编号
         int docID = scoreDoc.doc;
         //根据编号去找文档
         Document doc = reader.document(docID);
         System.out.println("id: " + doc.get("id"));
         System.out.println("title: " + doc.get("title"));
         //取出文档得分
         System.out.println("得分：" + scoreDoc.score);
     }
 }
 /**
  * 测试普通词条查询
  * 注意：Term（词条）是搜索的最小单位，不可在分词，值必须是字符串
  * 一般用来搜索唯一字段，比如ID（对不需要分词的关键字进行查询）
  * @throws IOException
  */
 @Test
 public void testTermQuery() throws IOException {
     //创建词条查询对象
     Query query = new TermQuery(new Term("title","谷歌地图"));
     search(query);
 }

 /*
 * 通配符查询
 * ? 可以代表任意一个字符
 * * 可以任意多个任意字符
 * */
 @Test
 public void testWildCardQuery() throws IOException {
     //创建查询对象
     Query query = new WildcardQuery(new Term("title","*歌*"));
     search(query);
 }

 /*
 * 模糊查询
 *
 * */
 @Test
 public void testFuzzyQuery() throws IOException {
     //创建模糊查询对象：允许用户输错，但是要求错误的最大编辑距离不能超过2
     //编辑距离：一个单词到另一个单词最少修改的次数
     //可以手动指定编辑距离，但是参数必须在0~2之间
     Query query = new FuzzyQuery(new Term("title","facevool"),2);
     search(query);
 }

 /*
 * 数值范围查询
 * 注意:数值范围查询，可以用来对非String类型的ID进行精确的查找
 * */
 @Test
 public void testNumericRangeQuery() throws IOException {
     //数值范围查询对象，参数：字段名称，最小值、最大值、是否包含最小值、是否包含最大值
     Query query = NumericRangeQuery.newLongRange("id",2L,2L,true,true);
     search(query);
 }

 /*
 * 布尔查询
 * 布尔查询本身没有查询条件，可以把查询通过逻辑运算进行组合！
 * 交集：Occur.MUST + Occur.MUST
 * 并集：Occur.SHOULD + Occur.SHOULD
 * 非：Occur.MUST
 * */
 @Test
 public void testBooleanQuery() throws IOException {
     Query query1 = NumericRangeQuery.newLongRange("id",1L,3L,true,true);
     Query query2 = NumericRangeQuery.newLongRange("id",2L,4L,true,true);

     // 创建布尔查询的对象
     BooleanQuery query = new BooleanQuery();
     // 组合其它查询
     query.add(query1, BooleanClause.Occur.MUST_NOT);
     query.add(query2, BooleanClause.Occur.SHOULD);

     search(query);

 }

7）修改索引

 public class LuceneUpdate {
     /*
     * 修改索引
     * 注意事项：
     *   1、Lucene修改功能底层会先删除，再把新的文档添加
     *   2、修改功能会根据Term进行匹配，所有匹配到的都会被删除，这样不好
     *   3、因此，一般我们修改时，都会根据一个唯一不重复字段进行匹配修改，例如ID
     *   4、但是词条搜索，要求ID必须是字符串，如果不是，这个方法就不能用
     *
     *   如果ID是数值类型，我们不能直接去修改，可以先手动删除deleteDocument（数值范围查询锁定ID）。再添加
     * */

     @Test
     public void testUpdate() throws IOException {
         //创建目录对象
         Directory directory = FSDirectory.open(new File("indexDir"));

         //创建配置对象
         IndexWriterConfig config = new IndexWriterConfig(Version.LATEST,new IKAnalyzer());

         //创建索引写出工具
         IndexWriter writer = new IndexWriter(directory,config);
         //创建新的文档数据
         Document doc = new Document();
         doc.add(new StringField("id","1", Field.Store.YES));
         doc.add(new TextField("title","谷歌地图之父跳槽facebook为了加入传智播客 屌爆了呀", Field.Store.YES));

         /*
         * 修改索引，参数
         * 词条：根据这个词条匹配到的所有的文档都会被修改
         * 文档信息：要修改的新的文档数据
         * */

         writer.updateDocument(new Term("id","1"),doc);
         //提交
         writer.commit();
         //关闭
         writer.close();
     }