wyl232

2008年9月19日 #

用 Lucene 加速 Web 搜索应用程序的开发

用 Lucene 加速 Web 搜索应用程序的开发

级别: 中级

周 登朋 (zhoudengpeng@yahoo.com.cn), 软件工程师, 上海交通大学

2006 年 9 月 06 日

Lucene 是基于 Java 的全文信息检索包,它目前是 Apache Jakarta 家族下面的一个开源项目。在这篇文章中,我们首先来看如何利用 Lucene 实现高级搜索功能,然后学习如何利用 Lucene 来创建一个健壮的 Web 搜索应用程序。

在本篇文章中,你会学习到如何利用 Lucene 实现高级搜索功能以及如何利用 Lucene 来创建 Web 搜索应用程序。通过这些学习,你就可以利用 Lucene 来创建自己的搜索应用程序。

架构概览

通常一个 Web 搜索引擎的架构分为前端和后端两部分,就像图一中所示。在前端流程中,用户在搜索引擎提供的界面中输入要搜索的关键词,这里提到的用户界面一般是一个带有输入框的 Web 页面,然后应用程序将搜索的关键词解析成搜索引擎可以理解的形式,并在索引文件上进行搜索操作。在排序后,搜索引擎返回搜索结果给用户。在后端流程中,网络爬虫或者机器人从因特网上获取 Web 页面,然后索引子系统解析这些 Web 页面并存入索引文件中。如果你想利用 Lucene 来创建一个 Web 搜索应用程序,那么它的架构也和上面所描述的类似,就如图一中所示。


Figure 1. Web 搜索引擎架构
Web搜索引擎架构

利用 Lucene 实现高级搜索

Lucene 支持多种形式的高级搜索,我们在这一部分中会进行探讨,然后我会使用 Lucene 的 API 来演示如何实现这些高级搜索功能。

布尔操作符

大多数的搜索引擎都会提供布尔操作符让用户可以组合查询,典型的布尔操作符有 AND, OR, NOT。Lucene 支持 5 种布尔操作符,分别是 AND, OR, NOT, 加(+), 减(-)。接下来我会讲述每个操作符的用法。

  • OR: 如果你要搜索含有字符 A 或者 B 的文档,那么就需要使用 OR 操作符。需要记住的是,如果你只是简单的用空格将两个关键词分割开,其实在搜索的时候搜索引擎会自动在两个关键词之间加上 OR 操作符。例如,“Java OR Lucene” 和 “Java Lucene” 都是搜索含有 Java 或者含有 Lucene 的文档。
  • AND: 如果你需要搜索包含一个以上关键词的文档,那么就需要使用 AND 操作符。例如,“Java AND Lucene” 返回所有既包含 Java 又包含 Lucene 的文档。
  • NOT: Not 操作符使得包含紧跟在 NOT 后面的关键词的文档不会被返回。例如,如果你想搜索所有含有 Java 但不含有 Lucene 的文档,你可以使用查询语句 “Java NOT Lucene”。但是你不能只对一个搜索词使用这个操作符,比如,查询语句 “NOT Java” 不会返回任何结果。
  • 加号(+): 这个操作符的作用和 AND 差不多,但它只对紧跟着它的一个搜索词起作用。例如,如果你想搜索一定包含 Java,但不一定包含 Lucene 的文档,就可以使用查询语句“+Java Lucene”。
  • 减号(-): 这个操作符的功能和 NOT 一样,查询语句 “Java -Lucene” 返回所有包含 Java 但不包含 Lucene 的文档。

接下来我们看一下如何利用 Lucene 提供的 API 来实现布尔查询。清单1 显示了如果利用布尔操作符进行查询的过程。


清单1:使用布尔操作符
  //Test boolean operator
            public void testOperator(String indexDirectory) throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String[] searchWords = {"Java AND Lucene", "Java NOT Lucene", "Java OR Lucene",
            "+Java +Lucene", "+Java -Lucene"};
            Analyzer language = new StandardAnalyzer();
            Query query;
            for(int i = 0; i < searchWords.length; i++){
            query = QueryParser.parse(searchWords[i], "title", language);
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords[i]);
            }
            }
            

域搜索(Field Search)

Lucene 支持域搜索,你可以指定一次查询是在哪些域(Field)上进行。例如,如果索引的文档包含两个域,TitleContent,你就可以使用查询 “Title: Lucene AND Content: Java” 来返回所有在 Title 域上包含 Lucene 并且在 Content 域上包含 Java 的文档。清单 2 显示了如何利用 Lucene 的 API 来实现域搜索。


