lucene基础学习

合集下载

lucene笔记-视频配套笔记

lucene笔记-视频配套笔记传智播客 Java学院传智.入云龙全文检索技术之Lucene1 课程计划1、什么全文检索数据类型:结构化数据和非结构化数据非结构化数据查询方法全文检索的概念2、什么是Lucene3、Lucene实现全文检索的流程(重点)4、Lucene的入门程序(重点)5、分析器Analyzer(重点)7、索引库的维护(重点)i. 索引库的增加索引ii. 删除索引iii. 修改索引8、索引库的查询(重点)i. 使用Query的子类查询ii. 使用QueryParser查询8、相关的排序2 什么全文检索结构化数据:数据的长度类型是固定的。

数据库中的数据非结构化数据:长度不固定格式不固定。

Word文档、excel、pdf、txt。

2.1 结构化数据的查询使用sql语句查询就可以2.2 非结构化数据的查询需求:在文件中找出包含java字符的文档。

传智播客 Java学院传智.入云龙2.2.1 实现方法1、目测2、顺序扫描。

如果文件量大的话比如说20G，顺序扫描会变的很慢。

3、非结构化的数据变结构化先从文件中找出文件所有的词汇，形成一个列表。

查询的时候直接查询列表，找到关键词后根据这词找到相应的文档。

一次创建多次使用。

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

2.4 全文检索应用领域1、搜索引擎，百度、谷歌2、站内搜索a) 微博搜索b) 论坛搜索3、电商搜索，搜索的是商品信息。

3 什么是Lucene3.1 Lucene的概念Lucene是apache下的一个开放源代码的全文检索引擎工具包。

提供了完整的查询引擎和索引引擎，部分文本分析引擎。

Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。

3.2 Lucene和搜索引擎的区别Lucene是一个工具包:需要进行编程才能实现全文检索的功能呢搜索引擎:一套独立运行的系统，提供了全文检索功能。

Lucene初级教程

Lucene初级教程2007-12-26 15:24 点击次数：0 次1 lucene简介1.1 什么是luceneLucene是一个全文搜索框架，而不是应用产品。

因此它并不像或者google Desktop那么拿来就能用，它只是提供了一种工具让你能实现这些产品。

2 lucene的工作方式lucene提供的服务实际包含两部分：一入一出。

所谓入是写入，即将你提供的源（本质是字符串）写入索引或者将其从索引中删除；所谓出是读出，即向用户提供全文搜索服务，让用户可以通过关键词定位源。

2.1写入流程源字符串首先经过analyzer处理，包括：分词，分成一个个单词；去除stopword（可选）。

将源中需要的信息加入Document的各个Field中，并把需要索引的Field索引起来，把需要存储的Field存储起来。

将索引写入存储器，存储器可以是内存或磁盘。

2.2读出流程用户提供搜索关键词，经过analyzer处理。

对处理后的关键词搜索索引找出对应的Document。

用户根据需要从找到的Document中提取需要的Field。

3 一些需要知道的概念3.1 analyzerAnalyzer是分析器，它的作用是把一个字符串按某种规则划分成一个个词语，并去除其中的无效词语，这里说的无效词语是指英文中的“of”、“the”，中文中的“的”、“地”等词语，这些词语在文章中大量出现，但是本身不包含什么关键信息，去掉有利于缩小索引文件、提高效率、提高命中率。

分词的规则千变万化，但目的只有一个：按语义划分。

这点在英文中比较容易实现，因为英文本身就是以单词为单位的，已经用空格分开；而中文则必须以某种方法将连成一片的句子划分成一个个词语。

具体划分方法下面再详细介绍，这里只需了解分析器的概念即可。

3.2 document用户提供的源是一条条记录，它们可以是文本文件、字符串或者数据库表的一条记录等等。

一条记录经过索引之后，就是以一个Document的形式存储在索引文件中的。

Lucene入门+实现

Lucene⼊门+实现Lucene简介详情见：（）lucene实现原理其实⽹上很多资料表明了，lucene底层实现原理就是倒排索引（invertedindex）。

那么究竟什么是倒排索引呢？经过Lucene分词之后，它会维护⼀个类似于“词条--⽂档ID”的对应关系，当我们进⾏搜索某个词条的时候，就会得到相应的⽂档ID。

不同于传统的顺排索引根据⼀个词，知道有哪⼏篇⽂章有这个词。

图解：Lucene在搜索前⾃⾏⽣成倒排索引，相⽐数据库中like的模糊搜索效率更⾼！Lucene 核⼼API索引过程中的核⼼类1. Document⽂档：他是承载数据的实体（他可以集合信息域Field），是⼀个抽象的概念，⼀条记录经过索引之后，就是以⼀个Document的形式存储在索引⽂件中的。

2. Field：Field 索引中的每⼀个Document对象都包含⼀个或者多个不同的域(Field),域是由域名(name)和域值(value)对组成，每⼀个域都包含⼀段相应的数据信息。

3. IndexWriter：索引过程的核⼼组件。

这个类⽤于创建⼀个新的索引并且把⽂档加到已有的索引中去，也就是写⼊操作。

4. Directroy：是索引的存放位置，是个抽象类。

具体的⼦类提供特定的存储索引的地址。

（FSDirectory 将索引存放在指定的磁盘中，RAMDirectory ·将索引存放在内存中。

）5. Analyzer：分词器，在⽂本被索引之前，需要经过分词器处理，他负责从将被索引的⽂档中提取词汇单元，并剔除剩下的⽆⽤信息（停⽌词汇），分词器⼗分关键，因为不同的分词器，解析相同的⽂档结果会有很⼤的不同。

Analyzer是⼀个抽象类，是所有分词器的基类。

搜索过程中的核⼼类1. IndexSearcher ：IndexSearcher 调⽤它的search⽅法，⽤于搜索IndexWriter 所创建的索引。

2. Term ：Term 使⽤于搜索的⼀个基本单元。

一步一步跟我学习lucene（1...

