午夜精品视频,8x国产一区二区三区精品推荐,精品欧美一区二区在线观看

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

用lucene来徏立搜索程序，在检索的时候效率大大的提高了，但是却以建立索引��Z��P��建立索引本��n��是个耗内存大、时间长的过�E�（数据量比较大�Q�数据少何必用lucene来徏立全文检索，个�h拙见�Q�，从而烦引的建立��是个瓶颈，如果我们建立好烦引，然后每次更新数据后重新徏立烦引，无疑是不合理的，��Z��么不能在原先索引文�g的基��上再把新更新的加在上面呢�Q�增量烦引就是在建完索引的后�Q�将数据库的最后一条记录的ID存储��h��Q�下�ơ徏立时候将�q�个ID拿到�Q�从而可以把更新的数据拿刎ͼ��q�把�q�些更新数据的烦引文件加在原先的索引文�g里面�Q�下面来看个��单的例子
数据库有两个字段id和title�Q�话不多��_��直接上代码，一看便�?br />

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";//索引文�g的存放�\�?/span>
            String storeIdPath = "d:\\storeId.txt";//存储ID的�\�?/span>
            String storeId ="";
            storeId = index.getStoreId(storeIdPath);
            ResultSet rs = index.getResult(storeId);
            index.indexBuilding(path, storeIdPath, rs);
            storeId = index.getStoreId(storeIdPath);
            System.out.println(storeId);//打印��ơ存储�v来的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原理一�?/span>

        try {
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            // 取得存储��h��的ID�Q�以判定是增量烦引还是重新烦�?/span>
            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�l�storeId�Q�这�U�拿法不合理�Q�这里�ؓ了方�?/span>
                indexFlag = true;
            }
            writer.optimize();
            writer.close();
            if(indexFlag){
                // ��最后一个的ID存到��盘文�g�?/span>
                this.writeStoreId(storeIdPath, storeId);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("出错�?/span>" + 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;
    }
}

�q�里代码写的比较��单，很多需要改�q�的地方�Q�自己改�q�就行了�Q�这里只是说明了增量索引的原理，望指正�?br />

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

lucene索引word/pdf/html/txt文�g及检�?搜烦引擎)

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

因�ؓlucene索引的时候是��String型的信息建立索引的，所以这里必��L��word/pdf/html�{�文件的内容转化问字�W�型�?br /> lucene的jar包自己去下蝲�?br /> 首先是徏立烦引的代码�Q?br />

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

        /* �q�里攄��引文件的位置 */
        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正在被烦�?img src="http://www.aygfsteel.com/Images/dot.gif" alt="" />.");

                /*
                 * 注意要变的就是这里，路径和读取文件的�Ҏ��
                 * */
                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()�Ҏ��是对索引�q�行优化
        indexWriter.optimize();
        indexWriter.close();

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

上面已经注释了要换的地方�Q�我们要做的��是换文件的路径和读取文件的�Ҏ��?/span>

下面来具体看下读取文件的�Ҏ��

1.首先来看WORD文档�Q?/span>
我这里用的是poi�Q�相关jar包自己去下蝲�Q�然后加到工�E�中�Q�以下所要用的jar包也是，不再重复��_��?br />
来看相关代码�Q?br />

    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();// �D�落
            for (int i = 0; i < paragraphCount; i++) {// 遍历�D�落��d��数据
                Paragraph pp = range.getParagraph(i);
                content.append(pp.text());
            }

        } catch (Exception e) {

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

2.PDF文�g用的是PDFbox�Q?br />

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文�g�Q?br />

public static String readHtml(String urlString) {

        StringBuffer content = new StringBuffer("");
        File file = new File(urlString);
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            // ��d��面
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    fis,"utf-8"));//�q�里的字�W�编码要注意�Q�要对上html头文件的一��_��否则会出��q��

            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文�g�Q?/span>

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();
    }

接下来数搜烦代码�Q?/span>