清单2:实现域搜索
//Test field search
            public void testFieldSearch(String indexDirectory) throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String searchWords = "title:Lucene AND content:Java";
            Analyzer language = new StandardAnalyzer();
            Query query = QueryParser.parse(searchWords, "title", language);
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords);
            }
            

通配符搜索(Wildcard Search)

Lucene 支持两种通配符:问号(?)和星号(*)。你可以使用问号(?)来进行单字符的通配符查询,或者利用星号(*)进行多字符的通配符查询。例如,如果你想搜索 tiny 或者 tony,你就可以使用查询语句 “t?ny”;如果你想查询 Teach, Teacher 和 Teaching,你就可以使用查询语句 “Teach*”。清单3 显示了通配符查询的过程。


清单3:进行通配符查询
//Test wildcard search
            public void testWildcardSearch(String indexDirectory)throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String[] searchWords = {"tex*", "tex?", "?ex*"};
            Query query;
            for(int i = 0; i < searchWords.length; i++){
            query = new WildcardQuery(new Term("title",searchWords[i]));
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords[i]);
            }
            }
            

模糊查询

Lucene 提供的模糊查询基于编辑距离算法(Edit distance algorithm)。你可以在搜索词的尾部加上字符 ~ 来进行模糊查询。例如,查询语句 “think~” 返回所有包含和 think 类似的关键词的文档。清单 4 显示了如果利用 Lucene 的 API 进行模糊查询的代码。


清单4:实现模糊查询
//Test fuzzy search
            public void testFuzzySearch(String indexDirectory)throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            String[] searchWords = {"text", "funny"};
            Query query;
            for(int i = 0; i < searchWords.length; i++){
            query = new FuzzyQuery(new Term("title",searchWords[i]));
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results for query " + searchWords[i]);
            }
            }
            

范围搜索(Range Search)

范围搜索匹配某个域上的值在一定范围的文档。例如,查询 “age:[18 TO 35]” 返回所有 age 域上的值在 18 到 35 之间的文档。清单5显示了利用 Lucene 的 API 进行返回搜索的过程。


清单5:测试范围搜索
//Test range search
            public void testRangeSearch(String indexDirectory)throws Exception{
            Directory dir = FSDirectory.getDirectory(indexDirectory,false);
            IndexSearcher indexSearcher = new IndexSearcher(dir);
            Term begin = new Term("birthDay","20000101");
            Term end   = new Term("birthDay","20060606");
            Query query = new RangeQuery(begin,end,true);
            Hits results = indexSearcher.search(query);
            System.out.println(results.length() + "search results is returned");
            }
            





回页首


在 Web 应用程序中集成 Lucene

接下来我们开发一个 Web 应用程序利用 Lucene 来检索存放在文件服务器上的 HTML 文档。在开始之前,需要准备如下环境:

  1. Eclipse 集成开发环境
  2. Tomcat 5.0
  3. Lucene Library
  4. JDK 1.5

这个例子使用 Eclipse 进行 Web 应用程序的开发,最终这个 Web 应用程序跑在 Tomcat 5.0 上面。在准备好开发所必需的环境之后,我们接下来进行 Web 应用程序的开发。

1、创建一个动态 Web 项目

  1. 在 Eclipse 里面,选择 File > New > Project,然后再弹出的窗口中选择动态 Web 项目,如图二所示。

图二:创建动态Web项目
创建动态Web项目
  1. 在创建好动态 Web 项目之后,你会看到创建好的项目的结构,如图三所示,项目的名称为 sample.dw.paper.lucene。

图三:动态 Web 项目的结构
动态 Web 项目的结构

2. 设计 Web 项目的架构

在我们的设计中,把该系统分成如下四个子系统:

  1. 用户接口: 这个子系统提供用户界面使用户可以向 Web 应用程序服务器提交搜索请求,然后搜索结果通过用户接口来显示出来。我们用一个名为 search.jsp 的页面来实现该子系统。
  2. 请求管理器: 这个子系统管理从客户端发送过来的搜索请求并把搜索请求分发到搜索子系统中。最后搜索结果从搜索子系统返回并最终发送到用户接口子系统。我们使用一个 Servlet 来实现这个子系统。
  3. 搜索子系统: 这个子系统负责在索引文件上进行搜索并把搜索结构传递给请求管理器。我们使用 Lucene 提供的 API 来实现该子系统。
  4. 索引子系统: 这个子系统用来为 HTML 页面来创建索引。我们使用 Lucene 的 API 以及 Lucene 提供的一个 HTML 解析器来创建该子系统。

