BlogJava-laoding-文章分类-搜索引擎 lucene

lucene增量索引的简单实现

老丁 — Sun, 31 May 2009 08:37:00 GMT

用lucene来建立搜索程序，在检索的时候效率大大的提高了，但是却以建立索引为代价，建立索引本身就是个耗内存大、时间长的过程（数据量比较大，数据少何必用lucene来建立全文检索，个人拙见），从而索引的建立就是个瓶颈，如果我们建立好索引，然后每次更新数据后重新建立索引，无疑是不合理的，为什么不能在原先索引文件的基础上再把新更新的加在上面呢？增量索引就是在建完索引的后，将数据库的最后一条记录的ID存储起来，下次建立时候将这个ID拿到，从而可以把更新的数据拿到，并把这些更新数据的索引文件加在原先的索引文件里面，下面来看个简单的例子
数据库有两个字段id和title，话不多说，直接上代码，一看便知

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

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;

public class Index {

    public static void main(String[] args) {
        try {
            Index index = new Index();
            String path = "d:\\index";//索引文件的存放路径
            String storeIdPath = "d:\\storeId.txt";//存储ID的路径
            String storeId ="";
            storeId = index.getStoreId(storeIdPath);
            ResultSet rs = index.getResult(storeId);
            index.indexBuilding(path, storeIdPath, rs);
            storeId = index.getStoreId(storeIdPath);
            System.out.println(storeId);//打印出这次存储起来的ID
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public ResultSet getResult(String storeId) throws Exception{
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        String url = "jdbc:mysql://localhost:3306/ding";
        String userName = "root";
        String password = "ding";
        Connection conn = DriverManager.getConnection(url,userName,password);
        Statement stmt = conn
            .createStatement();
        ResultSet rs = stmt
            .executeQuery("select * from newitem where id > '"+storeId+"'order by id");
        return rs;
    }

    public boolean indexBuilding(String path,String storeIdPath, ResultSet rs) {// 把RS换成LIST原理一样

        try {
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            // 取得存储起来的ID，以判定是增量索引还是重新索引
            boolean isEmpty = true;
             try {
                File file = new File(storeIdPath);
                if (!file.exists()) {
                    file.createNewFile();
                }
                FileReader fr = new FileReader(storeIdPath);
                BufferedReader br = new BufferedReader(fr);
                if(br.readLine()!= null) {
                    isEmpty = false;
                 }
                 br.close();
                 fr.close();
                } catch (IOException e) {
                   e.printStackTrace();
              }

            IndexWriter writer = new IndexWriter(path, luceneAnalyzer, isEmpty);//参数isEmpty是false表示增量索引
            String storeId = "";
            boolean indexFlag = false;
            String id;
            String title;
            while (rs.next()) {
                // for(Iterator it = list.iterator();it.hasNext();){
                id = rs.getString("id");
                title = rs.getString("title");
                writer.addDocument(Document(id, title));
                storeId = id;//将拿到的id给storeId，这种拿法不合理，这里为了方便
                indexFlag = true;
            }
            writer.optimize();
            writer.close();
            if(indexFlag){
                // 将最后一个的ID存到磁盘文件中
                this.writeStoreId(storeIdPath, storeId);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("出错了" + e.getClass() + "\n   错误信息为:   "
                    + e.getMessage());
            return false;
        }

    }

    public static Document Document(String id, String title) {
        Document doc = new Document();
        doc.add(new Field("ID", id, Field.Store.YES, Field.Index.TOKENIZED));
        doc.add(new Field("TITLE", title, Field.Store.YES,
                Field.Index.TOKENIZED));
        return doc;
    }

    // 取得存储在磁盘中的ID
    public static String getStoreId(String path) {
        String storeId = "";
        try {
            File file = new File(path);
            if (!file.exists()) {
                file.createNewFile();
            }
            FileReader fr = new FileReader(path);
            BufferedReader br = new BufferedReader(fr);
            storeId = br.readLine();
            if (storeId == null || storeId == "")
                storeId = "0";
            br.close();
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return storeId;
    }

    // 将ID写入到磁盘文件中
    public static boolean writeStoreId(String path,String storeId) {
        boolean b = false;
        try {
            File file = new File(path);
            if (!file.exists()) {
                file.createNewFile();
            }
            FileWriter fw = new FileWriter(path);
            PrintWriter out = new PrintWriter(fw);
            out.write(storeId);
            out.close();
            fw.close();
            b=true;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return b;
    }
}

这里代码写的比较简单，很多需要改进的地方，自己改进就行了，这里只是说明了增量索引的原理，望指正。

老丁 2009-05-31 16:37 发表评论

lucene索引word/pdf/html/txt文件及检索(搜索引擎)

老丁 — Fri, 31 Oct 2008 11:05:00 GMT

因为lucene索引的时候是将String型的信息建立索引的，所以这里必须是将word/pdf/html等文件的内容转化问字符型。
lucene的jar包自己去下载。
首先是建立索引的代码：

public class TextFileIndexer {
    public static void main(String[] args) throws Exception {
        /* 指明要索引文件夹的位置,这里是d盘的s文件夹下 */
        File fileDir = new File("d:\\s");

        /* 这里放索引文件的位置 */
        File indexDir = new File("d:\\index");
        Analyzer luceneAnalyzer = new StandardAnalyzer();
        IndexWriter indexWriter = new IndexWriter(indexDir, luceneAnalyzer,
                true);
        File[] textFiles = fileDir.listFiles();
        long startTime = new Date().getTime();

        //增加document到索引去
                System.out.println("File正在被索引.");

                /*
                 * 注意要变的就是这里，路径和读取文件的方法
                 * */
                String path ="d:\\s\\2.doc";
                String temp = ReadFile.readWord(path);
//                String path ="d:\\s\\index.htm";
//                String temp = ReadFile.readHtml(path);
                Document document = new Document();
                Field FieldPath = new Field("path",path,
                        Field.Store.YES, Field.Index.NO);
                Field FieldBody = new Field("body", temp, Field.Store.YES,
                        Field.Index.TOKENIZED,
                        Field.TermVector.WITH_POSITIONS_OFFSETS);
                document.add(FieldPath);
                document.add(FieldBody);
                indexWriter.addDocument(document);


        //optimize()方法是对索引进行优化
        indexWriter.optimize();
        indexWriter.close();

        //测试一下索引的时间
        long endTime = new Date().getTime();
        System.out
                .println("这花费了"
                        + (endTime - startTime)
                        + " 毫秒来把文档增加到索引里面去!"
                        + fileDir.getPath());
    }
}

上面已经注释了要换的地方，我们要做的就是换文件的路径和读取文件的方法。

下面来具体看下读取文件的方法

1.首先来看WORD文档：
我这里用的是poi，相关jar包自己去下载，然后加到工程中（以下所要用的jar包也是，不再重复说）。

来看相关代码：

    public static String readWord(String path) {
        StringBuffer content = new StringBuffer("");// 文档内容
        try {

            HWPFDocument doc = new HWPFDocument(new FileInputStream(path));
            Range range = doc.getRange();
            int paragraphCount = range.numParagraphs();// 段落
            for (int i = 0; i < paragraphCount; i++) {// 遍历段落读取数据
                Paragraph pp = range.getParagraph(i);
                content.append(pp.text());
            }

        } catch (Exception e) {

        }
        return content.toString().trim();
    }

2.PDF文件用的是PDFbox：

public static String readPdf(String path) throws Exception {
        StringBuffer content = new StringBuffer("");// 文档内容
        FileInputStream fis = new FileInputStream(path);
        PDFParser p = new PDFParser(fis);
        p.parse();
        PDFTextStripper ts = new PDFTextStripper();
        content.append(ts.getText(p.getPDDocument()));
        fis.close();
        return content.toString().trim();
    }

3.html文件：

public static String readHtml(String urlString) {

        StringBuffer content = new StringBuffer("");
        File file = new File(urlString);
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            // 读取页面
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    fis,"utf-8"));//这里的字符编码要注意，要对上html头文件的一致，否则会出乱码

            String line = null;

            while ((line = reader.readLine()) != null) {
                content.append(line + "\n");
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        String contentString = content.toString();
        return contentString;
    }

4.txt文件：

public static String readTxt(String path) {
        StringBuffer content = new StringBuffer("");// 文档内容
        try {
            FileReader reader = new FileReader(path);
            BufferedReader br = new BufferedReader(reader);
            String s1 = null;

            while ((s1 = br.readLine()) != null) {
                content.append(s1 + "\r");
            }
            br.close();
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return content.toString().trim();
    }

接下来数搜索代码：

public class TestQuery {
    public static void main(String[] args) throws IOException, ParseException {
        Hits hits = null;
        //搜索内容自己换
        String queryString = "根据国务院的决定";
        Query query = null;

        IndexSearcher searcher = new IndexSearcher("d:\\index"); //这里注意索引存放的路径

        Analyzer analyzer = new StandardAnalyzer();
        try {
            QueryParser qp = new QueryParser("body", analyzer);
            /**
             * 建索引的时候我们指定了body建立为内容，我们搜索的时候也是针对body的，所以
             *   QueryParser qp = new QueryParser("body", analyzer);
             *   这句和建立索引时候
                Field FieldBody = new Field("body", temp, Field.Store.YES,
                        Field.Index.TOKENIZED,
                        Field.TermVector.WITH_POSITIONS_OFFSETS);
             *的这句的"body"是对应的。
             */
            query = qp.parse(queryString);
        } catch (ParseException e) {
            System.out.println("异常");
        }
        if (searcher != null) {
            hits = searcher.search(query);
            if (hits.length() > 0) {
                System.out.println("找到:" + hits.length() + " 个结果!");
                for (int i = 0; i < hits.length(); i++) {//输出搜索信息
                     Document document = hits.doc(i);
                     System.out.println("contents："+document.get("body"));
                     //同样原理这里的document.get("body")就是取得建立在索引文件里面的额body的所有内容
                     //你若想输出文件路径就用document.get("path")就可以了
                }
            } else{
                System.out.println("0个结果!");
            }
        }
    }

老丁 2008-10-31 19:05 发表评论

Lucene的查询语法！(搜索引擎)

老丁 — Fri, 31 Oct 2008 10:07:00 GMT

原文来自：http://liyu2000.nease.net/article/Lucene/queryparsersyntax.htm

绪论

Lucene提供了方便您创建自建查询的API，也通过QueryParser提供了强大的查询语言。

本文讲述Lucene的查询语句解析器支持的语法，Lucene的查询语句解析器是使用JavaCC工具生成的词法解析器，它将查询字串解析为Lucene Query对象。

项（Term）

一条搜索语句被拆分为一些项（term）和操作符（operator）。项有两种类型：单独项和短语。

单独项就是一个单独的单词，例如"test" ， "hello"。

短语是一组被双引号包围的单词，例如"hello dolly"。

多个项可以用布尔操作符连接起来形成复杂的查询语句（接下来您就会看到）。

注意：Analyzer建立索引时使用的解析器和解析单独项和短语时的解析器相同，因此选择一个不会受查询语句干扰的Analyzer非常重要。

域（Field）

Lucene支持域。您可以指定在某一个域中搜索，或者就使用默认域。域名及默认域是具体索引器实现决定的。

您可以这样搜索域：域名+":"+搜索的项名。

举个例子，假设某一个Lucene索引包含两个域，title和text，text是默认域。如果您想查找标题为"The Right Way"且含有"don't go this way"的文章，您可以输入：

title:"The Right Way" AND text:go

或者

title:"Do it right" AND right

因为text是默认域，所以这个域名可以不行。

注意：域名只对紧接于其后的项生效，所以

title:Do it right

只有"Do"属于title域。"it"和"right"仍将在默认域中搜索（这里是text域）。

项修饰符（Term Modifiers）

Lucene支持项修饰符以支持更宽范围的搜索选项。

用通配符搜索

Lucene支持单个与多个字符的通配搜索。

使用符号"?"表示单个任意字符的通配。

使用符号"*"表示多个任意字符的通配。

单个任意字符匹配的是所有可能单个字符。例如，搜索"text或者"test"，可以这样：

te?t

多个任意字符匹配的是0个及更多个可能字符。例如，搜索test, tests 或者 tester，可以这样：

test*

您也可以在字符窜中间使用多个任意字符通配符。

te*t

注意：您不能在搜索的项开始使用*或者?符号。

模糊查询

Lucene支持基于Levenshtein Distance与Edit Distance算法的模糊搜索。要使用模糊搜索只需要在单独项的最后加上符号"~"。例如搜索拼写类似于"roam"的项这样写：

roam~

这次搜索将找到形如foam和roams的单词。

注意：使用模糊查询将自动得到增量因子（boost factor）为0.2的搜索结果.

邻近搜索(Proximity Searches)

Lucene还支持查找相隔一定距离的单词。邻近搜索是在短语最后加上符号"~"。例如在文档中搜索相隔10个单词的"apache"和"jakarta"，这样写：

"jakarta apache"~10

Boosting a Term

Lucene provides the relevance level of matching documents based on the terms found. To boost a term use the caret, "^", symbol with a boost factor (a number) at the end of the term you are searching. The higher the boost factor, the more relevant the term will be.

Lucene可以设置在搜索时匹配项的相似度。在项的最后加上符号"^"紧接一个数字（增量值），表示搜索时的相似度。增量值越高，搜索到的项相关度越好。

Boosting allows you to control the relevance of a document by boosting its term. For example, if you are searching for jakarta apache and you want the term "jakarta" to be more relevant boost it using the ^ symbol along with the boost factor next to the term. You would type:

通过增量一个项可以控制搜索文档时的相关度。例如如果您要搜索jakarta apache，同时您想让"jakarta"的相关度更加好，那么在其后加上"^"符号和增量值，也就是您输入：

jakarta^4 apache

This will make documents with the term jakarta appear more relevant. You can also boost Phrase Terms as in the example:

这将使得生成的doucment尽可能与jakarta相关度高。您也可以增量短语，象以下这个例子一样：

"jakarta apache"^4 "jakarta lucene"

By default, the boost factor is 1. Although, the boost factor must be positive, it can be less than 1 (i.e. .2)

默认情况下，增量值是1。增量值也可以小于1（例如0.2），但必须是有效的。

布尔操作符

布尔操作符可将项通过逻辑操作连接起来。Lucene支持AND, "+", OR, NOT 和 "-"这些操作符。（注意：布尔操作符必须全部大写）

OR操作符是默认的连接操作符。这意味着如果两个项之间没有布尔操作符，就是使用OR操作符。OR操作符连接两个项，意味着查找含有任意项的文档。这与集合并运算相同。符号||可以代替符号OR。

搜索含有"jakarta apache" 或者 "jakarta"的文档，可以使用这样的查询：

"jakarta apache" jakarta

或者

"jakarta apache" OR jakarta

AND

AND操作符匹配的是两项同时出现的文档。这个与集合交操作相等。符号&&可以代替符号AND。

搜索同时含有"jakarta apache" 与 "jakarta lucene"的文档，使用查询：

"jakarta apache" AND "jakarta lucene"

"+"操作符或者称为存在操作符，要求符号"+"后的项必须在文档相应的域中存在。

搜索必须含有"jakarta"，可能含有"lucene"的文档，使用查询：

+jakarta apache

NOT

NOT操作符排除那些含有NOT符号后面项的文档。这和集合的差运算相同。符号！可以代替符号NOT。

搜索含有"jakarta apache"，但是不含有"jakarta lucene"的文档，使用查询：

"jakarta apache" NOT "jakarta lucene"

注意：NOT操作符不能单独与项使用构成查询。例如，以下的查询查不到任何结果：

NOT "jakarta apache"

"-"操作符或者禁止操作符排除含有"-"后面的相似项的文档。

搜索含有"jakarta apache"，但不是"jakarta lucene"，使用查询：

"jakarta apache" -"jakarta lucene"

分组（Grouping）

Lucene支持使用圆括号来组合字句形成子查询。这对于想控制查询布尔逻辑的人十分有用。

搜索含有"jakarta"或者"apache"，同时含有"website"的文档，使用查询：

(jakartaOR apache) AND website

这样就消除了歧义，保证website必须存在，jakarta和apache中之一也存在。

转义特殊字符（Escaping Special Characters）

Lucene支持转义特殊字符，因为特殊字符是查询语法用到的。现在，特殊字符包括

+ - && || ! ( ) { } [ ] ^ " ~ * ? : "

转义特殊字符只需在字符前加上符号",例如搜索(1+1):2，使用查询

"(1"+1")":2

老丁 2008-10-31 18:07 发表评论

lucene介绍(搜索引擎)

老丁 — Fri, 31 Oct 2008 09:33:00 GMT

1. 什么是lucene

Apache Lucene是一个开放源程序的搜寻器引擎，利用它可以轻易地为Java软件加入全文搜寻功能。Lucene的最主要工作是替文件的每一个字作索引，索引让搜寻的效率比传统的逐字比较大大提高，Lucen提供一组解读，过滤，分析文件，编排和使用索引的API，它的强大之处除了高效和简单外，是最重要的是使使用者可以随时应自已需要自订其功能。 Lucene是apache软件基金会项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。

2. Lucene能做什么

Lucene使你可以为你的应用程序添加索引和搜索能力。Lucene可以索引并能使得可以转换成文本格式的任何数据能够被搜索。Lucene并不关心数据的来源、格式甚至它的语言，只要你能将它转换为文本。这就意味着你可经索引并搜索存放于文件中的数据：在远程服务器上的web页面，存于本地文件系统的文档，简单的文本文件，微软Word文档，HTML或PDF文件或任何其它能够提取出文本信息的格式。

同样，利用Lucene你可以索引存放于数据库中的数据，提供给用户很多数据库没有提供的全文搜索的能力。一旦你集成了Lucene，你的应用程序的用户就能够像这样来搜索：+George +Rice –eat –pudding, Apple –pie +Tiger, animal:monkey AND food:banana等等。利用Lucene，你可以索引和搜索email邮件，邮件列表档案，即时聊天记录，你的Wiki页面……等等更多。

3. Lucene的优点

（1）索引文件格式独立于应用平台。Lucene定义了一套以8位字节为基础的索引文件格式，使得兼容系统或者不同平台的应用能够共享建立的索引文件。

（2）在传统全文检索引擎的倒排索引的基础上，实现了分块索引，能够针对新的文件建立小文件索引，提升索引速度。然后通过与原有索引的合并，达到优化的目的。Lucene提供了索引的扩展机制，因此索引可以动态扩展。

（4）设计了独立于语言和文件格式的文本分析接口，索引器通过接受Token流完成索引文件的创立，用户扩展新的语言和文件格式，只需要实现文本分析的接口。

（5）已经默认实现了一套强大的查询引擎，用户无需自己编写代码即使系统可获得强大的查询能力，Lucene的查询实现中默认实现了布尔操作、模糊查询、分组查询等等。

（6）搜索过程优化。Lucene面向全文检索的优化在于首次索引检索后，并不把所有的记录（Document）具体内容读取出来，而起只将所有结果中匹配度最高的头100条结果（TopDocs）的ID放到结果集缓存中并返回。

（7）Lucene的另外一个特点是在收集结果的过程中将匹配度低的结果自动过滤掉了。这也是和数据库应用需要将搜索的结果全部返回不同之处

4. 查询相关

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

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

(1) 用通配符进行搜索

单个任意字符匹配的是所有可能单个字符。例如，搜索"text或者"test"，可以这样：te?t

多个任意字符匹配的是0个及更多个可能字符。例如，搜索test, tests 或者 tester，可以这样：test*

您也可以在字符窜中间使用多个任意字符通配符。te*t

注意：您不能在搜索的项开始使用*或者?符号。

(2) 模糊查询

Lucene支持基于Levenshtein Distance与Edit Distance算法的模糊搜索。要使用模糊搜索只需要在单独项的最后加上符号"~"。例如搜索拼写类似于"roam"的项这样写：roam~

这次搜索将找到形如foam和roams的单词。

注意：使用模糊查询将自动得到增量因子（boost factor）为0.2的搜索结果.

(3) 布尔操作符

布尔操作符可将项通过逻辑操作连接起来。Lucene支持AND, "+", OR, NOT 和 "-"这些操作符。（注意：布尔操作符必须全部大写）

(4) 转义特殊字符

Lucene支持转义特殊字符，因为特殊字符是查询语法用到的。现在，特殊字符包括

+ - && || ! ( ) { } [ ] ^ " ~ * ? : "

转义特殊字符只需在字符前加上符号",例如搜索(1+1):2，使用查询

"(1"+1")":2

5. 一些使用经验

(1) 关键词区分大小写

OR AND TO等关键词是区分大小写的，lucene只认大写的，小写的当做普通单词。

(2) 读写互斥性

同一时刻只能有一个对索引的写操作，在写的同时可以进行搜索。

(3) 文件锁

在写索引的过程中强行退出将在tmp目录留下一个lock文件，使以后的写操作无法进行，可以将其手工删除。

(4) 时间格式

lucene只支持一种时间格式yyMMddHHmmss，所以你传一个yy-MM-dd HH:mm:ss的时间给lucene它是不会当作时间来处理的。

(5) 索引更新

lucene不支持索引更新，必须是先删除再新建索引，如果数据量很大且更新快则相当麻烦，本身建立索引是个漫长的过程，同时相当耗内存且很伤disk，不能实时的满足查询。

(6) 中间取索引

lucene不支持从中间取索引。例如：用户取第十页，lucene需要把前面所有的内容都要检索出，然后所有的排序，过滤掉前面的然后返回。

(7) 英文查询

若查询英文，比如有一句话：jiangxi strong 如果你输入jiang或者stron等不完整的一个词，将不能查询出结果，当你输入jiangxi或者strong才能查询出结果。

老丁 2008-10-31 17:33 发表评论

简单lucene搜索实现(搜索引擎)

老丁 — Thu, 04 Sep 2008 05:06:00 GMT

首先下载lucene相关jar包，这里就不多说，自己网上找

在eclipse下建立web工程luceneTest

将jar包加载到你的web工程里面

新建类Index.java,代码如下：

import java.io.IOException;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;

/*
* Create Date:2007-10-26 下午02:52:53
*
* Author:dingkm
*
* Version: V1.0
*
* Description：对进行修改的功能进行描述
*
*
*/

public class Index {

/**
* @Description 方法实现功能描述
* @param args
*            void
* @throws 抛出异常说明
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  try {
   new Index().index();
   System.out.println("create index success!!!");
  } catch (CorruptIndexException e) {
   e.printStackTrace();
  } catch (LockObtainFailedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
}

public void index() throws CorruptIndexException, LockObtainFailedException, IOException{
   long start = System.currentTimeMillis();

  // 建立索引的路径
     String path = "c:\\index2";
  Document doc1 = new Document();
        doc1.add( new Field("name", "中华人民共和国",Field.Store.YES,Field.Index.TOKENIZED));
        doc1.add( new Field("content", "标题或正文包括",Field.Store.YES,Field.Index.TOKENIZED));
        doc1.add( new Field("time", "20080715",Field.Store.YES,Field.Index.TOKENIZED));
        Document doc2 = new Document();
        doc2.add(new Field("name", "大中国中国",Field.Store.YES,Field.Index.TOKENIZED));
        IndexWriter writer = new IndexWriter(FSDirectory.getDirectory(path, true), new StandardAnalyzer(), true);
        writer.setMaxMergeDocs(10);
        writer.setMaxFieldLength(3);
        writer.addDocument(doc1);
        writer.setMaxFieldLength(3);
        writer.addDocument(doc2);
        writer.close();


        System.out.println("=========================");
        System.out.print(System.currentTimeMillis() - start);
  System.out.println("total milliseconds");
  System.out.println("=========================");

}

执行这个类，可以看到结果：

=========================
375total milliseconds
=========================
create index success!!!

可以看到索引创建成功。

下面我们来创建搜索类，Search.java

import java.io.IOException;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.CorruptIndexException;
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;

/*
* Create Date:2007-10-26 下午02:56:12
*
* Author:dingkm
*
* Version: V1.0
*
* Description：对进行修改的功能进行描述
*
*
*/

public class Search {

/**
*   @Description 方法实现功能描述
*   @param args
*   void
*   @throws 抛出异常说明
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
   String path = "c:\\index2";
   try {
   new Search().search(path);
  } catch (CorruptIndexException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (ParseException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

}

public void search(String path) throws CorruptIndexException, IOException, ParseException{
   IndexSearcher searcher = new IndexSearcher(path);
         Hits hits = null;
         Query query = null;
         QueryParser qp = new QueryParser("name",new StandardAnalyzer());

            query = qp.parse("中");
         hits = searcher.search(query);
            java.text.NumberFormat   format   =   java.text.NumberFormat.getNumberInstance();
         System.out.println("查找到共" + hits.length() + "个结果");
            for   (int   i   =   0;   i   <   hits.length();   i++)   {
                  //开始输出查询结果
                  Document   doc   =   hits.doc(i);
                  System.out.println(doc.get("name"));
                  System.out.println("content="+doc.get("content"));
                  System.out.println("time="+doc.get("time"));
                  System.out.println("准确度为："   +   format.format(hits.score(i)   *   100.0)   +   "%");
//                  System.out.println(doc.get("CONTENT"));
              }

}

}

执行它，会得到以下结果：

查找到共2个结果
中华人民共和国
content=标题或正文包括
time=20080715
准确度为：29.727%
大中国中国
content=null
time=null
准确度为：29.727%

这样就完成了我们的程序

这是我第一次发表文章
说的比较简单，可能很多地方说的不清楚
希望大家多多支持

有什么不明白的欢迎留言。

老丁 2008-09-04 13:06 发表评论