一步一步跟我学习lucene（1...自定义排序说明我们在做lucene搜索的时候，可能会需要排序功能，虽然lucene 内置了多种类型的排序，但是如果在需要先进行某些值的运算然后在排序的时候就有点显得无能为力了；要做自定义查询，我们就要研究lucene已经实现的排序功能，lucene的所有排序都是要继承FieldComparator,然后重写内部实现，这里以IntComparator为例子来查看其实现；IntComparator相关实现其类的声明为public static class IntComparator extends NumericComparator<Integer>,这里说明IntComparator接收的是Integer类型的参数，即只处理IntField的排序；IntComparator声明的参数为：[java] view plain copy1.private final int[] values;2.private int bottom; // Value of bottom of queue3.private int topValue;查看copy方法可知•values随着类初始化而初始化其长度•values用于存储NumericDocValues中读取到的内容具体实现如下：values的初始化[java] view plain copy1./**2.* Creates a new comparator based on {@link Integer#co mpare} for {@code numHits}.3.* When a document has no value for the field, {@code mi ssingValue} is substituted.4.*/5.public IntComparator(int numHits, String field, Integer mi ssingValue) {6.super(field, missingValue);7.values = new int[numHits];8.}values值填充(此为IntComparator的处理方式)[java] view plain copy1.@Override2.public void copy(int slot, int doc) {3.int v2 = (int) currentReaderValues.get(doc);4.// Test for v2 == 0 to save Bits.get method call for5.// the common case (doc has value and value is non-zero):6.if (docsWithField != null && v2 == 0 && !docsWithField. get(doc)) {7.v2 = missingValue;8.}9.10.values[slot] = v2;11.}这些实现都是类似的，我们的应用实现自定义排序的时候需要做的是对binaryDocValues或NumericDocValues的值进行计算，然后实现FieldComparator内部方法，对应IntComparator就是如上的值copy操作；然后我们需要实现compareTop、compareBottom和compare，IntComparator的实现为：[java] view plain copy1.@Override2.public int compare(int slot1, int slot2) {3.return pare(values[slot1], values[slot2]);4.}5.6.@Override7.public int compareBottom(int doc) {8.int v2 = (int) currentReaderValues.get(doc);9.// Test for v2 == 0 to save Bits.get method call for10.// the common case (doc has value and value is non-zero):11.if (docsWithField != null && v2 == 0 && !docsWithFi eld.get(doc)) {12.v2 = missingValue;13.}14.15.return pare(bottom, v2);16.}[java] view plain copy1.@Override2.public int compareTop(int doc) {3.int docValue = (int) currentReaderValues.get(doc);4.// Test for docValue == 0 to save Bits.get method call for5.// the common case (doc has value and value is non-zero):6.if (docsWithField != null && docValue == 0 && !docsWit hField.get(doc)) {7.docValue = missingValue;8.}9.return pare(topValue, docValue);10.}实现自己的FieldComparator要实现FieldComparator，需要对接收参数进行处理，定义处理值的集合，同时定义BinaryDocValues和接收的参数等，这里我写了一个通用的比较器，代码如下：[java] view plain copy1.package com.lucene.search;2.3.import java.io.IOException;4.5.import org.apache.lucene.index.BinaryDocValues;6.import org.apache.lucene.index.DocValues;7.import org.apache.lucene.index.LeafReaderContext;8.import org.apache.lucene.search.SimpleFieldComparator;9.10.import com.lucene.util.ObjectUtil;11.12./**自定义comparator13.* @author lenovo14.*15.*/16.public class SelfDefineComparator extends SimpleFie ldComparator<String> {17.private Object[] values;//定义的Object[]，同IntComparator18.private Object bottom;19.private Object top;20.private String field;21.private BinaryDocValues binaryDocValues;//接收的BinaryDocValues,同IntComparator中的NumericDocValues22.private ObjectUtil objectUtil;//这里为了便于拓展用接口代替抽象类23.private Object[] params;//接收的参数24.25.public SelfDefineComparator(String field, int numHits, Object[] params,ObjectUtil objectUtil) {26.values = new Object[numHits];27.this.objectUtil = objectUtil;28.this.field = field;29.this.params = params;30.}31.32.@Override33.public void setBottom(int slot) {34.this.bottom = values[slot];35.}36.37.@Override38.public int compareBottom(int doc) throws IOExcepti on {39.Object distance = getValues(doc);40.return (bottom.toString()).compareTo(distance.toStrin g());41.}42.43.@Override44.public int compareTop(int doc) throws IOException {45.Object distance = getValues(doc);46.return pareTo(top,distance);47.}48.49.@Override50.public void copy(int slot, int doc) throws IOException {51.values[slot] = getValues(doc);52.}53.54./**��ȡdocID��Ӧ��value55.* @param doc56.* @return57.*/58.private Object getValues(int doc) {59.Object instance = objectUtil.getValues(doc,params,bin aryDocValues) ;60.return instance;61.}62.63.@Override64.protected void doSetNextReader(LeafReaderContext context)65.throws IOException {66.binaryDocValues = DocValues.getBinary(context.reade r(), field);//context.reader().getBinaryDocValues(field);67.}68.69.@Override70.public int compare(int slot1, int slot2) {71.return pareTo(values[slot1],values[slot2]);72.}73.@Override74.public void setTopValue(String value) {75.this.top = value;76.}77.78.@Override79.public String value(int slot) {80.return values[slot].toString();81.}82.83.}其中ObjectUtil是一个接口，定义了值处理的过程，最终是要服务于comparator的compare方法的，同时对comparator的内部compare方法进行了定义ObjectUtil接口定义如下：[java] view plain copy1.package com.lucene.util;2.3.import org.apache.lucene.index.BinaryDocValues;4.5.public interface ObjectUtil {6.7./**自定义的获取处理值的方法8.* @param doc9.* @param params10.* @param binaryDocValues11.* @return12.*/13.public abstract Object getValues(int doc, Object[] par ams, BinaryDocValues binaryDocValues) ;14.15./**compare比较器实现16.* @param object17.* @param object218.* @return19.*/20.public abstract int compareTo(Object object, Object object2);21.22.}我们不仅要提供比较器和comparator，同时还要提供接收用户输入的FiledComparatorSource[java] view plain copy1.package com.lucene.search;2.3.import java.io.IOException;4.5.import org.apache.lucene.search.FieldComparator;6.import org.apache.lucene.search.FieldComparatorSource;7.8.import com.lucene.util.ObjectUtil;9.10./**comparator用于接收用户原始输入，继承自FieldComparatorSource实现了自定义comparator的构建11.* @author lenovo12.*13.*/14.public class SelfDefineComparatorSource extends Fie ldComparatorSource {15.private Object[] params;//接收的参数16.private ObjectUtil objectUtil;//这里为了便于拓展用接口代替抽象类17.18.public Object[] getParams() {19.return params;20.}21.22.public void setParams(Object[] params) {23.this.params = params;24.}25.26.public ObjectUtil getObjectUtil() {27.return objectUtil;28.}29.30.public void setObjectUtil(ObjectUtil objectUtil) {31.this.objectUtil = objectUtil;32.}33.34.public SelfDefineComparatorSource(Object[] params, ObjectUtil objectUtil) {35.super();36.this.params = params;37.this.objectUtil = objectUtil;38.}39.40.@Override41.public FieldComparator<?> newComparator(String fie ldname, int numHits,42.int sortPos, boolean reversed) throws IOException {43.//实际比较由SelfDefineComparator实现44.return new SelfDefineComparator(fieldname, numHit s, params, objectUtil);45.}46.}相关测试程序，这里我们模拟一个StringComparator，对String 值进行排序[java] view plain copy1.package com.lucene.search;2.3.import org.apache.lucene.analysis.Analyzer;4.import org.apache.lucene.analysis.standard.StandardAnal yzer;5.import org.apache.lucene.document.BinaryDocValuesFiel d;6.import org.apache.lucene.document.Document;7.import org.apache.lucene.document.Field;8.import org.apache.lucene.document.StringField;9.import org.apache.lucene.index.DirectoryReader;10.import org.apache.lucene.index.IndexReader;11.import org.apache.lucene.index.IndexWriter;12.import org.apache.lucene.index.IndexWriterConfig;13.import org.apache.lucene.index.IndexWriterConfig.Op enMode;14.import org.apache.lucene.index.Term;15.import org.apache.lucene.search.IndexSearcher;16.import org.apache.lucene.search.MatchAllDocsQuery;17.import org.apache.lucene.search.Query;18.import org.apache.lucene.search.ScoreDoc;19.import org.apache.lucene.search.Sort;20.import org.apache.lucene.search.SortField;21.import org.apache.lucene.search.TermQuery;22.import org.apache.lucene.search.TopDocs;23.import org.apache.lucene.search.TopFieldDocs;24.import org.apache.lucene.store.RAMDirectory;25.import org.apache.lucene.util.BytesRef;26.27.import com.lucene.util.CustomerUtil;28.import com.lucene.util.ObjectUtil;29.import com.lucene.util.StringComparaUtil;30.31./**32.*33.* @author 吴莹桂34.*35.*/36.public class SortTest {37.public static void main(String[] args) throws Exceptio n {38.RAMDirectory directory = new RAMDirectory();39.Analyzer analyzer = new StandardAnalyzer();40.IndexWriterConfig indexWriterConfig = new IndexWri terConfig(analyzer);41.indexWriterConfig.setOpenMode(OpenMode.CREATE_ OR_APPEND);42.IndexWriter indexWriter = new IndexWriter(directory,indexWriterConfig);43.addDocument(indexWriter, "B");44.addDocument(indexWriter, "D");45.addDocument(indexWriter, "A");46.addDocument(indexWriter, "E");mit();48.indexWriter.close();49.IndexReader reader = DirectoryReader.open(directory) ;50.IndexSearcher searcher = new IndexSearcher(reader);51.Query query = new MatchAllDocsQuery();52.ObjectUtil util = new StringComparaUtil();53.Sort sort = new Sort(new SortField("name",new SelfD efineComparatorSource(new Object[]{},util),true));54.TopDocs topDocs = searcher.search(query, Integer.MA X_VALUE, sort);55.ScoreDoc[] docs = topDocs.scoreDocs;56.for(ScoreDoc doc : docs){57.Document document = searcher.doc(doc.doc);58.System.out.println(document.get("name"));59.}60.}61.62.private static void addDocument(IndexWriter writer,S tring name) throws Exception{63.Document document = new Document();64.document.add(new StringField("name",name,Field.Sto re.YES));65.document.add(new BinaryDocValuesField("name", new BytesRef(name.getBytes())));66.writer.addDocument(document);67.}68.}其对应的ObjectUtil实现如下：[java] view plain copy1.package com.lucene.util;2.3.import org.apache.lucene.index.BinaryDocValues;4.import org.apache.lucene.util.BytesRef;5.6.public class StringComparaUtil implements ObjectUtil {7.8.@Override9.public Object getValues(int doc, Object[] params,10.BinaryDocValues binaryDocValues) {11.BytesRef bytesRef = binaryDocValues.get(doc);12.String value = bytesRef.utf8T oString();13.return value;14.}15.16.@Override17.public int compareTo(Object object, Object object2) {18.// TODO Auto-generated method stub19.return object.toString().compareTo(object2.toString());20.}21.22.}。