图4 显示了我们设计的详细信息,我们将用户接口子系统放到 webContent 目录下面。你会看到一个名为 search.jsp 的页面在这个文件夹里面。请求管理子系统在包 sample.dw.paper.lucene.servlet 下面,类 SearchController 负责功能的实现。搜索子系统放在包 sample.dw.paper.lucene.search 当中,它包含了两个类,SearchManagerSearchResultBean,第一个类用来实现搜索功能,第二个类用来描述搜索结果的结构。索引子系统放在包 sample.dw.paper.lucene.index 当中。类 IndexManager 负责为 HTML 文件创建索引。该子系统利用包 sample.dw.paper.lucene.util 里面的类 HTMLDocParser 提供的方法 getTitlegetContent 来对 HTML 页面进行解析。


图四:项目的架构设计
项目的架构设计

3. 子系统的实现

在分析了系统的架构设计之后,我们接下来看系统实现的详细信息。

  1. 用户接口: 这个子系统有一个名为 search.jsp 的 JSP 文件来实现,这个 JSP 页面包含两个部分。第一部分提供了一个用户接口去向 Web 应用程序服务器提交搜索请求,如图5所示。注意到这里的搜索请求发送到了一个名为 SearchController 的 Servlet 上面。Servlet 的名字和具体实现的类的对应关系在 web.xml 里面指定。

图5:向Web服务器提交搜索请求
向Web服务器提交搜索请求

这个JSP的第二部分负责显示搜索结果给用户,如图6所示:


图6:显示搜索结果
显示搜索结果
  1. 请求管理器: 一个名为 SearchController 的 servlet 用来实现该子系统。清单6给出了这个类的源代码。

清单6:请求管理器的实现
package sample.dw.paper.lucene.servlet;
            import java.io.IOException;
            import java.util.List;
            import javax.servlet.RequestDispatcher;
            import javax.servlet.ServletException;
            import javax.servlet.http.HttpServlet;
            import javax.servlet.http.HttpServletRequest;
            import javax.servlet.http.HttpServletResponse;
            import sample.dw.paper.lucene.search.SearchManager;
            /**
            * This servlet is used to deal with the search request
            * and return the search results to the client
            */
            public class SearchController extends HttpServlet{
            private static final long serialVersionUID = 1L;
            public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException{
            String searchWord = request.getParameter("searchWord");
            SearchManager searchManager = new SearchManager(searchWord);
            List searchResult = null;
            searchResult = searchManager.search();
            RequestDispatcher dispatcher = request.getRequestDispatcher("search.jsp");
            request.setAttribute("searchResult",searchResult);
            dispatcher.forward(request, response);
            }
            public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException{
            doPost(request, response);
            }
            }
            

清单6中,doPost 方法从客户端获取搜索词并创建类 SearchManager 的一个实例,其中类 SearchManager 在搜索子系统中进行了定义。然后,SearchManager 的方法 search 会被调用。最后搜索结果被返回到客户端。

  1. 搜索子系统: 在这个子系统中,我们定义了两个类:SearchManagerSearchResultBean。第一个类用来实现搜索功能,第二个类是个JavaBean,用来描述搜索结果的结构。清单7给出了类 SearchManager 的源代码。

