lucene 3.0 sort 类适用--个人看的没做注释

package org.apache.lucene.demo;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

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.document.NumericField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
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.Searcher;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;

public class Test {

	public static void main(String[] args) throws CorruptIndexException,
			LockObtainFailedException, IOException, ParseException {
		List<PoJo> all = getList();
		Directory directory = new RAMDirectory();
		Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
		IndexWriter indexWriter = new IndexWriter(directory, analyzer, true,
				IndexWriter.MaxFieldLength.LIMITED);
		Document document = null;
		Iterator<PoJo> it = all.iterator();
		PoJo pojo = null;
		while (it.hasNext()) {
			pojo = it.next();
			document = new Document();
			document.add(new NumericField("id", Field.Store.YES, true)
					.setIntValue(pojo.getId()));
			document.add(new Field("name", pojo.getName(), Field.Store.YES,
					Field.Index.ANALYZED));
			document.add((new NumericField("order", Field.Store.YES, true)
					.setIntValue(pojo.getOrder())));
			indexWriter.addDocument(document);
		}
		indexWriter.optimize();
		indexWriter.close();

		IndexReader reader = IndexReader.open(directory, true);
		Searcher searcher = new IndexSearcher(reader);
		Sort sort = new Sort() ;
		sort.setSort(new SortField("order", SortField.INT ,true)) ;
		QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "name",
				analyzer);
		Query query = parser.parse("ZB");
		TopDocs results  = searcher.search(query, null, 2000, sort);
		
		for (int i = 0; i < results.scoreDocs.length; i++) {
			Document doc = searcher.doc(results.scoreDocs[i].doc);
			System.out.println(doc.get("id") + "   " + doc.get("name")
					+ "   " + doc.get("order"));
		}
	}

	public static List<PoJo> getList() {
		List<PoJo> all = new ArrayList<PoJo>();
		for (int i = 1; i < 2000; i++) {
			String name = getName(i);
			all.add(new PoJo(i, name + " " + new Random().nextInt(1000),
					new Random().nextInt(1000)));
		}
		return all;
	}

	public static String getName(int i) {
		String name = null;
		switch (i % 5) {
		case 0:
			name = "HB";
			break;
		case 1:
			name = "XJ";
			break;
		case 2:
			name = "XZ";
			break;
		case 3:
			name = "BJ";
			break;
		case 4:
			name = "ZB";
			break;

		default:
			name = "LJ";
		}
		return name;
	}
}

class PoJo {
	private int id;
	private String name;
	private int order;

	public PoJo(int id, String name, int order) {
		this.id = id;
		this.name = name;
		this.order = order;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getOrder() {
		return order;
	}

	public void setOrder(int order) {
		this.order = order;
	}
}

评论

4 楼 cf2huihui 2013-10-15  

ansjsun 写道

cf2huihui 写道

你好，我用两个域进行排序，结果跟目标不一样。用两个域排序的话，只有第一个sortfield起作用，第二个不起作用，但是我单独分开一个一个排序的话，就有效果，你知道是为什么吗？

SortField[] sortArray;  
				sortArray = new SortField[] {new SortField("memberType", SortField.Type.INT,true), new SortField("createdDate", SortField.Type.LONG,true)};
				topDocs = searcher.search(bQuery,20,new Sort(sortArray));

第一个如果相同才按照第二个排序

你好，问题解决了，我后来好好想想发现原因了。我用两个域排序，一个是产品的创建时间，一个是产品的等级，前者是Timestamp类型的，后者是int类型的，数据库查询结果自动给bean赋值，所以两者的数据类型都对。但是，lucene在建立索引的时候，是把数据类型转化为string,所以 问题出现了，既然在lucene中是string ，那么我在SortField中的SortField.type写成long 对于产品的创建时间在索引中是string类型的来说，是无效的，但是昨天测试的时候有时候有效，有时候很混乱，导致我没有发现这个问题。发现之后，就可以解决了，

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
							        Date createDate = null ;
							        try {
										createDate = formatter.parse(value);
									} catch (ParseException e) {
										e.printStackTrace();
									}
							        Long dateLong = createDate.getTime();
							        String fieldValue  =String.valueOf(dateLong);
//									System.out.println("createdDate:"+value);
									doc.add(new Field("createdDate",fieldValue,fieldType));

把string转化为时间类型，再转化为long型，然后转化为string保存，在textfield中按照long排序即可。
好了，说完了，但是觉得很麻烦，问下大神有没有简单点的方法？

3 楼 ansjsun 2013-10-14  

cf2huihui 写道

你好，我用两个域进行排序，结果跟目标不一样。用两个域排序的话，只有第一个sortfield起作用，第二个不起作用，但是我单独分开一个一个排序的话，就有效果，你知道是为什么吗？

SortField[] sortArray;  
				sortArray = new SortField[] {new SortField("memberType", SortField.Type.INT,true), new SortField("createdDate", SortField.Type.LONG,true)};
				topDocs = searcher.search(bQuery,20,new Sort(sortArray));

第一个如果相同才按照第二个排序

2 楼 cf2huihui 2013-10-14  

对了，我用的lucene版本是4.1

1 楼 cf2huihui 2013-10-14  

你好，我用两个域进行排序，结果跟目标不一样。用两个域排序的话，只有第一个sortfield起作用，第二个不起作用，但是我单独分开一个一个排序的话，就有效果，你知道是为什么吗？

SortField[] sortArray;  
				sortArray = new SortField[] {new SortField("memberType", SortField.Type.INT,true), new SortField("createdDate", SortField.Type.LONG,true)};
				topDocs = searcher.search(bQuery,20,new Sort(sortArray));