Lucene搜索入门教程

Lucene搜索入门教程1.了解搜索技术1.1搜索引擎搜索引擎是指根据一定的策略、运用特定的计算机程序从互联网上搜集信息,在对信息进行组织和处理后,为用户提供检索服务,将用户检索相关的信息展示给用户的系统。

搜索引擎包括全文索引、目录索引、元搜索引擎、垂直搜索引擎、集合式搜索引擎、门户搜索引擎与免费链接列表等。

搜索引擎的原理可以看到搜索引擎的功能主要是三部分:●爬行和抓取数据（爬虫多用python来编写、但是java也能实现）●对数据对预处理（提取文字、中文分词、建立倒排索引）提供搜索功能(用户输入关键词后、去索引库搜索数据)在上述三个步骤中,java要解决的往往是后两个步骤：数据处理和搜索。

那么,我们之前学习的mysql知识也能实现数据的存储和搜索,为什么还要学新的东西呢？1.2传统数据库搜索的问题要实现类似百度的复杂搜索,或者京东的商品搜索,如果使用传统的数据库存储数据,那么会存在一系列的问题：●数据库数据单表存储能力有限，无法存储海量数据●解决大数据，可以进行分库分表。

但是分库分表会增加业务复杂度●搜索只能通过模糊匹配，效率极低●模糊搜索可能导致全表扫描,效率非常差在这里，比较棘手的其实是第二个问题：查询效率低，类似百度和京东这样的网站，对性能要求极高。