清单7:搜索功能的实现
package sample.dw.paper.lucene.search;
            import java.io.IOException;
            import java.util.ArrayList;
            import java.util.List;
            import org.apache.lucene.analysis.Analyzer;
            import org.apache.lucene.analysis.standard.StandardAnalyzer;
            import org.apache.lucene.queryParser.ParseException;
            import org.apache.lucene.queryParser.QueryParser;
            import org.apache.lucene.search.Hits;
            import org.apache.lucene.search.IndexSearcher;
            import org.apache.lucene.search.Query;
            import sample.dw.paper.lucene.index.IndexManager;
            /**
            * This class is used to search the
            * Lucene index and return search results
            */
            public class SearchManager {
            private String searchWord;
            private IndexManager indexManager;
            private Analyzer analyzer;
            public SearchManager(String searchWord){
            this.searchWord   =  searchWord;
            this.indexManager =  new IndexManager();
            this.analyzer     =  new StandardAnalyzer();
            }
            /**
            * do search
            */
            public List search(){
            List searchResult = new ArrayList();
            if(false == indexManager.ifIndexExist()){
            try {
            if(false == indexManager.createIndex()){
            return searchResult;
            }
            } catch (IOException e) {
            e.printStackTrace();
            return searchResult;
            }
            }
            IndexSearcher indexSearcher = null;
            try{
            indexSearcher = new IndexSearcher(indexManager.getIndexDir());
            }catch(IOException ioe){
            ioe.printStackTrace();
            }
            QueryParser queryParser = new QueryParser("content",analyzer);
            Query query = null;
            try {
            query = queryParser.parse(searchWord);
            } catch (ParseException e) {
            e.printStackTrace();
            }
            if(null != query >> null != indexSearcher){
            try {
            Hits hits = indexSearcher.search(query);
            for(int i = 0; i < hits.length(); i ++){
            SearchResultBean resultBean = new SearchResultBean();
            resultBean.setHtmlPath(hits.doc(i).get("path"));
            resultBean.setHtmlTitle(hits.doc(i).get("title"));
            searchResult.add(resultBean);
            }
            } catch (IOException e) {
            e.printStackTrace();
            }
            }
            return searchResult;
            }
            }
            

清单7中,注意到在这个类里面有三个私有属性。第一个是 searchWord,代表了来自客户端的搜索词。第二个是 indexManager,代表了在索引子系统中定义的类 IndexManager 的一个实例。第三个是 analyzer,代表了用来解析搜索词的解析器。现在我们把注意力放在方法 search 上面。这个方法首先检查索引文件是否已经存在,如果已经存在,那么就在已经存在的索引上进行检索,如果不存在,那么首先调用类 IndexManager 提供的方法来创建索引,然后在新创建的索引上进行检索。搜索结果返回后,这个方法从搜索结果中提取出需要的属性并为每个搜索结果生成类 SearchResultBean 的一个实例。最后这些 SearchResultBean 的实例被放到一个列表里面并返回给请求管理器。

在类 SearchResultBean 中,含有两个属性,分别是 htmlPathhtmlTitle,以及这个两个属性的 get 和 set 方法。这也意味着我们的搜索结果包含两个属性:htmlPathhtmlTitle,其中 htmlPath 代表了 HTML 文件的路径,htmlTitle 代表了 HTML 文件的标题。

  1. 索引子系统: 类 IndexManager 用来实现这个子系统。清单8 给出了这个类的源代码。

清单8:索引子系统的实现
package sample.dw.paper.lucene.index;
            import java.io.File;
            import java.io.IOException;
            import java.io.Reader;
            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.index.IndexWriter;
            import org.apache.lucene.store.Directory;
            import org.apache.lucene.store.FSDirectory;
            import sample.dw.paper.lucene.util.HTMLDocParser;
            /**
            * This class is used to create an index for HTML files
            *
            */
            public class IndexManager {
            //the directory that stores HTML files
            private final String dataDir  = "c:\\dataDir";
            //the directory that is used to store a Lucene index
            private final String indexDir = "c:\\indexDir";
            /**
            * create index
            */
            public boolean createIndex() throws IOException{
            if(true == ifIndexExist()){
            return true;
            }
            File dir = new File(dataDir);
            if(!dir.exists()){
            return false;
            }
            File[] htmls = dir.listFiles();
            Directory fsDirectory = FSDirectory.getDirectory(indexDir, true);
            Analyzer  analyzer    = new StandardAnalyzer();
            IndexWriter indexWriter = new IndexWriter(fsDirectory, analyzer, true);
            for(int i = 0; i < htmls.length; i++){
            String htmlPath = htmls[i].getAbsolutePath();
            if(htmlPath.endsWith(".html") || htmlPath.endsWith(".htm")){
            addDocument(htmlPath, indexWriter);
            }
            }
            indexWriter.optimize();
            indexWriter.close();
            return true;
            }
            /**
            * Add one document to the Lucene index
            */
            public void addDocument(String htmlPath, IndexWriter indexWriter){
            HTMLDocParser htmlParser = new HTMLDocParser(htmlPath);
            String path    = htmlParser.getPath();
            String title   = htmlParser.getTitle();
            Reader content = htmlParser.getContent();
            Document document = new Document();
            document.add(new Field("path",path,Field.Store.YES,Field.Index.NO));
            document.add(new Field("title",title,Field.Store.YES,Field.Index.TOKENIZED));
            document.add(new Field("content",content));
            try {
            indexWriter.addDocument(document);
            } catch (IOException e) {
            e.printStackTrace();
            }
            }
            /**
            * judge if the index exists already
            */
            public boolean ifIndexExist(){
            File directory = new File(indexDir);
            if(0 < directory.listFiles().length){
            return true;
            }else{
            return false;
            }
            }
            public String getDataDir(){
            return this.dataDir;
            }
            public String getIndexDir(){
            return this.indexDir;
            }
            }
            

