lucene QueryParser用法示例

package demo.first;

import java.io.IOException;
import java.util.Date;

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.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.store.LockObtainFailedException;

public class TestQueryParser {

    public static void main(String[] args) throws CorruptIndexException, IOException {
        String path = "D://workspace//fwk//lucenedemo//firstLuceneIndex";
        TestQueryParser tqp = new TestQueryParser();
        tqp.createIndex(path);
        Searcher search = tqp.getSearcher(path);
        System.out.println("#_2");
        tqp.testTime(search, tqp.getQueryParser2());
        System.out.println("#_1");
        tqp.testTime(search, tqp.getQueryParser1());
        System.out.println("#_3");
        tqp.testTime(search, tqp.getQueryParser3());
        System.out.println("#_4");
        tqp.testTime(search, tqp.getQueryParser4());
        System.out.println("#_5");
        tqp.testTime(search, tqp.getQueryParser5());
        System.out.println("#_6");
        tqp.testTime(search, tqp.getQueryParser6());
        System.out.println("#_7");
        tqp.testTime(search, tqp.getQueryParser7());
    }

    public void testTime(Searcher search,Query query) throws IOException{
        Date start = new Date();
        Hits hits = search.search(query);
        for (int i = 0; i < hits.length(); i++) {
            System.out.println(hits.id(i));
            System.out.println(hits.doc(i));
            System.out.println(hits.score(i));
        }

        System.out.println("本次搜索用时：" + ((new Date()).getTime() - start.getTime()) + "毫秒");

    }

    public Searcher getSearcher(String path) throws CorruptIndexException, IOException{
            return new IndexSearcher(path);
    }

    public Query getQueryParser1(){
        //默认搜索字段
        QueryParser queryParser = new QueryParser("content", new StandardAnalyzer());
        try {
            return queryParser.parse("搜索 - 擎");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public Query getQueryParser2(){
        QueryParser queryParser = new QueryParser("content", new StandardAnalyzer());
        try {
            return queryParser.parse("欢迎");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public Query getQueryParser3(){
        QueryParser queryParser = new QueryParser("content", new StandardAnalyzer());
        try {
            return queryParser.parse("搜索 and 擎");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public Query getQueryParser4(){
        QueryParser queryParser = new QueryParser("content", new StandardAnalyzer());
        try {
            //content字段搜索 索引   title字段搜寻 你好
            return queryParser.parse("索引 title:你好");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public Query getQueryParser5(){
        QueryParser queryParser = new QueryParser("content", new StandardAnalyzer());
        //允许使用正则表达式方式
        queryParser.setAllowLeadingWildcard(true);
        try {
            return queryParser.parse("*索*");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 采用标准分词器StandardAnalyzer会在创建索引的时候把存入的英文全部换成小写放在索引中 查询的时候也会将查询的关键词转为小写进行查询
     * @return
     */
    public Query getQueryParser6(){
        QueryParser queryParser = new QueryParser("testCapital", new StandardAnalyzer());
        try {
            return queryParser.parse("hellOwangzi");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 采用标准分词器StandardAnalyzer会在创建索引的时候把存入的and or等关键字过滤掉 所以在查询的时候怎么也查不到
     * @return
     */
    public Query getQueryParser7(){
        QueryParser queryParser = new QueryParser("testAndOr", new StandardAnalyzer());
        try {
            //return queryParser.parse("and");
            return queryParser.parse("test");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 创建索引
     * @param path
     */
    public void createIndex(String path){
        try {
            IndexWriter writer = new IndexWriter(path,new StandardAnalyzer(),true);
            Document docA = new Document();
            //相当于数据库中列的概念，因此第一个参数是列名，第二个参数是列的值，最后两个参数是enum类型的(JDK1.5)，对创建的索引的设置
            //Field.Store 是否覆盖原来的索引文件，而不是重新建一个
            Field fieldA = new Field("content","搜索引擎",Field.Store.YES,Field.Index.TOKENIZED);
            //我们把列(fieldA)加到某一行(docA)中
            docA.add(fieldA);

            docA.add(new Field("title","你好中国",Field.Store.YES,Field.Index.TOKENIZED));
            docA.add(new Field("content","欢迎你llying",Field.Store.YES,Field.Index.TOKENIZED));
            docA.add(new Field("lastModifyTime","2008-9-17",Field.Store.YES,Field.Index.TOKENIZED));
            docA.add(new Field("testCapital","HelloWangzi",Field.Store.YES,Field.Index.TOKENIZED));
            docA.add(new Field("testAndOr","test and",Field.Store.YES,Field.Index.TOKENIZED));

            Document docB = new Document();
            //相当于数据库中列的概念，因此第一个参数是列名，第二个参数是列的值，最后两个参数是enum类型的(JDK1.5)，对创建的索引的设置
            Field fieldB = new Field("content","创建索引",Field.Store.YES,Field.Index.TOKENIZED);
            //我们把列(fieldA)加到某一行(docA)中
            docB.add(fieldB);
            docB.add(new Field("title","你好世界",Field.Store.YES,Field.Index.TOKENIZED));
            docB.add(new Field("content","欢迎加入jee高级开发群46176507",Field.Store.YES,Field.Index.TOKENIZED));
            docB.add(new Field("lastModifyTime","2008-9-6",Field.Store.YES,Field.Index.TOKENIZED));
            docB.add(new Field("testCapital","hellowangZi",Field.Store.YES,Field.Index.TOKENIZED));
            docB.add(new Field("testAndOr","test or",Field.Store.YES,Field.Index.TOKENIZED));

            writer.addDocument(docA);
            writer.addDocument(docB);

            //如果对海量数据进行创建索引的时候，需要对索引进行优化，以便提高速度
            writer.optimize();

            //跟数据库类似，打开一个连接，使用完后，要关闭它
            writer.close();
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}