如果用户点击搜索需要很久才能拿到数据，没人愿意一直等待下去。

那么问题来了:如何才能提高模糊搜索时的效率呢？答案是：倒排索引技术1.3什么是倒排索引倒排索引是一种存储数据的方式,与传统查找有很大区别：●传统查找:采用数据按行存储,查找时逐行扫描,或者根据索引查找,然后匹配搜索条件,效率较差.概括来讲是先找到文档,然后看是否匹配.传统线性查找一个10MB的word文件，查找关键字如果在文档最后,大约3秒钟●倒排索引：首先对文档数据按照id进行索引存储,然后对文档中的数据分词,记录对词条进行索引，并记录词条在文档中出现的位置。

这样查找时只要找到了词条，就找到了对应的文档。

Lucene入门与使用

中国Lucene入门与使用本文主要面向具体使用，适用于已熟悉java编程的lucene初学者。

1. Lucene的简介1.1 Lucene 历史org.apache.lucene包是纯java语言的全文索引检索工具包。

Lucene的作者是资深的全文索引/检索专家，最开始发布在他本人的主页上，2001年10月贡献给APACHE，成为APACHE基金jakarta的一个子项目。

目前，lucene广泛用于全文索引/检索的项目中。

lucene也被翻译成C#版本，目前发展为（不过最近好象有流产的消息）。

1.2 Lucene 原理lucene的检索算法属于索引检索，即用空间来换取时间，对需要检索的文件、字符流进行全文索引，在检索的时候对索引进行快速的检索，得到检索位置，这个位置记录检索词出现的文件路径或者某个关键词。

在使用数据库的项目中，不使用数据库进行检索的原因主要是：数据库在非精确查询的时候使用查询语言“like %keyword%”，对数据库进行查询是对所有记录遍历，并对字段进行“%keyword%”匹配，在数据库的数据庞大以及某个字段存储的数据量庞大的时候，这种遍历是致命的，它需要对所有的记录进行匹配查询。

因此，lucene主要适用于文档集的全文检索，以及海量数据库的模糊检索，特别是对数据库的xml或者大数据的字符类型。

2．Lucene的下载和配置2.1 Lucene的下载lucene在jakarta项目中的发布主页：/lucene/docs/index.html。

以下主要针对windows 用户，其它用户请在上面的地址中查找相关下载。

lucene的.jar包的下载（包括.jar和一个范例demo）：/jakarta/lucene/binaries/lucene-1.4-fina l.ziplucene的源代码下载：/mirrors/apache/jakarta/lucene/source/lucene-1 .4-final-src.ziplucene的api地址：/lucene/docs/api/index.html本文使用lucene版本：lucene-1.4-final.jar。

一步一步跟我学习lucene（1...

一步一步跟我学习lucene（1...这两天加班，不能兼顾博客的更新，请大家见谅。

有时候我们创建完索引之后，数据源可能有更新的内容，而我们又想像数据库那样能直接体现在查询中，这里就是我们所说的增量索引。

对于这样的需求我们怎么来实现呢？lucene内部是没有提供这种增量索引的实现的；这里我们一般可能会想到，将之前的索引全部删除，然后进行索引的重建。

对于这种做法，如果数据源的条数不是特别大的情况下倒还可以，如果数据源的条数特别大的话，势必会造成查询数据耗时，同时索引的构建也是比较耗时的，几相叠加，势必可能造成查询的时候数据缺失的情况，这势必严重影响用户的体验；比较常见的增量索引的实现是：•设置一个定时器，定时从数据源中读取比现有索引文件中新的内容或是数据源中带有更新标示的数据。

