Lucene-----信息检索技术

1 信息检索概述

1.1 传统检索方式的缺点

    • 文件检索
        操作系统常见的是硬盘文件检索
        文档检索:整个文档打开时已经加载到内存了;
        缺点:全盘遍历,慢,内存的海量数据
    • 数据库检索
        like "%三星%" 全表遍历;
        like "三星%" 最左特性 不会全表遍历;
        
        无法满足海量数据下准确迅速的定位
        mysql 单表数据量---千万级
        oracle 单表数据量---亿级
　　

　　总结:传统的方式无法满足检索的需求(迅速,准确,海量)

 

2 全文检索技术(大型互联网公司的搜索功能都是全文检索)

2.1 定义:

• 在海量的信息中,通过固定的数据结构引入索引文件,利用对索引文件的处理实现对应数据的快速定位等功能的技术;
• 信息检索系统(全文检索技术的应用,搜索引擎百度,google)
• 信息采集:通过爬虫技术,将公网的海量非结构化数据爬去到本地的分布式存储系统进行存储
• 信息整理:非结构化数据无法直接提供使用,需要整理,整理成索引文件
• 信息查询:通过建立一个搜索的应用,提供用户的入口进行查询操作,利用查询条件搜索索引文件中的有效数据;

 2.2结构

问题:非结构化数据,海量数据如何整理成有结构的索引文件(索引文件到底什么结构)?

2.3 倒排索引

　　　索引文件,是全文检索技术的核心内容,创建索引,搜索索引也是核心,搜索在创建之后的;
    　　如何将海量数据计算输出成有结构的索引文件,需要严格规范的计算逻辑-----倒排索引的计算
    
  　　  以网页为例:
   　　 假设爬虫系统爬去公网海量网页(2条);利用倒排索引的计算逻辑,将这2个非结构化的网页信息数据整理成索引文件;
    
  　　  源数据: 标题,时间,作者,留言,内容
 　　   网页1(id=1): 王思聪的IG战队获得LOL世界冠军,结束长达8年的遗憾
 　　   网页2(id=2): 王思聪又换女朋友了吗?嗯,天天换.
    
  　　  倒排索引的第一步:计算分词(数据内容)
 　　       分词:将数据字符串进行切分,形成最小意义的词语  (不同语言底层实现是不一样的)
  　　      并且每个分词计算的词语都会携带计算过程中的一些参数
  　　      词语(来源的网页id,当前网页中该词语出现的频率,出现的位置)
    
  　　  网页1: 王思聪(1,1,1),IG(1,1,2),战队(1,1,3), LOL(1,1,4) 世界(1,1,5)
 　　   网页2: 王思聪(2,1,1),女朋友(2,1,1),天天(2,1,1);
    
 　　   倒排索引第二步:合并分词结果
　　 　　   合并结果:王思聪([1,2],[1,1],[1,1]),IG(1,1,2),战队(1,1,3), LOL(1,1,4) 世界(1,1,5),女朋友(2,1,1),天天(2,1,1);
  　　 　　 合并逻辑:所有的网页的分词计算结果一定有重复的分词词汇,合并后所有参数也一起合并,结果形成了一批索引结构的数据;
   　　 倒排索引第三步:源数据整理document对象

　　　　　　document是索引文件中的文档对象,最小的数据单位(数据库中的一行数据)每个document对应一个网页

　　　　 倒排索引第四步:形成索引文件
   　　 　　将网页的数据对象(document)和分词合并结果(index)一起存储到存储位置,形成整体的索引文件

　　索引文件结构:

　　　　数据对象

　　　　合并分词结果

　　

　　对索引文件中的分词合并后的数据进行复杂的计算处理,获取我们想要的数据集合(document的集合)

3 Lucene

3.1介绍

　　是一个全文检索引擎工具包,hadoop的创始人Doug Cutting开发,2000年开始,每周花费2天,完成了lucene的第一个版本;引起搜索界的巨大轰动; java开发的工具包;

3.2 特点

• 　　稳定,索引性能高 (创建和搜索的性能)
• 　　现代磁盘每小时能索引150G数据(读写中)
• 　　对内存要求1MB栈内存
• 　　增量索引和批量索引速度一样快
• 　　索引的数据占整体索引文件20%
• 　　支持多种主流搜索功能.

3.3分词代码测试