public class TestQuery {
    public static void main(String[] args) throws IOException, ParseException {
        Hits hits = null;
        //搜烦内容自己�?/span>
        String queryString = "�Ҏ��国务院的军_��";
        Query query = null;

        IndexSearcher searcher = new IndexSearcher("d:\\index"); //�q�里注意索引存放的�\�?nbsp;

        Analyzer analyzer = new StandardAnalyzer();
        try {
            QueryParser qp = new QueryParser("body", analyzer);
            /**
             * 建烦引的时候我们指定了body建立为内容，我们搜烦的时候也是针对body的，所�?br />              *   QueryParser qp = new QueryParser("body", analyzer);
             *   �q�句和徏立烦引时�?br />                 Field FieldBody = new Field("body", temp, Field.Store.YES,
                        Field.Index.TOKENIZED,
                        Field.TermVector.WITH_POSITIONS_OFFSETS);
             *的这句的"body"是对应的�?br />              */
            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�Q?/span>"+document.get("body"));
                     //同样原理�q�里的document.get("body")��是取得建立在烦引文仉��面的额body的所有内�?br />                      //你若惌��出文件�\径就用document.get("path")��可以了
                }
            } else{
                System.out.println("0个结�?");
            }
        }
    }

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

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

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

原文来自�Q?a >http://liyu2000.nease.net/article/Lucene/queryparsersyntax.htm

�l�论

Lucene提供了方便您创徏自徏查询的API�Q�也通过QueryParser提供了强大的查询语言�?/span>

本文讲述Lucene的查询语句解析器支持的语法，Lucene的查询语句解析器是��用JavaCC工具生成的词法解析器�Q�它��查询字串解析�ؓLucene Query对象�?/span>

��（Term�Q?/span>

一条搜索语句被拆分��Z��些项�Q�term�Q�和操作�W�（operator�Q�。项有两�U�类型：单独��和短语�?/span>

单独��就是一个单独的单词�Q�例�?test" �Q?"hello"�?/span>

短语是一�l�被双引号包围的单词�Q�例�?hello dolly"�?/span>

多个��可以用布尔操作�W�连接�v来�Ş成复杂的查询语句�Q�接下来您就会看刎ͼ��?/span>

注意�Q�Analyzer建立索引时��用的解析器和解析单独��和短语时的解析器相同，因此选择一个不会受查询语句�q�扰的Analyzer非常重要�?/span>

域（Field�Q?/span>

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

您可以这��h��索域�Q�域�?":"+搜烦的项名�?/span>

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

title:"The Right Way" AND text:go

或�?/span>

title:"Do it right" AND right

因�ؓtext是默认域�Q�所以这个域名可以不行�?/span>

注意�Q�域名只对紧接于其后的项生效�Q�所�?/span>

title:Do it right

只有"Do"属于title域�?it"�?right"仍将在默认域中搜索（�q�里是text域）�?/span>

��修饰符�Q?/span>Term Modifiers�Q?/span>

Lucene支持��修饰符以支持更宽范围的搜烦选项�?/span>

用通配�W�搜�?/span>

Lucene支持单个与多个字�W�的通配搜烦�?/span>

使用�W�号"?"表示单个��L��字符的通配�?/span>

使用�W�号"*"表示多个��L��字符的通配�?/span>

单个��L��字符匚w��的是所有可能单个字�W�。例如，搜烦"text或�?test"�Q�可以这��P��

te?t

多个��L��字符匚w��的是0个及更多个可能字�W�。例如，搜烦test, tests 或�?tester�Q�可以这��P��

test*

您也可以在字�W�窜中间使用多个��L��字符通配�W��?/span>

te*t

注意�Q�您不能在搜索的��开始��?或�?�W�号�?/span>

模糊查询

Lucene支持��Z��Levenshtein Distance与Edit Distance��法的模�p�搜索。要使用模糊搜烦只需要在单独��的最后加上符�?~"。例如搜索拼写类��g��"roam"的项�q�样写：

roam~

�q�次搜烦��找到�Ş如foam和roams的单词�?/span>

注意�Q��用模�p�查询将自动得到增量因子�Q�boost factor�Q��ؓ0.2的搜索结�?

邻近搜烦(Proximity Searches)

Lucene�q�支持查扄��隔一定距��ȝ��单词。邻�q�搜索是在短语最后加上符�?~"。例如在文档中搜索相�?0个单词的"apache"�?jakarta"�Q�这样写�Q?/span>