•对数据转换成需要的document并进行索引这样做较以上的那种全删除索引然后重建的好处在于：•数据源查询扫描的数据量小•相应的更新索引的条数也少，减少了大量的IndexWriter的commit和close这些耗时操作以上解决了增量的问题，但是实时性的问题还是存在的：•索引的变更只有在IndexWriter的commit执行之后才可以体现出来那么我们怎样对实时性有个提升呢，大家都知道lucene索引可以以文件索引和内存索引两种方式存在，相较于文件索引，内存索引的执行效率要高于文件索引的构建，因为文件索引是要频繁的IO操作的；结合以上的考虑，我们采用文件索引+内存索引的形式来进行lucene 的增量更新；其实现机制如下：•定时任务扫描数据源的变更•对获得的数据源列表放在内存中•内存中的document达到数量限制的时候，以队列的方式删除内存中的索引，并将之添加到文件索引•查询的时候采用文件+内存索引联合查询的方式以达到NRT效果定时任务调度器java内置了TimerT ask，此类是可以提供定时任务的，但是有一点就是TimerTask的任务是无状态的，我们还需要对任务进行并行的设置；了解到quartz任务调度框架提供了有状态的任务StatefulJob，即在本次调度任务没有执行完毕时，下次任务不会执行；常见的我们启动一个quartz任务的方式如下：[java] view plain copy1.Date runTime = DateBuilder.evenSecondDate(new Date()) ;2.StdSchedulerFactory sf = new StdSchedulerFactory();3.Scheduler scheduler = sf.getScheduler();4.JobDetail job = JobBuilder.newJob(XXX.class).build();5.Trigger trigger = TriggerBuilder.newTrigger().startAt(runTi me).withSchedule(SimpleScheduleBuilder.simpleSchedule().withI ntervalInSeconds(3).repeatForever()).forJob(job).build();6.scheduler.scheduleJob(job, trigger);7.8.scheduler.start();</span>以上我们是设置了每三秒执行一次定时任务，而任务类是XXX 任务类通用方法这里我定义了一个XXX的父类，其定义如下：[java] view plain copy1.package com.chechong.lucene.indexcreasement;2.3.import java.util.List;4.import java.util.TimerTask;5.6.import org.apache.lucene.store.RAMDirectory;7.import org.quartz.Job;8.import org.quartz.StatefulJob;9.10./**有状态的任务：串行执行，即不允许上次执行没有完成即开始本次如果需要并行给接口改为Job即可11.* @author lenovo12.*13.*/14.public abstract class BaseInCreasementIndex implem ents StatefulJob {15./**16.* 内存索引17.*/18.private RAMDirectory ramDirectory;19.public BaseInCreasementIndex() {20.}21.public BaseInCreasementIndex(RAMDirectory ramDire ctory) {22.super();23.this.ramDirectory = ramDirectory;24.}25.26./**更新索引27.* @throws Exception28.*/29.public abstract void updateIndexData() throws Excep tion;30./**消费数据31.* @param list32.*/33.public abstract void consume(List list) throws Excepti on;34.}任务类相关实现,以下方法是获取待添加索引的数据源XXXInCreasementIndex[java] view plain copy1.@Override2.public void execute(JobExecutionContext context) throw s JobExecutionException {3.try {4.XXXInCreasementIndex index = new XXXInCreasementIn dex(Constants.XXX_INDEX_PATH, XXXDao.getInstance(), RamDir ectoryControl.getRAMDireactory());5.index.updateIndexData();6.} catch (Exception e) {7.// TODO Auto-generated catch block8.e.printStackTrace();9.}10.}[java] view plain copy1.@Override2.public void updateIndexData() throws Exception {3.int maxBeanID = SearchUtil.getLastIndexBeanID();4.System.out.println(maxBeanID);5.List<XXX> sources = XXXDao.getListInfoBefore(maxBeanID);、、6.if (sources != null && sources.size() > 0) {7.this.consume(sources);8.}9.}这里，XXX代表我们要获取数据的实体类对象consume方法主要是做两件事：•数据存放到内存索引•判断内存索引数量，超出限制的话以队列方式取出超出的数量，并将之存放到文件索引[java] view plain copy1.@Override2.public void consume(List list) throws Exception {3.IndexWriter writer = RamDirectoryControl.getRAMIndex Writer();4.RamDirectoryControl.consume(writer,list);5.}上边我们将内存索引和队列的实现放在了RamDirectoryControl 中内存索引控制器首先我们对内存索引的IndexWriter进行初始化，在初始化的时候需要注意先执行一次commit，否则会提示no segments的异常[java] view plain copy1.private static IndexWriter ramIndexWriter;2.private static RAMDirectory directory;3.static{4.directory = new RAMDirectory();5.try {6.ramIndexWriter = getRAMIndexWriter();7.} catch (Exception e) {8.// TODO Auto-generated catch block9.e.printStackTrace();10.}11.}12.public static RAMDirectory getRAMDireactory(){13.return directory;14.}15.public static IndexSearcher getIndexSearcher() throw s IOException{16.IndexReader reader = null;17.IndexSearcher searcher = null;18.try {19.reader = DirectoryReader.open(directory);20.} catch (IOException e) {21. e.printStackTrace();22.}23.searcher = new IndexSearcher(reader);24.return searcher;25.}26./**单例模式获取ramIndexWriter27.* @return28.* @throws Exception29.*/30.public static IndexWriter getRAMIndexWriter() throw s Exception{31.if(ramIndexWriter == null){32.synchronized (IndexWriter.class) {33.Analyzer analyzer = new IKAnalyzer();34.IndexWriterConfig iwConfig = new IndexWriterConfig (analyzer);35.iwConfig.setOpenMode(OpenMode.CREATE_OR_APPE ND);36.try {37.ramIndexWriter = new IndexWriter(directory, iwConfig);mit();39.ramIndexWriter.close();40.iwConfig = new IndexWriterConfig(analyzer);41.iwConfig.setOpenMode(OpenMode.CREATE_OR_APPE ND);42.ramIndexWriter = new IndexWriter(directory, iwConfig);43.} catch (IOException e) {44.// TODO Auto-generated catch block45. e.printStackTrace();46.}47.}48.}49.50.return ramIndexWriter;51.}定义一个获取内存索引中数据条数的方法[java] view plain copy1./**根据查询器、查询条件、每页数、排序条件进行查询2.* @param query 查询条件3.* @param first 起始值4.* @param max 最大值5.* @param sort 排序条件6.* @return7.*/8.public static TopDocs getScoreDocsByPerPageAndSortFi eld(IndexSearcher searcher,Query query, int first,int max, Sort s ort){9.try {10.if(query == null){11.System.out.println(" Query is null return null ");12.return null;13.}14.TopFieldCollector collector = null;15.if(sort != null){16.collector = TopFieldCollector.create(sort, first+max, fal se, false, false);17.}else{18.SortField[] sortField = new SortField[1];19.sortField[0] = new SortField("createTime",SortField.Ty pe.STRING,true);20.Sort defaultSort = new Sort(sortField);21.collector = TopFieldCollector.create(defaultSort,first+ max, false, false, false);22.}23.searcher.search(query, collector);24.return collector.topDocs(first, max);25.} catch (IOException e) {26.// TODO Auto-generated catch block27.}28.return null;29.}此方法返回结果为T opDocs，我们根据TopDocs的totalHits来获取内存索引中的数据条数，以此来鉴别内存占用，防止内存溢出。

lucene_入门整理

1.概述Lucene是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎。

Lucene以其方便使用、快速实施以及灵活性受到广泛的关注。

它可以方便地嵌入到各种应用中实现针对应用的全文索引、检索功能，本总结使用lucene--2.3.2。

2.lucene 的包结构1、org.apache.lucene.analysis对需要建立索引的文本进行分词、过滤等操作, 语言分析器，主要用于的切词Analyzer是一个抽象类，管理对文本内容的切分词规则。

2、org.apache.lucene.analysis.standard是标准分析器3、org.apache.lucene.document提供对Document和Field的各种操作的支持。

索引存储时的文档结构管理，类似于关系型数据库的表结构。

Document相对于关系型数据库的记录对象，Field主要负责字段的管理。

4、org.apache.lucene.index是最重要的包，用于向Lucene提供建立索引时各种操作的支持。

索引管理，包括索引建立、删除等。

索引包是整个系统核心，全文检索的根本就是为每个切出来的词建索引，查询时就只需要遍历索引，而不需要去正文中遍历，从而极大的提高检索效率。

5、org.apache.lucene.queryParser提供检索时的分析支持。

查询分析器，实现查询关键词间的运算，如与、或、非等。

6、org.apache.lucene.search 负责检索。

检索管理，根据查询条件，检索得到结果。

7、org.apache.lucene.store提供对索引存储的支持。

数据存储管理，主要包括一些底层的I/0操作。

8、org.apache.lucene.util提供一些常用工具类和常量类的支持3.索引文件格式a).fnm格式包含了Document中所有field名称b).fdt与.fdx格式.fdt文件用于存储具有Store.YES属性的Field的数据；.fdx是一个索引，用于存储Document在.fdt中的位置。