　　准备依赖的jar包(lucene6.0)

　　

    <!-- lucene查询扩展转化器 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-queryparser</artifactId>
               <version>6.0.0</version>
        </dependency>
        <!-- lucene自带的智能中文分词器 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-analyzers-smartcn</artifactId>
            <version>6.0.0</version>
        </dependency>
        <!-- lucene核心功能包 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-core</artifactId>
            <version>6.0.0</version>
        </dependency>

　　lucene分词测试

　　索引的查询都是基于分词的计算结果完成的,这种计算分词的过程叫做词条化,得到的每一个词汇称之为词项,lucene提供抽象类Analyzer表示分词器对象,不同的实现类来自不同的开发团队,实现这个Analyzer完成各自分词的计算;lucene也提供了多种分词器计算

• 　　    StandardAnalyzer 标准分词器,分词英文
• 　　WhitespaceAnalyzer 空格分词器　
• SimpleAnalyzer 简单分词器
• 　　 SmartChineseAnalyzer 智能中文分词器

　　

 package com.jt.test.lucene;

 import java.io.StringReader;

 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
 import org.apache.lucene.analysis.core.SimpleAnalyzer;
 import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
 import org.junit.Test;

 /**
  *测试不同分词器对同一个字符串的分词结果
  */
 public class AnalyzerTest {

     //编写一个静态方法, String str,Analayzer a
     //实现传入的字符串进行不同分词器的计算词项结果
     public static void printA(Analyzer analyzer,String str) throws Exception{
         //org.apache.lucene
         //获取str的刘对象
         StringReader reader=new StringReader(str);
         //通过字符串流获取分词词项流,每个不同的analyzer实现对象
         //词项流的底层计算时不一样的;
         //fieldName是当前字符串 代表的document的域名/属性名
         TokenStream tokenStream = analyzer.tokenStream("name", reader);
         //对流进行参数的重置reset,才能获取词项信息
         tokenStream.reset();
         //获取词项的打印结果
         CharTermAttribute attribute
         = tokenStream.getAttribute(CharTermAttribute.class);
         while(tokenStream.incrementToken()){
             System.out.println(attribute.toString());
         }
     }
     @Test
     public void test() throws Exception{
         String str="近日,有网友偶遇诸葛亮王思聪和网红焦可然一起共进晚餐,"
                 + "照片中,焦可然任由王思聪点菜,自己则专注玩手机,";
         //创建不同的分词计算器
         Analyzer a1=new StandardAnalyzer();
         Analyzer a2=new SmartChineseAnalyzer();
         Analyzer a3=new SimpleAnalyzer();
         Analyzer a4=new WhitespaceAnalyzer();
         //调用方法测试不同分词器的分词效果
         System.out.println("*******标准分词器*******");
         AnalyzerTest.printA(a1, str);
         System.out.println("*******智能中文分词器*******");
         AnalyzerTest.printA(a2, str);
         System.out.println("*******简单分词器*******");
         AnalyzerTest.printA(a3, str);
         System.out.println("*******空格分词器*******");
         AnalyzerTest.printA(a4, str);
     }
 }

3.4中文分词器常用IKAnalyzer

　　可以实现中文的只能分词,并且支持扩展,随着语言的各种发展,可以利用ext.dic文档补充词项,也支持停用,stop.dic;