这个类包含两个私有属性,分别是 dataDirindexDirdataDir 代表存放等待进行索引的 HTML 页面的路径,indexDir 代表了存放 Lucene 索引文件的路径。类 IndexManager 提供了三个方法,分别是 createIndex, addDocumentifIndexExist。如果索引不存在的话,你可以使用方法 createIndex 去创建一个新的索引,用方法 addDocument 去向一个索引上添加文档。在我们的场景中,一个文档就是一个 HTML 页面。方法 addDocument 会调用由类 HTMLDocParser 提供的方法对 HTML 文档进行解析。你可以使用最后一个方法 ifIndexExist 来判断 Lucene 的索引是否已经存在。

现在我们来看一下放在包 sample.dw.paper.lucene.util 里面的类 HTMLDocParser。这个类用来从 HTML 文件中提取出文本信息。这个类包含三个方法,分别是 getContentgetTitlegetPath。第一个方法返回去除了 HTML 标记的文本内容,第二个方法返回 HTML 文件的标题,最后一个方法返回 HTML 文件的路径。清单9 给出了这个类的源代码。


清单9:HTML 解析器
package sample.dw.paper.lucene.util;
            import java.io.FileInputStream;
            import java.io.FileNotFoundException;
            import java.io.IOException;
            import java.io.InputStream;
            import java.io.InputStreamReader;
            import java.io.Reader;
            import java.io.UnsupportedEncodingException;
            import org.apache.lucene.demo.html.HTMLParser;
            public class HTMLDocParser {
            private String htmlPath;
            private HTMLParser htmlParser;
            public HTMLDocParser(String htmlPath){
            this.htmlPath = htmlPath;
            initHtmlParser();
            }
            private void initHtmlParser(){
            InputStream inputStream = null;
            try {
            inputStream = new FileInputStream(htmlPath);
            } catch (FileNotFoundException e) {
            e.printStackTrace();
            }
            if(null != inputStream){
            try {
            htmlParser = new HTMLParser(new InputStreamReader(inputStream, "utf-8"));
            } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            }
            }
            }
            public String getTitle(){
            if(null != htmlParser){
            try {
            return htmlParser.getTitle();
            } catch (IOException e) {
            e.printStackTrace();
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
            }
            return "";
            }
            public Reader getContent(){
            if(null != htmlParser){
            try {
            return htmlParser.getReader();
            } catch (IOException e) {
            e.printStackTrace();
            }
            }
            return null;
            }
            public String getPath(){
            return this.htmlPath;
            }
            }
            

5.在 Tomcat 5.0 上运行应用程序

现在我们可以在 Tomcat 5.0 上运行开发好的应用程序。

  1. 右键单击 search.jsp,然后选择 Run as > Run on Server,如图7所示。

图7:配置 Tomcat 5.0
配置 Tomcat 5.0
  1. 在弹出的窗口中,选择 Tomcat v5.0 Server 作为目标 Web 应用程序服务器,然后点击 Next,如图8 所示:

图8:选择 Tomcat 5.0
选择 Tomcat 5.0
  1. 现在需要指定用来运行 Web 应用程序的 Apache Tomcat 5.0 以及 JRE 的路径。这里你所选择的 JRE 的版本必须和你用来编译 Java 文件的 JRE 的版本一致。配置好之后,点击 Finish。如 图9 所示。

图9:完成Tomcat 5.0的配置
完成Tomcat 5.0的配置
  1. 配置好之后,Tomcat 会自动运行,并且会对 search.jsp 进行编译并显示给用户。如 图10 所示。

图10:用户界面
用户界面
  1. 在输入框中输入关键词 “information” 然后单击 Search 按钮。然后这个页面上会显示出搜索结果来,如 图11 所示。

图11:搜索结果
搜索结果
  1. 单击搜索结果的第一个链接,页面上就会显示出所链接到的页面的内容。如 图12 所示.

图12:详细信息
详细信息

现在我们已经成功的完成了示例项目的开发,并成功的用Lucene实现了搜索和索引功能。你可以下载这个项目的源代码(下载)。