Lucene学习笔记(二)

还有一种是CJKAnalyzer类(需要单独下载JAR包)是进行二分法分词，对于上面的"中华人民共和国"，会被分成"中华"、"华人"、"人民"、"民共"、"共和"、"和国"
还有一种是MMAnalyzer类(需要单独下载JAR包)是词典分词中的极易分词器，将会分成我们期望的"中华"、"人民"、"共和国"，对于词典分词还有一种分词器是庖丁分词器(也要单独下载，庖丁分词和极易分词都可以很好的解决中文索引问题)
private Query query;
//缺省构造方法
public SearchMachine() {
// 初始化搜索器：并指定保存索引的目录
indexSearcher = new IndexSearcher(Constants.INDEX_DESC_PATH);
}
}
2.4 开始搜索：具体代码后边会讲解
public class SearchMachine {
// 创佳搜索器对象
private IndexSearcher indexSearcher;
// 创建Lucene格式的查询条件对象
//搜索结束时间
Date end = new Date();
System.out.println("搜索完成，用时： " + (end.getTime() - start.getTime()) + "毫秒!");
//返回结果
return hits;
}
//打印结果集

Lucene学习笔记（一）

Lucene学习笔记（一）申明：此文章中说到的分词器就是分析器中的一种，不要理解错了。

注意：以下内容中有没有解释留待以后章节解释的有：1. writer.optimize();对索引进行优化一、Lucene基础：大纲： 1. 信息获取与搜索引擎的发展2. Lucene的历史3. 建立索引(索引库)与搜索1. 信息获取技术包含：信息的表示、存储、组织和对信息的访问方法。

信息的表示和组织是为了用户更容易的访问到需要的信息。

1.1 一般来说，信息获取的流程分为以下四步：1.1.1 获取信息之前，要构建文本数据库，即将来需要进行检索的数据(被检索的数据)1.1.2 需要建立文档的索引，通过文档索引可以检索到对应的文本数据库中对应的数据；有很多建立文档索引的方法，但是用的最多的还是"倒排索引技术"，其中Lucene就是采用的这种建立文档索引的技术1.1.3 完成文档索引的建立之后就可以进行检索了，此时需要用户提供一个查询关键字，该关键字将被分析然后利用一些文本处理技术进行处理，当然也可以根据具体的需求进行一系列的处理。

1.1.4 查询关键字准备好之后，进入查询，根据查询关键字可以与文档索引中的数据得到匹配进而得到文本数据库中与匹配上的文档索引对应的数据，然后反馈给用户，当然反馈之前我们可以进行排序等处理，让最接近用户需求的信息排在最前面显示2. 搜索引擎：分为"全文搜索引擎(FullT ext Search Engine)"和"分类目录(Directory)"2.1 全文搜索引擎：通过一个叫网络机器人(Spider)或者叫网络蜘蛛(Crawlers)的软件,自动分析网络上的各种连接并且获取网页信息内容而且会按照规则加以分析整理，记入数据库。

优缺点：使用关键字和一定的语法；全文搜索引擎因为依靠网络机器人等收集数据，所以数据库的容量非常庞大，但是它的查询往往不准确。

lucene学习

lucene学习1. 基本概念信息检索(IR)是指文档搜索、文档内信息搜索或者文档相关的元数据搜索等操作。

文档：用于搜索的内容部件。

文档过滤器:将文本格式信息从原始内容中提取出来，便于后期建立搜索引擎文档。

如Tika，与数据库的内容连接，DBSight、Hibernate Search、LuSQL、Compass和Oracle/Lucene集成项目。

词汇单元：即分词。

词干提取器，如Snowball。

搜索质量主要由查准率(Precision)和查全率(Recall)来衡量。

[1]P13 语法检查器: Lucene的 contrib目录提供了两个模块完成此功能。

查询对象: Lucene提供了一个称之为查询解析器(QueryParser),用它可以根据通用查询语法将用户输入的文本处理成查询对象。

查询搜索：�搜�检索索引并返回与�搜�语句匹配的文档，结果返回时按照�搜�请求来排序。

搜索查询组件涵盖了搜索引擎内部复杂的工作机制，Lucene正是如此，它为你完成这一切。

倒排索引：inverted index常见的搜索理论模型有如下3种。

■ 纯布尔模型（Pure Boolean model) 文档不管是否匹配查询请求，都不会被评分.在该模型下，匹配文档与评分不相关，也是无序的；一条查询仅获取所有匹配文档集合的一个子集。

■ 向量空间模型（Vector space model)查询语句和文档都是高维空间的向量模型，这里每一个独立的项都是一个维度。

查询语句和文档之间的相关性或相似性由各自向量之间的距离计算得到.■概率模型（Probabilistic model)在该模型中，采用全概率方法来计算文档和查询语句的匹配概率。

Lucene在实现上采用向量空间模型和纯布尔模型，并能针对具体搜索让你决定采用哪种模型。

最后，Lucene返回的文档结果必须用比较经济的方式展现给用户。

搜索范围：涉及分布式搜索，Apache Lucene项目下的Solr和Nutch项目提供了对索引拆分和复制的支持，另Katta和Elastic search。

《Lucene_分析与应用》学习笔记

《Lucene_分析与应⽤》学习笔记《Lucene 分析与应⽤》学习笔记⼀、搜索引擎与Lucene（1）搜索引擎：⽹络全⽂搜索引擎(baidu,google,live)，⽬录搜索引擎(yahoo)和元搜索引擎。

（2）Lucene 并不是⼀个完整的全⽂检索应⽤，但却是⼀个可靠性⾼、易于扩展的全⽂检索⼯具包，可以嵌⼊到各种应⽤中，为应⽤提供全⽂检索功能。

（3）Lucene 具有突出的优点：①⾃定义的索引⽂件格式使得Lucene很容易嵌⼊到应⽤系统中，并部署在不同的平台上。