• 实现类的编写(IKAnalyzer需要自定义实现一些类)

   package com.jt.lucene.IK;
  
   import java.io.IOException;
  
   import org.apache.lucene.analysis.Tokenizer;
   import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
   import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
   import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
   import org.wltea.analyzer.core.IKSegmenter;
   import org.wltea.analyzer.core.Lexeme;
  
   public class IKTokenizer6x extends Tokenizer{
       //ik分词器实现
       private IKSegmenter _IKImplement;
       //词元文本属性
       private final CharTermAttribute termAtt;
       //词元位移属性
       private final OffsetAttribute offsetAtt;
       //词元分类属性
       private final TypeAttribute typeAtt;
       //记录最后一个词元的结束位置
       private int endPosition;
       //构造函数，实现最新的Tokenizer
       public IKTokenizer6x(boolean useSmart){
           super();
           offsetAtt=addAttribute(OffsetAttribute.class);
           termAtt=addAttribute(CharTermAttribute.class);
           typeAtt=addAttribute(TypeAttribute.class);
           _IKImplement=new IKSegmenter(input, useSmart);
       }
  
       @Override
       public final boolean incrementToken() throws IOException {
           //清除所有的词元属性
           clearAttributes();
           Lexeme nextLexeme=_IKImplement.next();
           if(nextLexeme!=null){
               //将lexeme转成attributes
               termAtt.append(nextLexeme.getLexemeText());
               termAtt.setLength(nextLexeme.getLength());
               offsetAtt.setOffset(nextLexeme.getBeginPosition(),
                       nextLexeme.getEndPosition());
               //记录分词的最后位置
               endPosition=nextLexeme.getEndPosition();
               typeAtt.setType(nextLexeme.getLexemeText());
               return true;//告知还有下个词元
           }
           return false;//告知词元输出完毕
       }
  
       @Override
       public void reset() throws IOException {
           super.reset();
           _IKImplement.reset(input);
       }
  
       @Override
       public final void end(){
           int finalOffset = correctOffset(this.endPosition);
           offsetAtt.setOffset(finalOffset, finalOffset);
       }
  
   }

   package com.jt.lucene.IK;
  
   import org.apache.lucene.analysis.Analyzer;
   import org.apache.lucene.analysis.Tokenizer;
  
   public class IKAnalyzer6x extends Analyzer{
       private boolean useSmart;
       public boolean useSmart(){
           return useSmart;
       }
       public void setUseSmart(boolean useSmart){
           this.useSmart=useSmart;
       }
       public IKAnalyzer6x(){
           this(false);//IK分词器lucene analyzer接口实现类，默认细粒度切分算法
       }
       //重写最新版本createComponents；重载analyzer接口，构造分词组件
       @Override
       protected TokenStreamComponents createComponents(String filedName) {
           Tokenizer _IKTokenizer=new IKTokenizer6x(this.useSmart);
           return new TokenStreamComponents(_IKTokenizer);
       }
       public IKAnalyzer6x(boolean useSmart){
           super();
           this.useSmart=useSmart;
       }
  
   }

• 手动导包
  build-path添加依赖的jar包到当前工程   IKAnalyzer2012_u6.jar
• 扩展词典和停用词典的使用

      <entry key="ext_dict">ext.dic;</entry>
      <!--用户可以在这里配置自己的扩展停止词字典-->
      <entry key="ext_stopwords">stopword.dic;</entry>
      和配置文件同目录下准备2个词典;
          确定分词器使用的代码编码字符集与词典编码是同一个    

4 Lucene创建索引

4.1概念

查询(Query):对于全文检索,最终都是使用词项指向一批document文档对象的集合,利用对词项的逻辑计算可以实现不同的查询功能;查询时构建的对象就是Query;

文档(document):是索引文件中的一个最小的数据单位,例如非结构化数据中的网页将会封装成一个document存储在索引文件中,而封装过程中写在对象里的所有数据都会根据逻辑进行分词计算,不同的结构数据源会对应创建具有不同属性的document对象

文档的域(Field):每个文档对象根据不同的数据来源封装Field的名称,个数和数据,导致document的结构可能各不相同

词条化(tokenization):计算分词过程

词项(Term):计算分词的结果每一个词语都是一个项

4.2 创建一个空的索引文件

• 指向一个索引文件位置
• 生成输出对象,进行输出

   @Test
       public void emptyIndex() throws Exception{
           //指向一个文件夹位置
           Path path = Paths.get("./index01");
           Directory dir=FSDirectory.open(path);
           //生成一个输出对象 writer 需要分词计算器,配置对象
           Analyzer analyzer=new IKAnalyzer6x();
           IndexWriterConfig config=new IndexWriterConfig(analyzer);
           IndexWriter writer=new IndexWriter(dir,config);
           //写出到磁盘,如果没有携带document,生成一个空的index文件
           writer.commit();
  
   } 

  在索引中创建数据

• 将源数据读取封装成document对象,根据源数据的结构定义document的各种field;

       @Test
           public void createData() throws Exception{
               /*
                * 1 指向一个索引文件
                * 2 生成输出对象
                * 3 封装document对象(手动填写数据)
                * 4 将document添加到输出对象索引文件的输出
                */
               //指向一个文件夹位置
               Path path = Paths.get("./index02");
               Directory dir=FSDirectory.open(path);
               //生成一个输出对象 writer 需要分词计算器,配置对象
               Analyzer analyzer=new IKAnalyzer6x();
               IndexWriterConfig config=new IndexWriterConfig(analyzer);
               IndexWriter writer=new IndexWriter(dir,config);
               //构造document对象
               Document doc1=new Document();//新闻 作者,内容,网站链接地址
               Document doc2=new Document();//商品页面,title,price,详情,图片等
               doc1.add(new TextField("author", "韩寒", Store.YES));
               doc1.add(new TextField("content","我是上海大金子",Store.NO));
               doc1.add(new StringField("address", "http://www.news.com", Store.YES));
               doc2.add(new TextField("title", "三星(SAMSUNG) 1TB Type-c USB3.1 移动固态硬盘",Store.YES));
               doc2.add(new TextField("price","1699",Store.YES));
               doc2.add(new TextField("desc","不怕爆炸你就买",Store.YES));
               doc2.add(new StringField("image", "image.jt.com/1/1.jpg",
                       Store.YES));
               //将2个document对象添加到writer中写出到索引文件;
               writer.addDocument(doc1);
               writer.addDocument(doc2);
               //写出到磁盘,如果没有携带document,生成一个空的index文件
               writer.commit();
           }

