lucene学习（二）

前面我们已经完成了hello world的编写，其实全文检索lucene很简单的，当然主要还是里面自带的一些类我们不熟悉，但是这也没有关系，这些类的方法用起来也很简单，下面是一些教程的截图：

关于排序的一些简单方法：

public QueryResult search(String queryString, int firstResult, int maxResults) {
        try {
            // 1，把要搜索的文本解析为 Query
            String[] fields = { "name", "content" };  
            Map<String, Float> boosts = new HashMap<String, Float>();//（按相关度排序）某个属性的boost的值   （排序）
            boosts.put("name", 3f); //认为标题很重要，权值大
            // boosts.put("content", 1.0f); 默认为1.0f

            QueryParser queryParser = new MultiFieldQueryParser(fields, analyzer, boosts);
            Query query = queryParser.parse(queryString);

            return search(query, firstResult, maxResults);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public QueryResult search(Query query, int firstResult, int maxResults) {
        IndexSearcher indexSearcher = null;

        try {
            // 2，进行查询
            indexSearcher = new IndexSearcher(indexPath);
            Filter filter = new RangeFilter("size", NumberTools.longToString(200)   //文档document的过滤器
                    , NumberTools.longToString(1000), true, true);   //过滤器的效率很低

            // ========== 排序  （默认为相关度排序）
            Sort sort = new Sort();
            sort.setSort(new SortField("size")); // （自定义排序）默认为升序 这个按size的大小排序
            // sort.setSort(new SortField("size", true));  //（自定义排序）按降序排序 这个按size的大小排序
            // ==========

            TopDocs topDocs = indexSearcher.search(query, filter, 10000, sort);

            int recordCount = topDocs.totalHits;

关于lucene的集中查询类：

/**
     * 关键词查询TermQuery
     * 
     * name:room
     */
    @Test
    public void testTermQuery() {
        // Term term = new Term("name", "房间");
        // Term term = new Term("name", "Room"); // 英文关键词全是小写字符
        Term term = new Term("content", "编辑");//属性中的关键字（键值对）
        Query query = new TermQuery(term);

        queryAndPrintResult(query);
    }

    /**
     * 范围查询RangeQuery
     * 
     * 包含边界：size:[0000000000001e TO 000000000000rs]
     * 
     * 不包含边界：size:{0000000000001e TO 000000000000rs}
     */
    @Test
    public void testRangeQuery() {
        Term lowerTerm = new Term("size", NumberTools.longToString(50));//下边界
        Term upperTerm = new Term("size", NumberTools.longToString(100));//上边界
        Query query = new RangeQuery(lowerTerm, upperTerm, false);//false表示不包含边界

        queryAndPrintResult(query);
    }

    // public static void main(String[] args) {
    // System.out.println(Long.MAX_VALUE);
    // System.out.println(NumberTools.longToString(1000));
    // System.out.println(NumberTools.stringToLong("000000000000rs"));
    //
    // System.out.println(DateTools.dateToString(new Date(), Resolution.DAY));
    // System.out.println(DateTools.dateToString(new Date(), Resolution.MINUTE));
    // System.out.println(DateTools.dateToString(new Date(), Resolution.SECOND));
    // }

    /**
     * 通配符查询WildcardQuery
     * 
     * '?' 代表一个字符， '*' 代表0个或多个字符
     * 
     * name:房*
     * 
     * name:*o*
     * 
     * name:roo?
     */
    @Test
    public void testWildcardQuery() {
        Term term = new Term("content", "luc?");
        // Term term = new Term("name", "ro*"); // 前缀查询 PrefixQuery
        // Term term = new Term("name", "*o*");
        // Term term = new Term("name", "房*");
        Query query = new WildcardQuery(term);

        queryAndPrintResult(query);
    }

    /**
     * 短语查询PhraseQuery
     * 
     * content:"? 绅士 ? ? 饭店"
     * 
     * content:"绅士 饭店"~2
     */
    @Test
    public void testPhraseQuery() {
        PhraseQuery phraseQuery = new PhraseQuery();
        // phraseQuery.add(new Term("content", "绅士"), 1);
        // phraseQuery.add(new Term("content", "饭店"), 4);

        phraseQuery.add(new Term("content", "编辑"));
        phraseQuery.add(new Term("content", "lucene"));
        phraseQuery.setSlop(2);

        queryAndPrintResult(phraseQuery);
    }

    /**
     * +content:"绅士 饭店"~2 -size:[000000000000dw TO 000000000000rs]
     * 
     * +content:"绅士 饭店"~2 +size:[000000000000dw TO 000000000000rs]
     * 
     * content:"绅士 饭店"~2 size:[000000000000dw TO 000000000000rs]
     * 
     * +content:"绅士 饭店"~2 size:[000000000000dw TO 000000000000rs]
     */
    @Test
    public void testBooleanQuery() {
        // 条件1
        PhraseQuery query1 = new PhraseQuery();
        query1.add(new Term("content", "绅士"));
        query1.add(new Term("content", "饭店"));
        query1.setSlop(2);

        // 条件2
        Term lowerTerm = new Term("size", NumberTools.longToString(500));
        Term upperTerm = new Term("size", NumberTools.longToString(1000));
        Query query2 = new RangeQuery(lowerTerm, upperTerm, true);

        // 组合
        BooleanQuery boolQuery = new BooleanQuery();
        boolQuery.add(query1, Occur.MUST);
        boolQuery.add(query2, Occur.SHOULD);

        queryAndPrintResult(boolQuery);
    }