②使⽤MDA（模型驱动架构）规则设计，使得Lucene易于扩展。

（4）其它搜索引擎开发包①MG4J②WebLucene③Woogle(5)Lucene 的系统架构<1>标引过程IndexWriter ①创建Lucene索引writer.setUseCompoundFile(false);②⾮复合式索引模式writer.setMergeFactor(2);③设置合并频率为2Document ④建⽴Document对象document.add(newField);⑤索引⽂件内容writer.addDocumnet(document);⑥将Document对象加到索引中writer.close();⑦关闭索引，完成索引建⽴过程说明：②使⽤复合式索引的优点是可以减少⽂件的IO操作。

(即设为true或默认情况)③内存中的segments数量达到指定数量时（默认为10）会将其合并为⼀个Segments。

⑦执⾏关闭索引的close()⽅法时，真正完成了将索引⽂件写⼊磁盘的操作。

.fdt包含各个域数据（field的特性）信息。

.fdx它是指向.fdt⽂件的指针。

填写的是.fdt⽂件中每个⽂档的域数据信息的起始位置。

.fnm各个域的名字信息。

（6）查询IndexSearch①打开索引queryParser.parse(keyword);②对KeyWord解析searcher.search(query)③检索索引（7）Lucene采⽤的索引结构对⽐全⽂扫描、签名⽂件、后缀树等索引结构，Lucene为提供准确快速的查询，采⽤倒排⽂件作为它的索引结构。

Lucene基本使用介绍

Lucene基本使用介绍今天用了下Lucene，发现网上虽然也有不少介绍它的文档，不过很多都偏向介绍概念呀、设计或者是一些更为深入的东西，对于其入门使用的介绍性的文档并不多，就写了这么一篇。

Lucene基本使用介绍本文的目的不在于对Lucene的概念和设计这些进行介绍，仅在于介绍怎么样去使用Lucene来达到自己想要的几种常见的全文检索的需求，如果想深入了解Lucene的话本文不会带给你什么收获的。

看完本文后想更深入的了解Lucene请访问：一.概述随着系统信息的越来越多，怎么样从这些信息海洋中捞起自己想要的那一根针就变得非常重要了，全文检索是通常用于解决此类问题的方案，而Lucene 则为实现全文检索的工具，任何应用都可通过嵌入它来实现全文检索。

二.环境搭建从上下载最新版本的lucene.jar，将此jar作为项目的build path，那么在项目中就可以直接使用lucene了。

三.使用说明3.1.基本概念这里介绍的主要为在使用中经常碰到一些概念，以大家都比较熟悉的数据库来进行类比的讲解，使用Lucene进行全文检索的过程有点类似数据库的这个过程，table---→查询相应的字段或查询条件----→返回相应的记录，首先是IndexWriter，通过它建立相应的索引表，相当于数据库中的table，在构建此索引表时需指定的为该索引表采用何种方式进行构建，也就是说对于其中的记录的字段以什么方式来进行格式的划分，这个在Lucene中称为Analyzer，Lucene提供了几种环境下使用的Analyzer：SimpleAnalyzer、StandardAnalyzer、GermanAnalyzer等，其中StandardAnalyzer是经常使用的，因为它提供了对于中文的支持，在表建好后我们就需要往里面插入用于索引的记录，在Lucene中这个称为Document，有点类似数据库中table的一行记录，记录中的字段的添加方法，在Lucene中称为Field，这个和数据库中基本一样，对于Field Lucene分为可被索引的，可切分的，不可被切分的，不可被索引的几种组合类型，通过这几个元素基本上就可以建立起索引了。

一步一步学lucene——（第一步：概念篇）

一步一步学lucene——（第一步：概念篇）信息检索的概念信息检索（Information Retrieval）是指信息按一定的方式组织起来，并根据信息用户的需要找出有关的信息的过程和技术。

狭义的信息检索就是信息检索过程的后半部分，即从信息集合中找出所需要的信息的过程，也就是我们常说的信息查寻（Information Search 或Information Seek）。

我们在下边研究的lucene就是对信息做全文检索的一种手段，或者说是一项比较流行的技术，跟google、baidu等专业的搜索引擎比起来会有一定的差距，但是对于普通的企业级应用已经是足够了。

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

Lucene 的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。

现在最新的稳定版本是3.6，而且4.0alpha版本也已经推出。

lucene能做什么首先要明确一点，lucene只是一个软件类库，或者一个工具箱，而并不是一个完整的搜索程序。

但是它的API非常简单，可以让你不用了解复杂的索引和搜索实现的情况下，通过它提供的API，来完成非常复杂的事务处理。

你可以把站内新闻都索引了，做个资料库；你可以把一个数据库表的若干个字段索引起来，那就不用再担心因为“%like%”而锁表了；你也可以写个自己的搜索引擎……应用程序和lucene之间的关系lucene的工作过程是首先建立索引，将索引保存，然后对索引进行搜索，并且根据搜索的结果找到对应的数据的过程。

关系结构如下：图：应用程序和lucene之间的关系lucene中的几大组件一、索引组件创建索引的过程就是首先“获取内容”，然后根据获取的内容“建立文档”，对文档进行“文档分析”，最后对文档建立“文档索引”的过程。

Lucene介绍与入门使用

Lucene介绍与⼊门使⽤ Lucene简介 Lucene是apache软件基⾦会4 jakarta项⽬组的⼀个⼦项⽬，是⼀个开放源代码的全⽂检索引擎⼯具包，但它不是⼀个完整的全⽂检索引擎，⽽是⼀个全⽂检索引擎的架构，提供了完整的查询引擎和索引引擎，部分⽂本分析引擎（英⽂与德⽂两种西⽅语⾔）。

Lucene的⽬的是为软件开发⼈员提供⼀个简单易⽤的⼯具包，以⽅便的在⽬标系统中实现全⽂检索的功能，或者是以此为基础建⽴起完整的全⽂检索引擎。

Lucene是⼀套⽤于全⽂检索和搜寻的开源程式库，由Apache软件基⾦会⽀持和提供。

Lucene提供了⼀个简单却强⼤的应⽤程式接⼝，能够做全⽂索引和搜寻。