• 问题一:Store.yes和no的区别是什么?????
  • Store,yes和no的区别在于,创建索引数据,非领导数据是否在输出到索引时存储到索引文件,按照类的类型进行计算分词,一些过大的数据,查询不需要的数据可以不存储在索引文件中(例如网页内容;计算不计算分词,和存储索引没有关系)
• 问题二:StringField和TextField的区别是什么
  • 域的数据需要进行分词计算如果是字符串有两种对应的域类型
  • 其中StringField表示不对数据进行分词计算,以整体形势计算索引
  • TextField表示对数据进行分词计算,以词形势计算索引
• 问题三:    问题3:显然document中的不同域field应该保存不同的数据类型
  • 数据中的类型不同,存储的数据计算逻辑也不同;
  • int long double的数字数据如果使用字符串类型保存域
  • 只能做到一件事--存储在索引文件上
  • 以上几个Point类型的域会对数据进行二进制数字的计算;
  • 范围查找,只要利用intPoint,longPoint对应域存储到document对象后
  • 这种类型的数据在分词计算中就具有了数字的特性 > <
  • intPoint只能存储数值,不存储数据
  • 如果既想记性数字特性的使用,又要存储数据;需要使用StringField类型

　　　　

5 Lucene索引的搜索

5.1词项查询

　　 单域查询:查询条件封装指定的域,给定Term(词项),lucene调用搜索api可以根据指定的条件,将所有当前查询的这个域中的分词结果进行比对,如果比对成功指向document对象返回数据;

 @Test
     public void search() throws Exception{
         /*
          * 1 指向索引文件
          * 2 构造查询条件
          * 3 执行搜索获取返回数据
          * 4 从返回数据中获取document对象
          */
         Path path = Paths.get("./index02");
         Directory dir=FSDirectory.open(path);
         //获取与输入流reader,从这里生产查询的对象
         IndexReader reader=DirectoryReader.open(dir);
         IndexSearcher search=new IndexSearcher(reader);
         //由于使用的是term查询,无需包装analyzer;
         //构造查询条件;
         Term term=new Term("title","三星");
         Query termQuery=new TermQuery(term);
         //查询,获取数据
         TopDocs docs = search.search(termQuery, 10);
         //将docs转化成document的获取逻辑
         ScoreDoc[] scoreDoc=docs.scoreDocs;
         for (ScoreDoc sd : scoreDoc) {
             //没循环一次,都可以获取document对象一个
             Document doc=search.doc(sd.doc);
             System.out.println("author:"+doc.get("author"));
             System.out.println("content:"+doc.get("content"));
             System.out.println("address:"+doc.get("address"));
             System.out.println("title:"+doc.get("title"));
             System.out.println("image:"+doc.get("image"));
             System.out.println("price:"+doc.get("price"));
             System.out.println("rate:"+doc.get("rate"));
             System.out.println("desc:"+doc.get("desc"));}}

　　多域查询:指定的查询多个field,传递参数的字符串会被先进行分词计算,利用分词计算的结果(多个词项),比对所有的域中的词项,只要满足一个与对应一个词项的最小要求就可以拿到当前的document范围.

     @Test
         public void multiQuery() throws Exception{
             //使用parser,转化查询条件,需要传递analyzer,查询的字符串需要计算分词
             Path path=Paths.get("./index02");
             Directory dir=FSDirectory.open(path);
             IndexReader reader=DirectoryReader.open(dir);
             IndexSearcher search=new IndexSearcher(reader);
             //用到分词器计算查询的条件,必须和创建索引时用的分词一致;
             Analyzer analyzer=new IKAnalyzer6x();
             //准备查询的2个域desc title
             String[] fields={"desc","title"};
             //获取转化器,将查询的字符串进行分词计算,获取多于查询的对象query
             MultiFieldQueryParser parser=
                     new MultiFieldQueryParser(fields,analyzer);
             Query multiFieldQuery=parser.parse("爆");//三星,爆炸
             TopDocs docs=search.search(multiFieldQuery, 10);
             ScoreDoc[] scoreDocs=docs.scoreDocs;
             for (ScoreDoc scoreDoc : scoreDocs) {
                 Document doc=search.doc(scoreDoc.doc);
                 System.out.println("author:"+doc.get("author"));
                 System.out.println("content:"+doc.get("content"));
                 System.out.println("address:"+doc.get("address"));
                 System.out.println("title:"+doc.get("title"));
                 System.out.println("image:"+doc.get("image"));
                 System.out.println("price:"+doc.get("price"));
                 System.out.println("rate:"+doc.get("rate"));
                 System.out.println("desc:"+doc.get("desc"));}}