回页首


总结

Lucene 提供了灵活的接口使我们更加方便的设计我们的 Web 搜索应用程序。如果你想在你的应用程序中加入搜索功能,那么 Lucene 是一个很好的选择。在设计你的下一个带有搜索功能的应用程序的时候可以考虑使用 Lucene 来提供搜索功能。

posted @ 2008-09-19 11:19 wyl 阅读(36) | 评论 (0)编辑 收藏

实战 Lucene,第 1 部分: 初识 Lucene

级别: 初级

朋 周登 (zhoudengpeng@yahoo.com.cn), 软件工程师

2006 年 4 月 20 日

本文首先介绍了Lucene的一些基本概念,然后开发了一个应用程序演示了利用Lucene建立索引并在该索引上进行搜索的过程。

Lucene 简介

Lucene 是一个基于 Java 的全文信息检索工具包,它不是一个完整的搜索应用程序,而是为你的应用程序提供索引和搜索功能。Lucene 目前是 Apache Jakarta 家族中的一个开源项目。也是目前最为流行的基于 Java 开源全文检索工具包。

目前已经有很多应用程序的搜索功能是基于 Lucene 的,比如 Eclipse 的帮助系统的搜索功能。Lucene 能够为文本类型的数据建立索引,所以你只要能把你要索引的数据格式转化的文本的,Lucene 就能对你的文档进行索引和搜索。比如你要对一些 HTML 文档,PDF 文档进行索引的话你就首先需要把 HTML 文档和 PDF 文档转化成文本格式的,然后将转化后的内容交给 Lucene 进行索引,然后把创建好的索引文件保存到磁盘或者内存中,最后根据用户输入的查询条件在索引文件上进行查询。不指定要索引的文档的格式也使 Lucene 能够几乎适用于所有的搜索应用程序。

图 1 表示了搜索应用程序和 Lucene 之间的关系,也反映了利用 Lucene 构建搜索应用程序的流程:


图1. 搜索应用程序和 Lucene 之间的关系
图1. 搜索应用程序和 Lucene 之间的关系




回页首


索引和搜索

索引是现代搜索引擎的核心,建立索引的过程就是把源数据处理成非常方便查询的索引文件的过程。为什么索引这么重要呢,试想你现在要在大量的文档中搜索含有某个关键词的文档,那么如果不建立索引的话你就需要把这些文档顺序的读入内存,然后检查这个文章中是不是含有要查找的关键词,这样的话就会耗费非常多的时间,想想搜索引擎可是在毫秒级的时间内查找出要搜索的结果的。这就是由于建立了索引的原因,你可以把索引想象成这样一种数据结构,他能够使你快速的随机访问存储在索引中的关键词,进而找到该关键词所关联的文档。Lucene 采用的是一种称为反向索引(inverted index)的机制。反向索引就是说我们维护了一个词/短语表,对于这个表中的每个词/短语,都有一个链表描述了有哪些文档包含了这个词/短语。这样在用户输入查询条件的时候,就能非常快的得到搜索结果。我们将在本系列文章的第二部分详细介绍 Lucene 的索引机制,由于 Lucene 提供了简单易用的 API,所以即使读者刚开始对全文本进行索引的机制并不太了解,也可以非常容易的使用 Lucene 对你的文档实现索引。

对文档建立好索引后,就可以在这些索引上面进行搜索了。搜索引擎首先会对搜索的关键词进行解析,然后再在建立好的索引上面进行查找,最终返回和用户输入的关键词相关联的文档。





回页首


Lucene 软件包分析

Lucene 软件包的发布形式是一个 JAR 文件,下面我们分析一下这个 JAR 文件里面的主要的 JAVA 包,使读者对之有个初步的了解。

Package: org.apache.lucene.document

这个包提供了一些为封装要索引的文档所需要的类,比如 Document, Field。这样,每一个文档最终被封装成了一个 Document 对象。

Package: org.apache.lucene.analysis

这个包主要功能是对文档进行分词,因为文档在建立索引之前必须要进行分词,所以这个包的作用可以看成是为建立索引做准备工作。

Package: org.apache.lucene.index

这个包提供了一些类来协助创建索引以及对创建好的索引进行更新。这里面有两个基础的类:IndexWriter 和 IndexReader,其中 IndexWriter 是用来创建索引并添加文档到索引中的,IndexReader 是用来删除索引中的文档的。

Package: org.apache.lucene.search