在Java开发环境⾥Lucene是⼀个成熟的免费开源⼯具。

就其本⾝⽽⾔，Lucene是当前以及最近⼏年最受欢迎的免费Java信息检索程序库。

⼈们经常提到信息检索程序库，虽然与搜索引擎有关，但不应该将信息检索程序库与搜索引擎相混淆。

那么先来说⼀说什么是全⽂搜索说之前先说⼀说数据的分类：　我们⽣活中的数据总体分为两种：结构化数据和⾮结构化数据。

（1）结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。

（2）⾮结构化数据：指不定长或⽆固定格式的数据，如邮件，word⽂档等磁盘上的⽂件结构化数据查询⽅法数据库搜索数据库中的搜索很容易实现，通常都是使⽤sql语句进⾏查询，⽽且能很快的得到查询结果。

为什么数据库搜索很容易？因为数据库中的数据存储是有规律的，有⾏有列⽽且数据格式、数据长度都是固定的。

⾮结构化数据查询⽅法（1）顺序扫描法(Serial Scanning) 所谓顺序扫描，⽐如要找内容包含某⼀个字符串的⽂件，就是⼀个⽂档⼀个⽂档的看，对于每⼀个⽂档，从头看到尾，如果此⽂档包含此字符串，则此⽂档为我们要找的⽂件，接着看下⼀个⽂件，直到扫描完所有的⽂件。

如利⽤windows的搜索也可以搜索⽂件内容，只是相当的慢。

Lucene搜索引擎框架基础实践

Lucene 搜索引擎框架基础实践Lucene搜索引擎11) 有一系列被索引文件2) 被索引文件经过语法分析和语言处理形成一系列词(Term)。

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

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

a) 用户输入查询语句。

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

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

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

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

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

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

2lucene索引的单元对象是Document,它可以是一个文本、一封email或者一个网页等，其中Document包含多个Field，一个Field就是它的一个属性，比如“文件路径”、“作者”，“文件内容”等都是Field1）索引用类：/*** 对目录进行Lucene索引* @author roy**/public class Indexer {private static String INDEX_DIR = "G:\\ROY的各种笔记\\索引"; // 索引结果存放目录private static String DATA_DIR = "G:\\ROY的各种笔记"; //被索引文件存放的目录/*** 测试主函数* @param args* @throws Exception*/public static void main(String[] args) throws Exception{long start = new Date().getTime();int numIndexed = index(new File(INDEX_DIR),new File(DATA_DIR));//调用index方法long end = new Date().getTime();System.out.println("Indexing " + numIndexed + " files took " + (end - start) + " milliseconds");}/*** 索引dataDir下的.txt文件，并储存在indexDir下，返回索引的文件数量* @param indexDir* @param dataDir* @return* @throws IOException*/private static int index(File indexDir, File dataDir) throws Exception{if(!dataDir.exists() || !dataDir.isDirectory()){throw new Exception("被索引的文件不存在！");}if(!indexDir.exists() || !indexDir.isDirectory()){ indexDir.mkdirs();}IndexWriter writer = new IndexWriter( FSDirectory.open(indexDir),newStandardAnalyzer(Version.LUCENE_30),true,IndexWriter.MaxFieldLength.UNLIMITED);//按照目录进行递归索引indexDirectory(writer,dataDir);int numIndexed = writer.numDocs();//对索引后的结果加以优化writer.optimize();writer.close();return numIndexed;}/*** 循环遍历目录下的所有.doc文件并进行索引* @param writer* @param dir* @throws IOException*/private static void indexDirectory(IndexWriter writer, File dir) throws IOException {File[] files = dir.listFiles();for (int i = 0; i < files.length; i++) {File f = files[i];if (f.isDirectory()) {indexDirectory(writer, f); // recurse} else if (f.getName().endsWith(".doc")) {indexFile(writer, f);}}}/*** 对单个doc文件进行索引* @param writer* @param f* @throws IOException*/private static void indexFile(IndexWriter writer, File f)throws IOException {if (f.isHidden() || !f.exists() || !f.canRead()) {return;}System.out.println("Indexing " + f.getCanonicalPath());Document doc = new Document();doc.add(new Field("content",new FileReader(f)));doc.add(new Field("filename",f.getName(),Field.Store.YES,Field.Index.ANALYZED));doc.add(new Field("path",f.getCanonicalPath(),Field.Store.YES, Field.Index.ANALYZED));writer.addDocument(doc);}}2）查询用类：/*** 对索引结果进行搜索* @author roy**/public class Searcher {private static String INDEX_DIR = "G:\\ROY的各种笔记\\索引"; //索引所在的路径private static String KEYWORD = "自己"; //关键词private static int TOP_NUM = 100; //显示前100条结果/*** 测试主函数* @param args* @throws Exception*/public static void main(String[] args) throws Exception{File indexDir = new File(INDEX_DIR);if (!indexDir.exists() || !indexDir.isDirectory()){throw new Exception(indexDir + "索引目录不存在！");}search(indexDir,KEYWORD); //调用search方法进行查询}/*** 索引查找方法* @param indexDir 索引所在的目录* @param q 查询的字符串* @throws Exception*/private static void search(File indexDir, String q) throws Exception {IndexSearcher is = newIndexSearcher(FSDirectory.open(indexDir),true); //read-onlyString field = "content";//创建查询解析器QueryParser parser = new QueryParser(Version.LUCENE_30, field, new StandardAnalyzer(Version.LUCENE_30));Query query = parser.parse(q);//创建结果收集器TopScoreDocCollector collector =TopScoreDocCollector.create(TOP_NUM ,false);//有变化的地方long start = new Date().getTime();// start timeis.search(query, collector);ScoreDoc[] hits = collector.topDocs().scoreDocs;System.out.println(hits.length);for (int i = 0; i < hits.length; i++) {Document doc = is.doc(hits[i].doc);//new method is.doc()System.out.println(doc.getField("filename")+" "+hits[i].toString()+" ");}long end = new Date().getTime();//end timeSystem.out.println("Found " + collector.getTotalHits() +" document(s) (in " + (end - start) +" milliseconds) that matched query '" +q + "':");}}3、分词器的选择分词器是一个搜索引擎的核心之一，好的分词器可以把关键字分解为更接近于用户的搜索目标的词汇。