精华内容
下载资源
问答
  • www.tompall.com lucene 全文检索 站内搜索 Lucene分页
  • Lucene全文检索

    2019-08-13 11:37:04
    Lucene全文检索Lucene的介绍Lucene的应用场景Lucene实现全文检索的过程创建索引的过程1. 获得原始文档2.创建文档对象3.分析文档4.创建索引5.查询索引代码实现查询索引的过程1.用户查询接口2.创建查询3.执行查询4....

    Lucene的介绍

    全文检索的概念:将非结构化的数据(大小不定,格式不定)中的一部分信息提取出来,重新组织,使其变得有一定结构,然后对此有一定结构的数据进行搜索,从而达到搜索比较快的目的。这部分从非结构化的数据中提取出的然后重新组织的信息,我们称之为索引。这种先建立索引,再对索引进行搜素的过程就叫全文索引。

    lucece的下载地址:http://lucene.apache.org/core/downloads.html

    Lucene的应用场景

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

    Lucene实现全文检索的过程

    在这里插入图片描述

    1. 绿色表示创建索引的过程
    2. 红色表示搜索过程

    创建索引的过程

    1. 获得原始文档

    在这里插入图片描述

    2.创建文档对象

    对于原始文档中的每一个文件,我们都可以创建一个对象来表示。
    文档对象中存储的是键值对,键是域(Field)类似于数据库中的字段,值(value)表示的是存储的内容。
    在这里插入图片描述

    3.分析文档

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

    4.创建索引

    在这里插入图片描述

    5.查询索引

    查询索引就是搜索的过程。搜索就是用户输入关键字,从索引中进行搜索的过程。

    代码实现

    需要导入的jar包
    在这里插入图片描述

     @Test
        public void createIndex() throws Exception {
            //指定索引库存放的路径
            //F://temp//index
    
            //1.将索引存储到磁盘中
            Directory directory= FSDirectory.open(new File("F:\\所有的jar包\\temp\\index").toPath());
    
            //2.创建indexwriterconfig对象
            IndexWriterConfig config= new IndexWriterConfig(new IKAnalyzer());
    
            //3.创建indexwriter对象
            IndexWriter indexWriter=new IndexWriter(directory,config);
    
            //4. 将原始文档写入到索引库
    
            //原始文档的路径
            File dir=new File("F:\\所有的jar包\\searchsource");
    
            for (File f: dir.listFiles()){
                //文件名
                String fileName=f.getName();
    
                //文件内容
                String fileContent= FileUtils.readFileToString(f,"utf-8");
    
                //文件路径
                String filePath=f.getPath();
    
                //文件的大小
                long fileSize=FileUtils.sizeOf(f);
    
                //创建文件名域:第一个参数:域的名称 第二个参数:域的内容 第三个参数:是否存储
                Field fileNameField= new TextField("fileName",fileName, Field.Store.YES);
    
                //创建文件内容域
                Field fileContentField=new TextField("fileContent",fileContent, Field.Store.YES);
    
                //创建文件路径域
                Field filePathField=new TextField("filePath",filePath, Field.Store.YES);
    
                //创建文件大小域
                Field fileSizeField=new TextField("fileSize",fileSize+"", Field.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();
        }
    

    查询索引的过程

    1.用户查询接口

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

    2.创建查询

    用户输入查询关键字执行搜索之前需要构建一个查询对象,查询对象中可以指定查询要搜索的Field文档域,查询关键字等等

    3.执行查询

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

    4.渲染结果

    以一个友好的页面把结果展示给用户。

    代码

    @Test
        public void searchIndex() throws Exception{
            //指定索引库存放的路径
            //F://temp//index
            Directory directory=FSDirectory.open(new File("F:\\所有的jar包\\temp\\index").toPath());
    
            //创建indexReader对象
            IndexReader indexReader= DirectoryReader.open(directory);
    
            //创建indexSearcher对象
            IndexSearcher indexSearcher=new IndexSearcher(indexReader);
    
            //创建查询
            Query query=new TermQuery(new Term("fileContent","spring"));
    
            //执行查询
            //第一个参数是查询对象,第二个参数是查询结果返回的最大值
            TopDocs topDocs=indexSearcher.search(query,10);
    
            //查询结果的总条数
            System.out.println("查询结果的总条数:"+topDocs.totalHits);
    
            //遍历查询结果
            //topDocs.scoreDocs存储了document对象的id
            for (ScoreDoc scoreDoc:topDocs.scoreDocs){
                //scoreDoc.doc属性就是对象的id
                //根据document的Id找到document对象
                Document document=indexSearcher.doc(scoreDoc.doc);
                System.out.println(document.get("fileName"));
                System.out.println(document.get("filePath"));
                System.out.println(document.get("fileSize"));
    
                System.out.println("-------------");
    
            }
    
            //关闭indexReader对象
            indexReader.close();
        }
    
    展开全文
  • lucene全文检索实现流程

    千次阅读 2010-07-02 16:41:00
    对于lucene全文检索,可以简约地看看它的7个主要类,这7个类同时也表达了处理全文检索的7个意念。因为数据库比较为人所熟悉,它又与全文检索某些理念极为相似,所以在对下面的概念说明时,将会大量在渗入...

    对于lucene全文检索,可以简约地看看它的7个主要类,这7个类同时也表达了处理全文检索的7个意念。因为数据库比较为人所熟悉,它又与全文检索某些理念极为相似,所以在对下面的概念说明时,将会大量在渗入数据库和全文检索间的类比。
    1)Document :它的中文意思是文档,对于一个文档,通常都包括它的标题、时间、作者、内容。如果让它的意思泛化,它也有文件的意思(相信Lucene的作者在取这个类名的时候也是经过再三斟酌的),对于文件,它可以指一个TXT文本、一个HTML网页、一个PDF文件等等。总而言之,它是映射着某一个具体的文件,这就是它的单位粒度。对应于数据库的概念是记录,英文是Record,weblucene在索引源的xml中就原原本本地采用了这个概念,可参照<weblucene_home>/dump/blog.xml 。

    2)Field :中文意思是字段。汉语的翻译将这个单词的意思表达得更恰如其分了,意思是文字片段,它可以是一个或多个字。字段是文档(Document)的次粒度单位,也是检索的最基本单位。注意这个概念跟在搜索引擎的输入框中随意输入的那几个字或几组字不是一样的,在搜索输入框中输入的那些文字首先需要经过一个QueryParser(这也是7个类中的一个)将其分解成真正的Field。 在数据库中本来就有Field 这个概念,它即是Record的次级单位。在数据库一条或多条记录怎么被找出来的,往往就经由对Field的检索而得来。在全文检索中Document的最终取得也是差不多,它是根据现在的某个Filed来决定的。即根据文档中的某些还不完整的东西牵引出它的所需的全部。
    示例代码:

    代码内容
    [com.chedong.weblucene.search.WebLuceneResultSetTest]
    Document doc = new Document();
    doc.add(Field.Keyword("keyword", "房地产"));
    doc.add(Field.Keyword("keyword", "非典"));


    3)IndexWriter :索引书写者
    示例代码:
    [org.apache.lucene.index.TestIndexWriter]

    代码内容
    Document doc = new Document();
    doc.add(Field.UnStored("content", "aaa"));
    try {
    IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);
    writer.addDocument(doc);
    }
    catch (IOException e) {
    e.printStackTrace();
    }


    它的构造器new IndexWriter(dir, new WhitespaceAnalyzer(), true) 有三个参数,分别是Directory对象、分析器对象(这是下一个要介绍的类)和一个布尔量,是否要重写索引就是由这个布尔量标明的,如果取false则仅仅是将索引附加上来。

    4)Analyzer : 分析器,它将目录中的一组原始文件分析成由一组Document和它相应的次级粒度Field组成的索引。因为不同的文件类型,同样的文本其内部文件流组织形式是不一样的,所以需要不同的分析器处理不同的文件类型(如PDFAnalyzer、HtmlAnalyzer)。又因为不同的文字语言处理Field拆分(Token)上是不一样的,所以在语言角度上又有另一层分析器的类别区分,如下面这行代码是处理普通中文字符的
    [com.chedong.weblucene.search.WebLuceneResultSetTest]
    IndexWriter writer = new IndexWriter(dir, new CJKAnalyzer(), true);

    5)QueryParser :这前面在区分Field和用户输入的搜索关键字时已经提及了。(它所用的词是Query,跟数据库所用的是一个概念的,这个词同样的检索上让人感觉没有像Search那么费尽心思去深究。)QueryParser并没有实际地去做查询工作,它只是Parser(剖析)用户输入的东西,并把剖析的结果以一种规则的形式送给Searcher去执行一个真正的搜索。作为剖析的结果,不仅仅是Field,还有Field们相互间的关系(terms,譬如逻辑和AND,逻辑或OR, 逻辑非NOT)。

    6)Searcher : 搜索一个Query,将结果返回。
    [org.apache.lucene.search..TestNot]

    代码内容
    RAMDirectory store = new RAMDirectory();
    IndexWriter writer = new IndexWriter(store, new SimpleAnalyzer(), true);

    Document d1 = new Document();
    d1.add(Field.Text("field", "a b"));

    writer.addDocument(d1);
    writer.optimize();
    writer.close();

    Searcher searcher = new IndexSearcher(store);
    Query query = QueryParser.parse("a NOT b", "field", new SimpleAnalyzer());
    //System.out.println(query);
    Hits hits = searcher.search(query);


    对于每一个搜索器对象,它都需要指定一个索引文件路径,然后由搜索器对Query对象执行查询。 上面的这个类袖珍地对7个主要类都均有涉及。

    7)Hits : Lucene的类注释是:A ranked list of documents, used to hold search results. 搜索的结果不仅仅是一些文档,而且这些文档还是有级别的,这个级别是对于先后次序而言的。它对应于数据库中的RecordSet / ResultSet 。

    展开全文
  • Lucene全文检索Lucene全文检索Lucene简介Lucene实现全文检索流程Lucene_demo Lucene全文检索 Lucene简介 Lucene是apache下用java编写一个开源全文检索工具包。 全文检索:首先把将要查询目标文档提取出来,...

    Lucene全文检索

    Lucene简介

    Lucene是apache下用java编写的一个开源的全文检索工具包。
    全文检索:首先把将要查询的目标文档提取出来,构造一套索引,在应用查询的时候通过查询索引得到目标文档。

    Lucene实现全文检索流程

    1. 构造索引:
      采集原始数据(文件系统/数据库/网络数据/手工录入)
      构造文档对象:(document)
      分析分词的过程
      创建索引

    2. 搜索索引获取目标文档
      用户输入搜索关键字
      创建查询
      搜索目标索引库
      返回结果

    Lucene_demo

    1. 准备
      1.1 下载lucene.jar
      1.2 将核心包(lucene-core-7.7.2.jar),分析器包(lucene-analyzers-common-7.7.2.jar),查询器包(lucene-queries-7.7.2.jar)拷到工程中。
      1.3 为测试还需要mysql驱动包与junit测试包。
    2. 步骤
      2.1 将数据库的数据查询出来进行测试
      2.2 将查询出来的数据构建索引
      2.3 通过查询索引获取目标对象
    3. demo开始
    //entity(实体类)
    public class Student {
        private int id;
        private String name;
        private String phone;
        private int score;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public int getScore() {
            return score;
        }
    
        public void setScore(int score) {
            this.score = score;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", phone='" + phone + '\'' +
                    ", score=" + score +
                    '}';
        }
    }
    
    //daoImplI(dao层实现查询方法)
    public class StudentDaoImpl extends BaseDao implements StudentDao {
        private String sql;
        @Override
        public List<Student> getStudentList() {
            sql = "select * from students";
            return baseQueryMultiple(sql, Student.class);
        }
    }
    
    //Test(测试类)
    import com.ljy.lucene.dao.StudentDao;
    import com.ljy.lucene.dao.impl.StudentDaoImpl;
    import com.ljy.lucene.po.Student;
    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.StoredField;
    import org.apache.lucene.document.TextField;
    import org.apache.lucene.index.*;
    import org.apache.lucene.search.*;
    import org.apache.lucene.store.Directory;
    import org.apache.lucene.store.FSDirectory;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.nio.file.FileSystems;
    import java.util.ArrayList;
    import java.util.List;
    
    public class LuceneTest {
        /**
         * 查询数据
         */
        @Test
        public void testQueryAll(){
            StudentDao dao = new StudentDaoImpl();
            List<Student> students = dao.getStudentList();
            for (Student stu: students
                 ) {
                System.out.println(stu);
            }
        }
        /**
         * 创建索引
         */
        @Test
        public void testCreateIndex() throws IOException {
            StudentDao dao = new StudentDaoImpl();
            List<Student> students = dao.getStudentList();
            //创建索引(将数据放入document对象,一条数据是一个document对象)
            List<Document> documents = new ArrayList<Document>();
            Document doc;
            for (Student stu: students
            ) {
                doc = new Document();
                //根据不同字段的需求,创建field对象(域(字段)的属性:分词、索引、存储)
                //id:不分词、不索引、要存储
                Field id = new StoredField("id",stu.getId());
                //name:要分词,要索引,要存储
                Field name = new TextField("name",stu.getName(), Field.Store.YES);//Field.Store.YES(决定是否需要存储)
                //score:要分词(区间),要索引,要存储
                Field score = new TextField("score",String.valueOf(stu.getScore()),Field.Store.YES);
                //phone:不分词,不索引,要存储
                Field phone = new StoredField("phone",stu.getPhone());
                doc.add(id);
                doc.add(name);
                doc.add(score);
                doc.add(phone);
                documents.add(doc);
            }
            System.out.println(documents);
    
            //用分词器对document进行分词得到索引
            //标准分词器(中英文分词不一样)
            Analyzer analyzer = new StandardAnalyzer();
            //创建索引存储的目录
            Directory directory = FSDirectory.open(FileSystems.getDefault().getPath("/Users/ljy/Documents/Idea/LuceneDemo/studentIndex"));
            //创建构造索引的配置对象
            IndexWriterConfig cfg = new IndexWriterConfig(analyzer);
            //开始构造索引写入到指定的目录
            IndexWriter indexWriter = new IndexWriter(directory,cfg);
            for (Document document: documents
                 ) {
                indexWriter.addDocument(document);
            }
            //关闭流
            indexWriter.close();
        }
    
        /**
         * 通过查询索引来找到目标对象
         */
        @Test
        public void testQueryIndex() throws IOException {
            //创建一个查询对象
            Query query = new TermQuery(new Term("name","w"));
            //执行搜索
            Directory directory = FSDirectory.open(FileSystems.getDefault().getPath("/Users/ljy/Documents/Idea/LuceneDemo/studentIndex"));
            //创建indexReader对象
            IndexReader indexReader = DirectoryReader.open(directory);
            //创建搜索对象
            IndexSearcher searcher = new IndexSearcher(indexReader);
            //执行搜索
            TopDocs topDocs = searcher.search(query, 10);
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;
            for (ScoreDoc doc : scoreDocs
                 ) {
                int docId = doc.doc;
                Document d = searcher.doc(docId);
                System.out.println(d);
            }
            indexReader.close();
        }
    }
    
    
    展开全文
  • Solr or Lucene全文检索实现原理

    万次阅读 2017-06-19 11:19:41
    Solr是一个独立企业级搜索应用服务器,它对外提供类似于Web-serviceAPI接口。用户可以通过http请求,向搜索引擎服务器提交一定... Lucene是apache软件基金会4 jakarta项目组一个子项目,是一个开放源代码的全文

    Solr是一个独立的企业级搜索应用服务器,它对外提供类似于Web-service的API接口。用户可以通过http请求,向搜索引擎服务器提交一定格式的XML文件,生成索引;也可以通过Http Get操作提出查找请求,并得到XML/Json格式的返回结果。采用Java5开发,基于Lucene。

      Lucene是apache软件基金会4 jakarta项目组的一个子项目,是一个开放源代码的全文检索引擎工具包,即它不是一个完整的全文检索引擎,而是一个全文检索引擎的架构,提供了完整的查询引擎和索引引擎,部分文本分析引擎(英文与德文两种西方语言)。

      其中Lucene全文检索的基本原理,跟郭军大牛讲的web搜索课程里的技术一致,采用分词,语义语法分析,向量空间模型等技术来实现,下面转载一篇讲的比较细致的博文备忘:http://www.cnblogs.com/guochunguang/articles/3641008.html

    一、总论

    根据http://lucene.apache.org/java/docs/index.html定义:

    Lucene是一个高效的,基于Java的全文检索库。

    所以在了解Lucene之前要费一番工夫了解一下全文检索。

    那么什么叫做全文检索呢?这要从我们生活中的数据说起。

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

    • 结构化数据:指具有固定格式或有限长度的数据,如数据库,元数据等。
    • 非结构化数据:指不定长或无固定格式的数据,如邮件,word文档等。

    当然有的地方还会提到第三种,半结构化数据,如XML,HTML等,当根据需要可按结构化数据来处理,也可抽取出纯文本按非结构化数据来处理。

    非结构化数据又一种叫法叫全文数据。

     

    按照数据的分类,搜索也分为两种:

    • 对结构化数据的搜索:如对数据库的搜索,用SQL语句。再如对元数据的搜索,如利用windows搜索对文件名,类型,修改时间进行搜索等。
    • 对非结构化数据的搜索:如利用windows的搜索也可以搜索文件内容,Linux下的grep命令,再如用Google和百度可以搜索大量内容数据。

    对非结构化数据也即对全文数据的搜索主要有两种方法:

    一种是顺序扫描法(Serial Scanning):所谓顺序扫描,比如要找内容包含某一个字符串的文件,就是一个文档一个文档的看,对于每一个文档,从头看到尾,如果此文档包含此字符串,则此文档为我们要找的文件,接着看下一个文件,直到扫描完所有的文件。如利用windows的搜索也可以搜索文件内容,只是相当的慢。如果你有一个80G硬盘,如果想在上面找到一个内容包含某字符串的文件,不花他几个小时,怕是做不到。Linux下的grep命令也是这一种方式。大家可能觉得这种方法比较原始,但对于小数据量的文件,这种方法还是最直接,最方便的。但是对于大量的文件,这种方法就很慢了。

    有人可能会说,对非结构化数据顺序扫描很慢,对结构化数据的搜索却相对较快(由于结构化数据有一定的结构可以采取一定的搜索算法加快速度),那么把我们的非结构化数据想办法弄得有一定结构不就行了吗?

    这种想法很天然,却构成了全文检索的基本思路,也即将非结构化数据中的一部分信息提取出来,重新组织,使其变得有一定结构,然后对此有一定结构的数据进行搜索,从而达到搜索相对较快的目的。

    这部分从非结构化数据中提取出的然后重新组织的信息,我们称之索引

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

     

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

     

    下面这幅图来自《Lucene in action》,但却不仅仅描述了Lucene的检索过程,而是描述了全文检索的一般过程。

     

     

    全文检索大体分两个过程,索引创建(Indexing)搜索索引(Search)

    • 索引创建:将现实世界中所有的结构化和非结构化数据提取信息,创建索引的过程。
    • 搜索索引:就是得到用户的查询请求,搜索创建的索引,然后返回结果的过程。

    于是全文检索就存在三个重要问题:

    1. 索引里面究竟存些什么?(Index)

    2. 如何创建索引?(Indexing)

    3. 如何对索引进行搜索?(Search)

    下面我们顺序对每个个问题进行研究。

     

    二、索引里面究竟存些什么

    索引里面究竟需要存些什么呢?

    首先我们来看为什么顺序扫描的速度慢:

    其实是由于我们想要搜索的信息和非结构化数据中所存储的信息不一致造成的。

    非结构化数据中所存储的信息是每个文件包含哪些字符串,也即已知文件,欲求字符串相对容易,也即是从文件到字符串的映射。而我们想搜索的信息是哪些文件包含此字符串,也即已知字符串,欲求文件,也即从字符串到文件的映射。两者恰恰相反。于是如果索引总能够保存从字符串到文件的映射,则会大大提高搜索速度。

    由于从字符串到文件的映射是文件到字符串映射的反向过程,于是保存这种信息的索引称为反向索引

    反向索引的所保存的信息一般如下:

    假设我的文档集合里面有100篇文档,为了方便表示,我们为文档编号从1到100,得到下面的结构

     

    左边保存的是一系列字符串,称为词典

    每个字符串都指向包含此字符串的文档(Document)链表,此文档链表称为倒排表(Posting List)。

    有了索引,便使保存的信息和要搜索的信息一致,可以大大加快搜索的速度。

    比如说,我们要寻找既包含字符串“lucene”又包含字符串“solr”的文档,我们只需要以下几步:

    1. 取出包含字符串“lucene”的文档链表。

    2. 取出包含字符串“solr”的文档链表。

    3. 通过合并链表,找出既包含“lucene”又包含“solr”的文件。

     

    看到这个地方,有人可能会说,全文检索的确加快了搜索的速度,但是多了索引的过程,两者加起来不一定比顺序扫描快多少。的确,加上索引的过程,全文检索不一定比顺序扫描快,尤其是在数据量小的时候更是如此。而对一个很大量的数据创建索引也是一个很慢的过程。

    然而两者还是有区别的,顺序扫描是每次都要扫描,而创建索引的过程仅仅需要一次,以后便是一劳永逸的了,每次搜索,创建索引的过程不必经过,仅仅搜索创建好的索引就可以了。

    这也是全文搜索相对于顺序扫描的优势之一:一次索引,多次使用。

     

    三、如何创建索引

    全文检索的索引创建过程一般有以下几步:

    第一步:一些要索引的原文档(Document)。

    为了方便说明索引创建过程,这里特意用两个文件为例:

    文件一:Students should be allowed to go out with their friends, but not allowed to drink beer.

    文件二:My friend Jerry went to school to see his students but found them drunk which is not allowed.

     

    第二步:将原文档传给分次组件(Tokenizer)。

    分词组件(Tokenizer)会做以下几件事情(此过程称为Tokenize):

    1. 将文档分成一个一个单独的单词。

    2. 去除标点符号。

    3. 去除停词(Stop word)。

    所谓停词(Stop word)就是一种语言中最普通的一些单词,由于没有特别的意义,因而大多数情况下不能成为搜索的关键词,因而创建索引时,这种词会被去掉而减少索引的大小。

    英语中挺词(Stop word)如:“the”,“a”,“this”等。

    对于每一种语言的分词组件(Tokenizer),都有一个停词(stop word)集合。

     

    经过分词(Tokenizer)后得到的结果称为词元(Token)。

    在我们的例子中,便得到以下词元(Token):

    “Students”,“allowed”,“go”,“their”,“friends”,“allowed”,“drink”,“beer”,“My”,“friend”,“Jerry”,“went”,“school”,“see”,“his”,“students”,“found”,“them”,“drunk”,“allowed”。

     

    第三步:将得到的词元(Token)传给语言处理组件(Linguistic Processor)。

    语言处理组件(linguistic processor)主要是对得到的词元(Token)做一些同语言相关的处理。

    对于英语,语言处理组件(Linguistic Processor)一般做以下几点:

    1. 变为小写(Lowercase)。

    2. 将单词缩减为词根形式,如“cars”到“car”等。这种操作称为:stemming。

    3. 将单词转变为词根形式,如“drove”到“drive”等。这种操作称为:lemmatization。

     

    Stemming 和 lemmatization的异同:

    • 相同之处:Stemming和lemmatization都要使词汇成为词根形式。
    • 两者的方式不同:
      • Stemming采用的是“缩减”的方式:“cars”到“car”,“driving”到“drive”。
      • Lemmatization采用的是“转变”的方式:“drove”到“drove”,“driving”到“drive”。
    • 两者的算法不同:
      • Stemming主要是采取某种固定的算法来做这种缩减,如去除“s”,去除“ing”加“e”,将“ational”变为“ate”,将“tional”变为“tion”。
      • Lemmatization主要是采用保存某种字典的方式做这种转变。比如字典中有“driving”到“drive”,“drove”到“drive”,“am, is, are”到“be”的映射,做转变时,只要查字典就可以了。
    • Stemming和lemmatization不是互斥关系,是有交集的,有的词利用这两种方式都能达到相同的转换。

     

    语言处理组件(linguistic processor)的结果称为词(Term)。

    在我们的例子中,经过语言处理,得到的词(Term)如下:

    “student”,“allow”,“go”,“their”,“friend”,“allow”,“drink”,“beer”,“my”,“friend”,“jerry”,“go”,“school”,“see”,“his”,“student”,“find”,“them”,“drink”,“allow”。

     

    也正是因为有语言处理的步骤,才能使搜索drove,而drive也能被搜索出来。

     

    第四步:将得到的词(Term)传给索引组件(Indexer)。

    索引组件(Indexer)主要做以下几件事情:

    1. 利用得到的词(Term)创建一个字典。

    在我们的例子中字典如下:

    Term

    Document ID

    student

    1

    allow

    1

    go

    1

    their

    1

    friend

    1

    allow

    1

    drink

    1

    beer

    1

    my

    2

    friend

    2

    jerry

    2

    go

    2

    school

    2

    see

    2

    his

    2

    student

    2

    find

    2

    them

    2

    drink

    2

    allow

    2

     

    2. 对字典按字母顺序进行排序。

     

    Term

    Document ID

    allow

    1

    allow

    1

    allow

    2

    beer

    1

    drink

    1

    drink

    2

    find

    2

    friend

    1

    friend

    2

    go

    1

    go

    2

    his

    2

    jerry

    2

    my

    2

    school

    2

    see

    2

    student

    1

    student

    2

    their

    1

    them

    2

     

    3. 合并相同的词(Term)成为文档倒排(Posting List)链表。

     

    在此表中,有几个定义:

    • Document Frequency 即文档频次,表示总共有多少文件包含此词(Term)。
    • Frequency 即词频率,表示此文件中包含了几个此词(Term)。

    所以对词(Term) “allow”来讲,总共有两篇文档包含此词(Term),从而词(Term)后面的文档链表总共有两项,第一项表示包含“allow”的第一篇文档,即1号文档,此文档中,“allow”出现了2次,第二项表示包含“allow”的第二个文档,是2号文档,此文档中,“allow”出现了1次。

    到此为止,索引已经创建好了,我们可以通过它很快的找到我们想要的文档。

    而且在此过程中,我们惊喜地发现,搜索“drive”,“driving”,“drove”,“driven”也能够被搜到。因为在我们的索引中,“driving”,“drove”,“driven”都会经过语言处理而变成“drive”,在搜索时,如果您输入“driving”,输入的查询语句同样经过我们这里的一到三步,从而变为查询“drive”,从而可以搜索到想要的文档。

     

     

    三、如何对索引进行搜索?

    到这里似乎我们可以宣布“我们找到想要的文档了”。

    然而事情并没有结束,找到了仅仅是全文检索的一个方面。不是吗?如果仅仅只有一个或十个文档包含我们查询的字符串,我们的确找到了。然而如果结果有一千个,甚至成千上万个呢?那个又是您最想要的文件呢?

    打开Google吧,比如说您想在微软找份工作,于是您输入“Microsoft job”,您却发现总共有22600000个结果返回。好大的数字呀,突然发现找不到是一个问题,找到的太多也是一个问题。在如此多的结果中,如何将最相关的放在最前面呢?

     

    当然Google做的很不错,您一下就找到了jobs at Microsoft。想象一下,如果前几个全部是“Microsoft does a good job at software industry…”将是多么可怕的事情呀。

    如何像Google一样,在成千上万的搜索结果中,找到和查询语句最相关的呢?

    如何判断搜索出的文档和查询语句的相关性呢?

    这要回到我们第三个问题:如何对索引进行搜索?

    搜索主要分为以下几步:

    第一步:用户输入查询语句。

    查询语句同我们普通的语言一样,也是有一定语法的。

    不同的查询语句有不同的语法,如SQL语句就有一定的语法。

    查询语句的语法根据全文检索系统的实现而不同。最基本的有比如:AND, OR, NOT等。

    举个例子,用户输入语句:lucene AND learned NOT hadoop。

    说明用户想找一个包含lucene和learned然而不包括hadoop的文档。

    第二步:对查询语句进行词法分析,语法分析,及语言处理。

    由于查询语句有语法,因而也要进行语法分析,语法分析及语言处理。

    1. 词法分析主要用来识别单词和关键字。

    如上述例子中,经过词法分析,得到单词有lucene,learned,hadoop, 关键字有AND, NOT。

    如果在词法分析中发现不合法的关键字,则会出现错误。如lucene AMD learned,其中由于AND拼错,导致AMD作为一个普通的单词参与查询。

    2. 语法分析主要是根据查询语句的语法规则来形成一棵语法树。

    如果发现查询语句不满足语法规则,则会报错。如lucene NOT AND learned,则会出错。

    如上述例子,lucene AND learned NOT hadoop形成的语法树如下:

     

    3. 语言处理同索引过程中的语言处理几乎相同。

    如learned变成learn等。

    经过第二步,我们得到一棵经过语言处理的语法树。

     

     

    第三步:搜索索引,得到符合语法树的文档。

    此步骤有分几小步:

    1. 首先,在反向索引表中,分别找出包含lucene,learn,hadoop的文档链表。
    2. 其次,对包含lucene,learn的链表进行合并操作,得到既包含lucene又包含learn的文档链表。
    3. 然后,将此链表与hadoop的文档链表进行差操作,去除包含hadoop的文档,从而得到既包含lucene又包含learn而且不包含hadoop的文档链表。
    4. 此文档链表就是我们要找的文档。

     

     

     

    第四步:根据得到的文档和查询语句的相关性,对结果进行排序。

    虽然在上一步,我们得到了想要的文档,然而对于查询结果应该按照与查询语句的相关性进行排序,越相关者越靠前。

    如何计算文档和查询语句的相关性呢?

    不如我们把查询语句看作一片短小的文档,对文档与文档之间的相关性(relevance)进行打分(scoring),分数高的相关性好,就应该排在前面。

    那么又怎么对文档之间的关系进行打分呢?

    这可不是一件容易的事情,首先我们看一看判断人之间的关系吧。

    首先看一个人,往往有很多要素,如性格,信仰,爱好,衣着,高矮,胖瘦等等。

    其次对于人与人之间的关系,不同的要素重要性不同,性格,信仰,爱好可能重要些,衣着,高矮,胖瘦可能就不那么重要了,所以具有相同或相似性格,信仰,爱好的人比较容易成为好的朋友,然而衣着,高矮,胖瘦不同的人,也可以成为好的朋友。

    因而判断人与人之间的关系,首先要找出哪些要素对人与人之间的关系最重要,比如性格,信仰,爱好。其次要判断两个人的这些要素之间的关系,比如一个人性格开朗,另一个人性格外向,一个人信仰佛教,另一个信仰上帝,一个人爱好打篮球,另一个爱好踢足球。我们发现,两个人在性格方面都很积极,信仰方面都很善良,爱好方面都爱运动,因而两个人关系应该会很好。

     

    我们再来看看公司之间的关系吧。

    首先看一个公司,有很多人组成,如总经理,经理,首席技术官,普通员工,保安,门卫等。

    其次对于公司与公司之间的关系,不同的人重要性不同,总经理,经理,首席技术官可能更重要一些,普通员工,保安,门卫可能较不重要一点。所以如果两个公司总经理,经理,首席技术官之间关系比较好,两个公司容易有比较好的关系。然而一位普通员工就算与另一家公司的一位普通员工有血海深仇,怕也难影响两个公司之间的关系。

    因而判断公司与公司之间的关系,首先要找出哪些人对公司与公司之间的关系最重要,比如总经理,经理,首席技术官。其次要判断这些人之间的关系,不如两家公司的总经理曾经是同学,经理是老乡,首席技术官曾是创业伙伴。我们发现,两家公司无论总经理,经理,首席技术官,关系都很好,因而两家公司关系应该会很好。

     

    分析了两种关系,下面看一下如何判断文档之间的关系了。

    首先,一个文档有很多词(Term)组成,如search, lucene, full-text, this, a, what等。

    其次对于文档之间的关系,不同的Term重要性不同,比如对于本篇文档,search, Lucene, full-text就相对重要一些,this, a , what可能相对不重要一些。所以如果两篇文档都包含search, Lucene,fulltext,这两篇文档的相关性好一些,然而就算一篇文档包含this, a, what,另一篇文档不包含this, a, what,也不能影响两篇文档的相关性。

    因而判断文档之间的关系,首先找出哪些词(Term)对文档之间的关系最重要,如search, Lucene, fulltext。然后判断这些词(Term)之间的关系。

     

    找出词(Term)对文档的重要性的过程称为计算词的权重(Term weight)的过程。

    计算词的权重(term weight)有两个参数,第一个是词(Term),第二个是文档(Document)。

    词的权重(Term weight)表示此词(Term)在此文档中的重要程度,越重要的词(Term)有越大的权重(Term weight),因而在计算文档之间的相关性中将发挥更大的作用。

    判断词(Term)之间的关系从而得到文档相关性的过程应用一种叫做向量空间模型的算法(Vector Space Model)。

     

    下面仔细分析一下这两个过程:

    1. 计算权重(Term weight)的过程。

    影响一个词(Term)在一篇文档中的重要性主要有两个因素:

    • Term Frequency (tf):即此Term在此文档中出现了多少次。tf 越大说明越重要。
    • Document Frequency (df):即有多少文档包含次Term。df 越大说明越不重要。

    容易理解吗?词(Term)在文档中出现的次数越多,说明此词(Term)对该文档越重要,如“搜索”这个词,在本文档中出现的次数很多,说明本文档主要就是讲这方面的事的。然而在一篇英语文档中,this出现的次数更多,就说明越重要吗?不是的,这是由第二个因素进行调整,第二个因素说明,有越多的文档包含此词(Term), 说明此词(Term)太普通,不足以区分这些文档,因而重要性越低。

    这也如我们程序员所学的技术,对于程序员本身来说,这项技术掌握越深越好(掌握越深说明花时间看的越多,tf越大),找工作时越有竞争力。然而对于所有程序员来说,这项技术懂得的人越少越好(懂得的人少df小),找工作越有竞争力。人的价值在于不可替代性就是这个道理。

    道理明白了,我们来看看公式:

     

     

    这仅仅只term weight计算公式的简单典型实现。实现全文检索系统的人会有自己的实现,Lucene就与此稍有不同。

     

    2. 判断Term之间的关系从而得到文档相关性的过程,也即向量空间模型的算法(VSM)。

    我们把文档看作一系列词(Term),每一个词(Term)都有一个权重(Term weight),不同的词(Term)根据自己在文档中的权重来影响文档相关性的打分计算。

    于是我们把所有此文档中词(term)的权重(term weight) 看作一个向量。

    Document = {term1, term2, …… ,term N}

    Document Vector = {weight1, weight2, …… ,weight N}

    同样我们把查询语句看作一个简单的文档,也用向量来表示。

    Query = {term1, term 2, …… , term N}

    Query Vector = {weight1, weight2, …… , weight N}

    我们把所有搜索出的文档向量及查询向量放到一个N维空间中,每个词(term)是一维。

    如图:

     

    我们认为两个向量之间的夹角越小,相关性越大。

    所以我们计算夹角的余弦值作为相关性的打分,夹角越小,余弦值越大,打分越高,相关性越大。

    有人可能会问,查询语句一般是很短的,包含的词(Term)是很少的,因而查询向量的维数很小,而文档很长,包含词(Term)很多,文档向量维数很大。你的图中两者维数怎么都是N呢?

    在这里,既然要放到相同的向量空间,自然维数是相同的,不同时,取二者的并集,如果不含某个词(Term)时,则权重(Term Weight)为0。

     

    相关性打分公式如下:

     

    举个例子,查询语句有11个Term,共有三篇文档搜索出来。其中各自的权重(Term weight),如下表格。

     

    t1

    t2

    t3

    t4

    t5

    t6

    t7

    t8

    t9

    t10

    t11

    D1

    0

    0

    .477

    0

    .477

    .176

    0

    0

    0

    .176

    0

    D2

    0

    .176

    0

    .477

    0

    0

    0

    0

    .954

    0

    .176

    D3

    0

    .176

    0

    0

    0

    .176

    0

    0

    0

    .176

    .176

    Q

    0

    0

    0

    0

    0

    .176

    0

    0

    .477

    0

    .176

     

    于是计算,三篇文档同查询语句的相关性打分分别为:

     

     

     

     

    于是文档二相关性最高,先返回,其次是文档一,最后是文档三。

    到此为止,我们可以找到我们最想要的文档了。

    说了这么多,其实还没有进入到Lucene,而仅仅是信息检索技术(Information retrieval)中的基本理论,然而当我们看过Lucene后我们会发现,Lucene是对这种基本理论的一种基本的的实践。所以在以后分析Lucene的文章中,会常常看到以上理论在Lucene中的应用。

    在进入Lucene之前,对上述索引创建和搜索过程所一个总结,如图:

    此图参照http://www.lucene.com.cn/about.htm中文章《开放源代码的全文检索引擎Lucene》

     

    1. 索引过程:

    1) 有一系列被索引文件

    2) 被索引文件经过语法分析和语言处理形成一系列词(Term)。

    3) 经过索引创建形成词典和反向索引表。

    4) 通过索引存储将索引写入硬盘。

    2. 搜索过程:

    a) 用户输入查询语句。

    b) 对查询语句经过语法分析和语言分析得到一系列词(Term)。

    c) 通过语法分析得到一个查询树。

    d) 通过索引存储将索引读入到内存。

    e) 利用查询树搜索索引,从而得到每个词(Term)的文档链表,对文档链表进行交,差,并得到结果文档。

    f) 将搜索到的结果文档对查询的相关性进行排序。

    g) 返回查询结果给用户。

     

    展开全文
  • Lucene全文检索入门

    2019-12-21 17:56:08
    什么是全文检索二、全文搜索的应用场景三、什么是Lucene四、Luence实现全文检索的流程1. 创建索引获得原始文档创建文档对象分析文档创建索引2. 查询索引3. 执行查询 Lucene (全文检索技术) 一.什么是全文检索 数据...
  • lucene全文检索

    2009-10-11 20:43:44
    本文描述了lucene全文检索的技术原理及实现思路,尤其针对java程序员在开发过程中实现检索功能提供了解决方案.
  • 全文检索”功能已经成为客户开发应用平台重要部分,中文搜索引擎已有多年发展历史。全文检索产品,开发出独立于原有数据库检索平台,利用该平台进行文件采集和搜索。此方式很好地解决了高端用户搜索需求...
  • Lucene全文检索技术

    2020-04-13 22:36:05
    搜索引擎三、什么是Lucene四、Lucene实现全文检索的流程1. 创建案引2、查询索引五、入门程序1.创建索引代码实现2.使用luke查看索引库中的内容3.查询索引库代码实现六、分析器1.查看分析器的分析效果2. IKAnalyze的...
  • 一、Lucene实现全文检索的流程
  • lucene开发文档,包括全文检索原理,lucene全文检索工具API介绍
  • Lucene是apache软件基金会4 jakarta项目组的一个子项目,是一...Lucene的目的是为软件开发人员提供一个简单易用的工具包,以方便的在目标系统中实现全文检索的功能,或者是以此为基础建立起完整的全文检索引擎。Luc...
  • Lucene的目的是为软件开发人员提供一个简单易用的工具包,以方便的在目标系统中实现全文检索的功能,或者是以此为基础建立起完整的全文检索引擎。  Lucene作为一个开放源代码全文检索工具包,具有优异的索引结构和...
  • Lucene 全文检索技术

    2017-08-29 15:41:06
    lucene: lucene是apache下的一个开源的免费的全文检索工具包 ...学习lucene的目的是为了更深层次的理解全文检索的原理, 全文检索技术 作用:  可以实现类似于百度和谷歌的搜索引擎 可以实现类似于京东,淘
  • Lucene全文检索框架

    2018-11-29 13:23:54
    Lucene全文检索框架 1、什么时Lucene? 是一个全文搜索框架,而不是应用产品,他只是一种工具让你能实现某些产品,并不像www.baidu.com拿来就能用 是apache组织一个用java实现的全文搜索引擎开源项目 2、...
  • Lucene是一个用Java 写的全文索引引擎工具包,可以方便的嵌入到各种应用中...全文检索的实现机制  Lucene 的API 接口设计的比较通用,输入输出结构都很像数据库的表==>记录==>字段,所以很多传统的应用的文...
  • 前几天投简历时候在技能栏里写了一个熟练使用Lucene全文检索系统。 当年确实用Lucene全文检索系统写了一个唐诗检索系统(实现了分页,高亮)。 前台用EasyUI实现的不是太完美,但是可以勉强使用。github地址 有...
  • lucene全文检索更新

    2014-04-02 16:21:36
    lucene全文检索demo,通过简单封装,使用着只需要调用方法并实现自己操作即可。
  • Lucene是apache软件基金会 jakarta项目组的一个子项目,是一个开放源...Lucene的目的是为软件开发人员提供一个简单易用的工具包,以方便的在目标系统中实现全文检索的功能,或者是以此为基础建立起完整的全文检索引擎。
  • Lucene全文检索引擎

    2017-08-04 15:42:13
     Lucene是apache软件基金会4 jakarta项目组的一个子项目,是一个...Lucene的目的是为软件开发人员提供一个简单易用的工具包,以方便的在目标系统中实现全文检索的功能,或者是以此为基础建立起完整的全文检索引擎...
  • lucene全文检索概述(二) 目录 lucene全文检索概述(二) 一.lucene中分词计算 二.分词器代码 1.创建一个mavenquickstart测试工程 2.添加依赖 1.引入需要各种依赖 2.依赖中提供各种lucene已经实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,365
精华内容 946
关键字:

lucene全文检索的实现