　　布尔查询:可以封装多个查询条件的对象query,由布尔查询条件实现多个其他查询的逻辑关系 MUST必须包含 MUST_NOT必须不包含.

　　对应一个布尔查询条件,一个没有must条件的布尔查询可以有一个或者多个should,有must条件的布尔查询,should不起作用;

　　MUST:匹配结果必须包含这个条件

　　MUST_NOT:匹配结果必须不包含这个条件

　　SHOULD:没有must的booleanClause中,可以有1个或者多个should,一旦有must条件,should就没有作用了

　　FILTER:和must效果一样,必须包含,但是查询过程不参加评分计算.

     @Test
         public void booleanQuery() throws Exception{
             Path path=Paths.get("./index02");
             Directory dir=FSDirectory.open(path);
             IndexReader reader=DirectoryReader.open(dir);
             IndexSearcher search=new IndexSearcher(reader);
             //设置多个查询的query,可以使任何类型,TermQuery
             //准备查询的2个域desc title
             Analyzer analyzer=new IKAnalyzer6x();
             String[] fields={"desc","title"};
             //获取转化器,将查询的字符串进行分词计算,获取多于查询的对象query
             MultiFieldQueryParser parser=
                     new MultiFieldQueryParser(fields,analyzer);
                     Query multiFieldQuery=parser.parse("三星爆炸");//三星,爆炸
             Query query1=new TermQuery(new Term("title","三星"));
             Query query2=new TermQuery(new Term("desc","爆炸"));
             //构造一个布尔的查询条件 先构造查询的逻辑对象
             BooleanClause bc1=new BooleanClause(query1,Occur.MUST);
             //BooleanClause bc2=new BooleanClause(query2,Occur.MUST_NOT);
             BooleanClause bc2=new BooleanClause(multiFieldQuery,Occur.FILTER);
             BooleanQuery boolQuery=
                     new BooleanQuery.Builder().add(bc1).add(bc2).build();
             TopDocs docs=search.search(boolQuery, 10);
             ScoreDoc[] scoreDocs=docs.scoreDocs;
             for (ScoreDoc scoreDoc : scoreDocs) {
                 Document doc=search.doc(scoreDoc.doc);
                 System.out.println("author:"+doc.get("author"));
                 System.out.println("content:"+doc.get("content"));
                 System.out.println("address:"+doc.get("address"));
                 System.out.println("title:"+doc.get("title"));
                 System.out.println("image:"+doc.get("image"));
                 System.out.println("price:"+doc.get("price"));
                 System.out.println("rate:"+doc.get("rate"));
                 System.out.println("desc:"+doc.get("desc"));
                 System.out.println("文档评分:"+scoreDoc.score);
             }
 }

　　范围查询:对查询条件进行范围的定义,查询某个域的数据范围,只能对INTPOINT LONGPOINT DOUBLEPOINT FLOATPOINT类型的域做查询;

　　Query rangeQuery=IntPoint.newRangeQuery("rate", 200, 1000);

　　前缀查询:非常类似数据库中的like"三星%",查询条件表示前缀,只要当前的域满足前缀的内容,就能够查询document;

　　    //构造前缀的词项
    Term term=new Term("desc","爆");
    Query query=new PrefixQuery(term);
　　前缀查询中,前缀本身必须是索引文件的词项,否则无法查到

　　模糊查询
    Term term=new Term("name","tramp");
    FuzzyQuery query=new FuzzyQuery(term);
    使用term中的词项,但是不在进行精确的匹配,可以查到具有trump词项;
    曰和日, 晶和品

　　通配符查询
    WildcardQuery query= new WildcardQuery(new Term("name","爆?")) //效率不高,小范围的遍历
　　?匹配所有内容,可以补充前缀查询中使用Term的问题;