这个包提供了对在建立好的索引上进行搜索所需要的类。比如 IndexSearcher 和 Hits, IndexSearcher 定义了在指定的索引上进行搜索的方法,Hits 用来保存搜索得到的结果。





回页首


一个简单的搜索应用程序

假设我们的电脑的目录中含有很多文本文档,我们需要查找哪些文档含有某个关键词。为了实现这种功能,我们首先利用 Lucene 对这个目录中的文档建立索引,然后在建立好的索引中搜索我们所要查找的文档。通过这个例子读者会对如何利用 Lucene 构建自己的搜索应用程序有个比较清楚的认识。





回页首


建立索引

为了对文档进行索引,Lucene 提供了五个基础的类,他们分别是 Document, Field, IndexWriter, Analyzer, Directory。下面我们分别介绍一下这五个类的用途:

Document

Document 是用来描述文档的,这里的文档可以指一个 HTML 页面,一封电子邮件,或者是一个文本文件。一个 Document 对象由多个 Field 对象组成的。可以把一个 Document 对象想象成数据库中的一个记录,而每个 Field 对象就是记录的一个字段。

Field

Field 对象是用来描述一个文档的某个属性的,比如一封电子邮件的标题和内容可以用两个 Field 对象分别描述。

Analyzer

在一个文档被索引之前,首先需要对文档内容进行分词处理,这部分工作就是由 Analyzer 来做的。Analyzer 类是一个抽象类,它有多个实现。针对不同的语言和应用需要选择适合的 Analyzer。Analyzer 把分词后的内容交给 IndexWriter 来建立索引。

IndexWriter

IndexWriter 是 Lucene 用来创建索引的一个核心的类,他的作用是把一个个的 Document 对象加到索引中来。

Directory

这个类代表了 Lucene 的索引的存储的位置,这是一个抽象类,它目前有两个实现,第一个是 FSDirectory,它表示一个存储在文件系统中的索引的位置。第二个是 RAMDirectory,它表示一个存储在内存当中的索引的位置。

熟悉了建立索引所需要的这些类后,我们就开始对某个目录下面的文本文件建立索引了,清单1给出了对某个目录下的文本文件建立索引的源代码。


清单 1. 对文本文件建立索引
package TestLucene;
            import java.io.File;
            import java.io.FileReader;
            import java.io.Reader;
            import java.util.Date;
            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.index.IndexWriter;
            /**
            * This class demonstrate the process of creating index with Lucene
            * for text files
            */
            public class TxtFileIndexer {
            public static void main(String[] args) throws Exception{
            //indexDir is the directory that hosts Lucene's index files
            File   indexDir = new File("D:\\luceneIndex");
            //dataDir is the directory that hosts the text files that to be indexed
            File   dataDir  = new File("D:\\luceneData");
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            File[] dataFiles  = dataDir.listFiles();
            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
            long startTime = new Date().getTime();
            for(int i = 0; i < dataFiles.length; i++){
            if(dataFiles[i].isFile() && dataFiles[i].getName().endsWith(".txt")){
            System.out.println("Indexing file " + dataFiles[i].getCanonicalPath());
                    		Document document = new Document();
            Reader txtReader = new FileReader(dataFiles[i]);
            document.add(Field.Text("path",dataFiles[i].getCanonicalPath()));
            document.add(Field.Text("contents",txtReader));
            indexWriter.addDocument(document);
            }
            }
            indexWriter.optimize();
            indexWriter.close();
            long endTime = new Date().getTime();
            System.out.println("It takes " + (endTime - startTime)
            + " milliseconds to create index for the files in directory "
            + dataDir.getPath());
            }
            }
            

在清单1中,我们注意到类 IndexWriter 的构造函数需要三个参数,第一个参数指定了所创建的索引要存放的位置,他可以是一个 File 对象,也可以是一个 FSDirectory 对象或者 RAMDirectory 对象。第二个参数指定了 Analyzer 类的一个实现,也就是指定这个索引是用哪个分词器对文挡内容进行分词。第三个参数是一个布尔型的变量,如果为 true 的话就代表创建一个新的索引,为 false 的话就代表在原来索引的基础上进行操作。接着程序遍历了目录下面的所有文本文档,并为每一个文本文档创建了一个 Document 对象。然后把文本文档的两个属性:路径和内容加入到了两个 Field 对象中,接着在把这两个 Field 对象加入到 Document 对象中,最后把这个文档用 IndexWriter 类的 add 方法加入到索引中去。这样我们便完成了索引的创建。接下来我们进入在建立好的索引上进行搜索的部分。





