Lucene自定义排序

package com.lucene.search;
 
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.NumericField;
 import org.apache.lucene.index.CorruptIndexException;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.FSDirectory;
 import org.apache.lucene.util.Version;
 
 import com.chenlb.mmseg4j.Dictionary;
 import com.chenlb.mmseg4j.analysis.ComplexAnalyzer;
 
 public class IndexUtils {
 
     private static Directory directory=null;
     
     static{
         try {
             directory=FSDirectory.open(new File("E:/lucene/files"));
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
     
     public static Directory getDirectory() {
         return directory;
     }
 
     /**
      * 创建索引
      */
     public static void createIndex(){
         IndexWriter writer=null;
         File file=new File("E:/lucene/resource");
         Document document=null;
         try {
             //创建IndexWriter   使用中文分词器
             Dictionary dic=Dictionary.getInstance(new File("F:/官方包/lucene-3.5.0/mmseg4j-1.8.5/data"));
             writer=new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_35,new ComplexAnalyzer(dic)));
             for(File f:file.listFiles()){
                 document=new Document();
                 document.add(new Field("filename", f.getName(), Field.Store.YES, Field.Index.NOT_ANALYZED));
                 document.add(new Field("content",new FileReader(f)));
                 document.add(new NumericField("date", Field.Store.YES, true).setLongValue(f.lastModified()));
                 document.add(new NumericField("size", Field.Store.YES, false).setLongValue(f.length()/1000));
                 writer.addDocument(document);
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (CorruptIndexException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             try {
                 writer.close();
             } catch (CorruptIndexException e) {
                 e.printStackTrace();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
     

 }

######################

package com.lucene.search;
 
 import java.io.IOException;
 import java.sql.Date;
 import java.text.SimpleDateFormat;
 
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.index.CorruptIndexException;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.queryParser.ParseException;
 import org.apache.lucene.queryParser.QueryParser;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.util.Version;
 
 public class SearchUtils {
 
     // 定义IndexReader,并使用静态块加载IndexReader
     private static IndexReader reader = null;
     static {
         try {
             reader = IndexReader.open(IndexUtils.getDirectory());
         } catch (CorruptIndexException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
     // 获取IndexSearcher
     private IndexSearcher getSearcher() {
         try {
             if (reader == null) {
                 reader = IndexReader.open(IndexUtils.getDirectory());
             } else {
                 IndexReader ir = IndexReader.openIfChanged(reader);
                 if (ir != null) {
                     reader.close();
                     reader = ir;
                 }
             }
             return new IndexSearcher(reader);
         } catch (CorruptIndexException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         return null;
     }
 
     /**
      * 排序查询
      *
      * @param querystr
      *            查找匹配的字符串
      * @param domain
      *            查找内容的域
      * @param sort
      *            排序方式
      */
     public void SearchBySort(String querystr, String domain, Sort sort) {
         TopDocs docs = null;
         IndexSearcher searcher = this.getSearcher();
         try {
             QueryParser parser = new QueryParser(Version.LUCENE_35, domain,
                     new StandardAnalyzer(Version.LUCENE_35));
             Query query = parser.parse(querystr);
             if (sort == null) {
                 docs = searcher.search(query, 150);
             } else {
                 docs = searcher.search(query, 150, sort);
             }
 
             // 输出信息
             ScoreDoc[] sds = docs.scoreDocs;
             Document d = null;
             SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
             for (ScoreDoc s : sds) {
                 d = searcher.doc(s.doc);
                 System.out.println(s.doc+"->"
                                     +s.score+"->"
                                     +d.get("filename")+"->"
                                     +d.get("size")+"->"
                                     +sdf.format(new Date(Long.valueOf(d.get("date")))));
             }
 
         } catch (ParseException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

############################

package com.lucene.test;

import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.junit.Before;
import org.junit.Test;

import com.lucene.search.SearchUtils;

public class TestSortSearch {

    private SearchUtils su=null;
    
    @Before
    public void init(){
        su=new SearchUtils();
    }
    
    @Test
    public void testSortSearch(){
        //无排序搜索,默认根据评分降序排序
        //su.SearchBySort("中国", "content", null);
        //通过doc的id进行排序
        //su.SearchBySort("中国", "content", Sort.INDEXORDER);
        //通过评分进行排序
        //su.SearchBySort("中国", "content", Sort.RELEVANCE);
        //根据SortField设置属性对filename进行升序排序
        //su.SearchBySort("中国", "content", new Sort(new SortField("filename", SortField.STRING)));
        //通过根据SortField设置最后一个属性进行降序排序
        su.SearchBySort("中国", "content", new Sort(new SortField("filename", SortField.STRING,true)));
        
    }
}