"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可以讄��在搜索时匚w��的�怼�度。在��的最后加上符�?^"紧接一个数字（增量��|��Q�表�C�搜索时的相似度。增量��D��高，搜烦到的��相兛_��好�?/span>

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�Q�同时您惌��"jakarta"的相兛_��更加好，那么在其后加�?^"�W�号和增量��|��也就是您输入�Q?/span>

jakarta^4 apache

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

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

"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。增量��g��可以��于1�Q�例�?.2�Q�，但必��L��有效的�?/span>

布尔操作�W?/span>

布尔操作�W�可��项通过逻辑操作�q�接��h��。Lucene支持AND, "+", OR, NOT �?"-"�q�些操作�W�。（注意�Q�布��操作符必须全部大写�Q?/span>

OR操作�W�是默认的连接操作符。这意味着如果两个��之间没有布��操作符�Q�就是��用OR操作�W�。OR操作�W�连接两个项�Q�意味着查找含有��L��的文档。这与集合�ƈ�q�算相同。符号||可以代替�W�号OR�?/span>

搜烦含有"jakarta apache" 或�?"jakarta"的文档，可以使用�q�样的查询：

"jakarta apache" jakarta

或�?/span>

"jakarta apache" OR jakarta

AND

AND操作�W�匹配的是两��同时出现的文档。这个与集合交操作相�{�。符�?amp;&可以代替�W�号AND�?/span>

搜烦同时含有"jakarta apache" �?"jakarta lucene"的文档，使用查询�Q?/span>

"jakarta apache" AND "jakarta lucene"

"+"操作�W�或者称为存在操作符�Q�要求符�?+"后的��必��d��文档相应的域中存在�?/span>

搜烦必须含有"jakarta"�Q�可能含�?lucene"的文档，使用查询�Q?/span>

+jakarta apache

NOT

NOT操作�W�排除那些含有NOT�W�号后面��的文档。这和集合的差运��相同。符��P��可以代替�W�号NOT�?/span>

搜烦含有"jakarta apache"�Q�但是不含有"jakarta lucene"的文档，使用查询�Q?/span>

"jakarta apache" NOT "jakarta lucene"

注意�Q�NOT操作�W�不能单独与��用构成查询。例如，以下的查询查不到��M��l�果�Q?/span>

NOT "jakarta apache"

"-"操作�W�或者禁止操作符排除含有"-"后面的相似项的文档�?/span>

搜烦含有"jakarta apache"�Q�但不是"jakarta lucene"�Q��用查询：

"jakarta apache" -"jakarta lucene"

分组�Q?/span>Grouping�Q?/span>

Lucene支持使用圆括��h��l�合字句形成子查询。这对于��x��制查询布��逻辑的�h十分有用�?/span>

搜烦含有"jakarta"或�?apache"�Q�同时含�?website"的文档，使用查询�Q?/span>

(jakartaOR apache) AND website

�q�样��消除了歧义�Q�保证website必须存在�Q�jakarta和apache中之一也存在�?/span>

转义�Ҏ��字符�Q?/span>Escaping Special Characters�Q?/span>

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

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

转义�Ҏ��字符只需在字�W�前加上�W�号",例如搜烦(1+1):2�Q��用查�?/span>

"(1"+1")":2

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

lucene介绍(搜烦引擎)

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

1. 什么是lucene

Apache Lucene是一个开放源�E�序的搜��d��引擎�Q�利用它可以��L��CؓJava软�g加入全文搜寻功能�?/span>Lucene的最主要工作是替文�g的每一个字作烦引，索引让搜�ȝ��效率比传�l�的逐字比较大大提高�Q?/span>Lucen提供一�l�解读，�q��o�Q�分析文�Ӟ��~�排和��用烦引的API�Q�它的强大之处除了高效和��单外�Q�是最重要的是使��用者可以随时应自已需要自订其功能�?/span> Lucene�?/span>apache软�g基金会项目组的一个子��目�Q�是一个开放源代码的全文检索引擎工具包�Q�即它不是一个完整的全文��索引擎，而是一个全文检索引擎的架构�Q�提供了完整的查询引擎和索引引擎�Q�部分文本分析引擎�?/span>Lucene的目的是��Y件开发�h员提供一个简单易用的工具包，以方便的在目标系�l�中实现全文��索的功能�Q�或者是以此为基��建立起完整的全文��索引擎�?/span>

2. Lucene能做什�?/span>

Lucene使你可以��Z��的应用程序添加烦引和搜烦能力�?/span>Lucene可以索引�q�能使得可以转换成文本格式的��M��数据能够被搜索�?/span>Lucene�q�不兛_��数据的来源、格式甚臛_��的语�a��Q�只要你能将它�{换�ؓ文本。这��意味着你可�l�烦引�ƈ搜烦存放于文件中的数据：在远�E�服务器上的web��面�Q�存于本地文件系�l�的文档�Q�简单的文本文�g�Q�微�?/span>Word文档�Q?/span>HTML�?/span>PDF文�g或�Q何其它能够提取出文本信息的格式�?/span>

同样�Q�利�?/span>Lucene你可以烦引存放于数据库中的数据，提供�l�用户很多数据库没有提供的全文搜索的能力。一旦你集成�?/span>Lucene�Q�你的应用程序的用户��p��够像�q�样来搜索：+George +Rice –eat –pudding, Apple –pie +Tiger, animal:monkey AND food:banana�{�等。利�?/span>Lucene�Q�你可以索引和搜�?/span>email邮�g�Q�邮件列表档案，��x��聊天记录�Q�你�?/span>Wiki��面……�{�等更多�?/span>

3. Lucene的优�?/span>

�Q?/span>1�Q�烦引文件格式独立于应用�q�_��?/span>Lucene定义了一套以8位字节�ؓ基础的烦引文件格式，使得兼容�pȝ��或者不同��^台的应用能够�׃�n建立的烦引文件�?/span>

�Q?/span>2�Q�在传统全文��索引擎的倒排索引的基��上，实现了分块烦引，能够针对新的文�g建立��文件烦引，提升索引速度。然后通过与原有烦引的合�ƈ�Q�达��C��化的目的�?/span>Lucene提供了烦引的扩展机制�Q�因此烦引可以动态扩展�?/span>

�Q?/span>4�Q�设计了独立于语�a�和文件格式的文本分析接口�Q�烦引器通过接受Token��完成烦引文件的创立�Q�用��h��展新的语�a�和文件格式，只需要实现文本分析的接口�?/span>

�Q?/span>5�Q�已�l�默认实��C��一套强大的查询引擎�Q�用��h��需自己�~�写代码即�ɾpȝ��可获得强大的查询能力�Q?/span>Lucene的查询实��C��默认实现了布��操作、模�p�查询、分�l�查询等�{��?/span>

�Q?/span>6�Q?span style="color: black">搜烦�q�程优化�?/span>Lucene面向全文��索的优化在于首次索引��索后�Q��ƈ不把所有的记录�Q?/span>Document�Q�具体内容读取出来，而�v只将所有结果中匚w��度最高的�?/span>100条结果（TopDocs�Q�的ID攑ֈ��l�果集缓存中�q�返回�?/span>

�Q?/span>7�Q?/span>Lucene的另外一个特�Ҏ��在收集结果的�q�程中将匚w��度低的结果自动过滤掉了。这也是和数据库应用需要将搜烦的结果全部返回不同之�?/span>

4. 查询相关

Analyzer是分析器�Q�它的作用是把一个字�W�串按某�U�规则划分成一个个词语�Q��ƈ去除其中的无效词语，�q�里说的无效词语是指英文中的“of”�?/span> “the”�Q�中文中�?#8220;�?#8221;�?#8220;�?#8221;�{�词语，�q�些词语在文章中大量出现�Q�但是本�w�不包含什么关键信息，��L��有利于羃��烦引文件、提高效率、提高命中率�?/span>

分词的规则千变万化，但目的只有一个：按语义划分。这点在英文中比较容易实玎ͼ�因�ؓ英文本��n��是以单词�ؓ单位的，已经用空格分开�Q�而中文则必须以某�U�方法将�q�成一片的句子划分成一个个词语�?/span>

(1) 用通配�W�进行搜�?/span>

单个��L��字符匚w��的是所有可能单个字�W�。例如，搜烦"text或�?/span>"test"�Q�可以这��P��te?t

多个��L��字符匚w��的是0个及更多个可能字�W�。例如，搜烦test, tests 或�?/span> tester�Q�可以这��P��test*

您也可以在字�W�窜中间使用多个��L��字符通配�W��?/span>te*t

注意�Q�您不能在搜索的��开始��?/span>*或�?/span>?�W�号�?/span>

(2) 模糊查询

Lucene支持��Z��Levenshtein Distance�?/span>Edit Distance��法的模�p�搜索。要使用模糊搜烦只需要在单独��的最后加上符�?/span>"~"。例如搜索拼写类��g��"roam"的项�q�样写：roam~

�q�次搜烦��找到�Ş�?/span>foam�?/span>roams的单词�?/span>

注意�Q��用模�p�查询将自动得到增量因子�Q?/span>boost factor�Q��ؓ0.2的搜索结�?/span>.

(3) 布尔操作�W?/span>

布尔操作�W�可��项通过逻辑操作�q�接��h��?/span>Lucene支持AND, "+", OR, NOT �?/span> "-"�q�些操作�W�。（注意�Q�布��操作符必须全部大写�Q?/span>

(4) 转义�Ҏ��字符

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

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

转义�Ҏ��字符只需在字�W�前加上�W�号",例如搜烦(1+1):2�Q��用查�?/span>

"(1"+1")":2

5. 一些��用经�?/span>

(1) 关键词区分大��写

OR AND TO�{�关键词是区分大��写的，lucene只认大写的，��写的当做普通单词�?/span>

(2) ��d��互斥�?/span>

同一时刻只能有一个对索引的写操作�Q�在写的同时可以�q�行搜烦�?/span>

(3) 文�g�?/span>

在写索引的过�E�中��退出将�?/span>tmp目录留下一�?/span>lock文�g�Q��以后的写操作无法�q�行�Q�可以将其手工删除�?/span>

(4) 旉��格式

lucene只支持一�U�时间格�?/span>yyMMddHHmmss�Q�所以你传一�?/span>yy-MM-dd HH:mm:ss的时间给lucene它是不会当作旉��来处理的�?/span>

(5) 索引更新

lucene不支持烦引更斎ͼ�必须是先删除再新建烦引，如果数据量很大且更新快则相当�ȝ��Q�本�w�徏立烦引是个�O长的�q�程�Q�同时相当耗内存且很伤disk�Q�不能实时的满��查询�?/span>

(6) 中间取烦�?/span>

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

(7) 英文查询

若查询英文，比如有一句话�Q?/span>jiangxi strong 如果你输�?/span>jiang或�?/span>stron�{�不完整的一个词�Q�将不能查询出结果，当你输入jiangxi或�?/span>strong才能查询出结果�?/span>

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

��单lucene搜烦实现(搜烦引擎)

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

新徏�c�Index.java,代码如下�Q?/span>

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�Q�对�q�行修改的功能进行描�q?br /> *
*
*/

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();

  // 建立索引的�\�?br />      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("=========================");

}

执行�q�个�c�，可以看到�l�果�Q?br />
=========================
375total milliseconds
=========================
create index success!!!

可以看到索引创徏成功�?br />

下面我们来创建搜索类�Q�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�Q�对�q�行修改的功能进行描�q?
*
*
*/

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++)   {
                  //开始输出查询结�?nbsp;
                  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("准确度�ؓ�Q?   +   format.format(hits.score(i)   *   100.0)   +   "%");
//                  System.out.println(doc.get("CONTENT"));
              }

}

}

执行它，会得��C��下结果：

查找到共2个结�?br /> 中华人民共和�?br /> content=标题或正文包�?br /> time=20080715
准确度�ؓ�Q?9.727%
大中国中�?br /> content=null
time=null
准确度�ؓ�Q?9.727%

�q�样��完成了我们的程�?br />
�q�是我第一�ơ发表文�?br /> 说的比较��单，可能很多地方说的不清�?br /> 希望大家多多支持

有什么不明白的欢�q�留�a��?/span>

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

午夜精品视频,8x国产一区二区三区精品推荐,精品欧美一区二区在线观看

lucene索引word/pdf/html/txt文�g及检�?搜烦引擎)

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

lucene介绍(搜烦引擎)

���单lucene搜烦实现(搜烦引擎)

��单lucene搜烦实现(搜烦引擎)