回页首


搜索文档

利用Lucene进行搜索就像建立索引一样也是非常方便的。在上面一部分中,我们已经为一个目录下的文本文档建立好了索引,现在我们就要在这个索引上进行搜索以找到包含某个关键词或短语的文档。Lucene提供了几个基础的类来完成这个过程,它们分别是呢IndexSearcher, Term, Query, TermQuery, Hits. 下面我们分别介绍这几个类的功能。

Query

这是一个抽象类,他有多个实现,比如TermQuery, BooleanQuery, PrefixQuery. 这个类的目的是把用户输入的查询字符串封装成Lucene能够识别的Query。

Term

Term是搜索的基本单位,一个Term对象有两个String类型的域组成。生成一个Term对象可以有如下一条语句来完成:Term term = new Term(“fieldName”,”queryWord”); 其中第一个参数代表了要在文档的哪一个Field上进行查找,第二个参数代表了要查询的关键词。

TermQuery

TermQuery是抽象类Query的一个子类,它同时也是Lucene支持的最为基本的一个查询类。生成一个TermQuery对象由如下语句完成: TermQuery termQuery = new TermQuery(new Term(“fieldName”,”queryWord”)); 它的构造函数只接受一个参数,那就是一个Term对象。

IndexSearcher

IndexSearcher是用来在建立好的索引上进行搜索的。它只能以只读的方式打开一个索引,所以可以有多个IndexSearcher的实例在一个索引上进行操作。

Hits

Hits是用来保存搜索的结果的。

介绍完这些搜索所必须的类之后,我们就开始在之前所建立的索引上进行搜索了,清单2给出了完成搜索功能所需要的代码。


清单2 :在建立好的索引上进行搜索
package TestLucene;
            import java.io.File;
            import org.apache.lucene.document.Document;
            import org.apache.lucene.index.Term;
            import org.apache.lucene.search.Hits;
            import org.apache.lucene.search.IndexSearcher;
            import org.apache.lucene.search.TermQuery;
            import org.apache.lucene.store.FSDirectory;
            /**
            * This class is used to demonstrate the
            * process of searching on an existing
            * Lucene index
            *
            */
            public class TxtFileSearcher {
            public static void main(String[] args) throws Exception{
            String queryStr = "lucene";
            //This is the directory that hosts the Lucene index
            File indexDir = new File("D:\\luceneIndex");
            FSDirectory directory = FSDirectory.getDirectory(indexDir,false);
            IndexSearcher searcher = new IndexSearcher(directory);
            if(!indexDir.exists()){
            System.out.println("The Lucene index is not exist");
            return;
            }
            Term term = new Term("contents",queryStr.toLowerCase());
            TermQuery luceneQuery = new TermQuery(term);
            Hits hits = searcher.search(luceneQuery);
            for(int i = 0; i < hits.length(); i++){
            Document document = hits.doc(i);
            System.out.println("File: " + document.get("path"));
            }
            }
            }
            

在清单2中,类IndexSearcher的构造函数接受一个类型为Directory的对象,Directory是一个抽象类,它目前有两个子类:FSDirctory和RAMDirectory. 我们的程序中传入了一个FSDirctory对象作为其参数,代表了一个存储在磁盘上的索引的位置。构造函数执行完成后,代表了这个IndexSearcher以只读的方式打开了一个索引。然后我们程序构造了一个Term对象,通过这个Term对象,我们指定了要在文档的内容中搜索包含关键词”lucene”的文档。接着利用这个Term对象构造出TermQuery对象并把这个TermQuery对象传入到IndexSearcher的search方法中进行查询,返回的结果保存在Hits对象中。最后我们用了一个循环语句把搜索到的文档的路径都打印了出来。好了,我们的搜索应用程序已经开发完毕,怎么样,利用Lucene开发搜索应用程序是不是很简单。





回页首


总结

本文首先介绍了 Lucene 的一些基本概念,然后开发了一个应用程序演示了利用 Lucene 建立索引并在该索引上进行搜索的过程。希望本文能够为学习 Lucene 的读者提供帮助。



关于作者

 

周登朋,软件工程师,上海交通大学研究生,对 Java 技术以及信息检索技术很感兴趣。您可以通过 zhoudengpeng@yahoo.com.cn 与他联系。

posted @ 2008-09-19 11:16 wyl 阅读(41) | 评论 (0)编辑 收藏

仅列出标题