实现像百度一样的自动补全功能

import java.io.IOException;

import java.io.Reader;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;



import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.analysis.LowerCaseFilter;

import org.apache.lucene.analysis.StopFilter;

import org.apache.lucene.analysis.TokenStream;

import org.apache.lucene.analysis.standard.StandardFilter;

import org.apache.lucene.analysis.standard.StandardTokenizer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.CorruptIndexException;

import org.apache.lucene.index.IndexReader;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.Term;

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.TermQuery;

import org.apache.lucene.search.TopDocs;

import org.apache.lucene.store.Directory;

import org.apache.lucene.store.FSDirectory;



public class Sugesstion {



private static final String GRAMMED_WORDS_FIELD = "words";



private static final String SOURCE_WORD_FIELD = "sourceWord";



private static final String COUNT_FIELD = "count";



private static final String[] ENGLISH_STOP_WORDS = {

"a", "an", "and", "are", "as", "at", "be", "but", "by",

"for", "i", "if", "in", "into", "is",

"no", "not", "of", "on", "or", "s", "such",

"t", "that", "the", "their", "then", "there", "these",

"they", "this", "to", "was", "will", "with"

};



private final Directory autoCompleteDirectory;



private IndexReader autoCompleteReader;



private IndexSearcher autoCompleteSearcher;



public Sugesstion(String autoCompleteDir) throws IOException {

this.autoCompleteDirectory = FSDirectory.getDirectory(autoCompleteDir,

null);



reOpenReader();

}



public List<String> suggestTermsFor(String term) throws IOException {

// get the top 5 terms for query

Query query = new TermQuery(new Term(GRAMMED_WORDS_FIELD, term));

Sort sort = new Sort(COUNT_FIELD, true);



TopDocs docs = autoCompleteSearcher.search(query, null, 5, sort);

List<String> suggestions = new ArrayList<String>();

for (ScoreDoc doc : docs.scoreDocs) {

suggestions.add(autoCompleteReader.document(doc.doc).get(

SOURCE_WORD_FIELD));

}



return suggestions;

}



@SuppressWarnings("unchecked")

public void reIndex(Directory sourceDirectory, String fieldToAutocomplete)

throws CorruptIndexException, IOException {

// build a dictionary (from the spell package)

IndexReader sourceReader = IndexReader.open(sourceDirectory);



LuceneDictionary dict = new LuceneDictionary(sourceReader,

fieldToAutocomplete);



// code from

// org.apache.lucene.search.spell.SpellChecker.indexDictionary(

// Dictionary)

IndexReader.unlock(autoCompleteDirectory);



// use a custom analyzer so we can do EdgeNGramFiltering

IndexWriter writer = new IndexWriter(autoCompleteDirectory,

new Analyzer() {

public TokenStream tokenStream(String fieldName,

Reader reader) {

TokenStream result = new StandardTokenizer(reader);



result = new StandardFilter(result);

result = new LowerCaseFilter(result);

result = new ISOLatin1AccentFilter(result);

result = new StopFilter(result,

ENGLISH_STOP_WORDS);

result = new EdgeNGramTokenFilter(

result, Side.FRONT,1, 20);



return result;

}

}, true);



writer.setMergeFactor(300);

writer.setMaxBufferedDocs(150);



// go through every word, storing the original word (incl. n-grams)

// and the number of times it occurs

Map<String, Integer> wordsMap = new HashMap<String, Integer>();



Iterator<String> iter = (Iterator<String>) dict.getWordsIterator();

while (iter.hasNext()) {

String word = iter.next();



int len = word.length();

if (len < 3) {

continue; // too short we bail but "too long" is fine...

}



if (wordsMap.containsKey(word)) {

throw new IllegalStateException(

"This should never happen in Lucene 2.3.2");

// wordsMap.put(word, wordsMap.get(word) + 1);

} else {

// use the number of documents this word appears in

wordsMap.put(word, sourceReader.docFreq(new Term(

fieldToAutocomplete, word)));

}

}



for (String word : wordsMap.keySet()) {

// ok index the word

Document doc = new Document();

doc.add(new Field(SOURCE_WORD_FIELD, word, Field.Store.YES,

Field.Index.UN_TOKENIZED)); // orig term

doc.add(new Field(GRAMMED_WORDS_FIELD, word, Field.Store.YES,

Field.Index.TOKENIZED)); // grammed

doc.add(new Field(COUNT_FIELD,

Integer.toString(wordsMap.get(word)), Field.Store.NO,

Field.Index.UN_TOKENIZED)); // count



writer.addDocument(doc);

}



sourceReader.close();



// close writer

writer.optimize();

writer.close();



// re-open our reader

reOpenReader();

}



private void reOpenReader() throws CorruptIndexException, IOException {

if (autoCompleteReader == null) {

autoCompleteReader = IndexReader.open(autoCompleteDirectory);

} else {

autoCompleteReader.reopen();

}



autoCompleteSearcher = new IndexSearcher(autoCompleteReader);

}



public static void main(String[] args) throws Exception {

Sugesstion autocomplete = new Sugesstion("/index/autocomplete");



// run this to re-index from the current index, shouldn't need to do

// this very often

// autocomplete.reIndex(FSDirectory.getDirectory("/index/live", null),

// "content");



String term = "steve";



System.out.println(autocomplete.suggestTermsFor(term));

// prints [steve, steven, stevens, stevenson, stevenage]

}

}