lucene searchafter分页

package com.gaibuy.foundation.lucene;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.DoubleField;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.IntField;
import org.apache.lucene.document.LongField;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.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.search.highlight.Highlighter;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.SimpleFragmenter;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.jsoup.Jsoup;
import org.jsoup.safety.Whitelist;
import org.wltea.analyzer.lucene.IKAnalyzer;

/**
 * 商品lucene工具类
 * 
 */
public class GoodsLuceneUtil {
    private static File index_file = null;
    private static Analyzer analyzer;
    private static QueryParser parser;
    private static String index_path;
    private int textmaxlength = 2000;
    private static String prefixHTML = "<font color='red'>";
    private static String suffixHTML = "</font>";

    public GoodsLuceneUtil(String indexPath) {
        index_path = indexPath;
        analyzer = new IKAnalyzer(true);
        parser = new QueryParser(Version.LUCENE_4_9, GoodsLuceneVo.TITLE, analyzer);
    }

    public void setIndex_path(String path) {
        index_path = path;
    }

    /**
     * 创建索引阅读器
     * 
     * @param directoryPath
     *            索引目录
     * @return
     * @throws IOException
     *             可能会抛出IO异常
     */
    public static IndexReader createIndexReader(String index_path) throws IOException {
        return DirectoryReader.open(FSDirectory.open(new File(index_path)));
    }

    /**
     * 创建索引查询器
     * 
     * @param directoryPath
     *            索引目录
     * @return
     * @throws IOException
     */
    public static IndexSearcher createIndexSearcher(String index_path) throws IOException {
        return new IndexSearcher(createIndexReader(index_path));
    }

    /**
     * 创建索引查询器
     * 
     * @param reader
     * @return
     */
    public static IndexSearcher createIndexSearcher(IndexReader reader) {
        return new IndexSearcher(reader);
    }

    /**
     * Lucene分页查询
     * 
     * @param directoryPath
     * @param query
     * @param page
     * @throws IOException
     */
    public static void pageQuery(Query query, LuceneResult result, Sort sort) throws IOException {
        IndexSearcher searcher = createIndexSearcher(index_path);
        result.setRows(searchTotalRecord(searcher, query));
        ScoreDoc after = getLastScoreDoc(result.getCurrentPage(), result.getPageSize(), query, searcher, sort);

        TopDocs topDocs = searcher.searchAfter(after, query, result.getPageSize(), sort);
        // 设置总记录数
        List<Document> docList = new ArrayList<Document>();
        System.out.println(topDocs.totalHits + "topDocs.totalHits.......................");
        ScoreDoc[] docs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : docs) {
            int docID = scoreDoc.doc;
            Document document = searcher.doc(docID);
            docList.add(document);
        }
        result.setDoc_list(docList);
        searcher.getIndexReader().close();
    }

    /**
     * 商品搜索
     * 
     * @param params
     * @param directoryPath
     * @param begin_price
     * @param end_price
     * @param result
     * @param sort
     * @return
     * @throws ParseException
     * @throws IOException
     */
    public LuceneResult goodsPage(String params, double begin_price, double end_price, LuceneResult result, Sort sort)
            throws ParseException, IOException {
        // 组件参数
        params = goodsBuilderParams(params, begin_price, end_price);
        try {
            parser.setAllowLeadingWildcard(true);
            Query query = parser.parse(params);
            pageQuery(query, result, sort);
            List<GoodsLuceneVo> goodsVoList = builderVoList(result.getDoc_list(), query);
            result.setGoodsVo_list(goodsVoList);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 创建索引
     * 
     * @param list
     * @throws IOException
     */
    public void writeIndex(List<GoodsLuceneVo> list) throws IOException {
        IndexWriter writer = openIndexWriter();
        try {
            for (GoodsLuceneVo lucenceVo : list) {
                Document document = builderDocument(lucenceVo);
                writer.addDocument(document);
            }
            writer.commit();
        } finally {
            writer.close();
        }
    }

    /**
     * 创建索引
     * 
     * @param vo
     */
    public void writeIndex(GoodsLuceneVo vo) {
        IndexWriter writer = null;
        try {
            writer = openIndexWriter();
            Document document = builderDocument(vo);
            writer.addDocument(document);
            // writer.optimize();
        } catch (IOException e1) {
            e1.printStackTrace();
            try {
                writer.close();
            } catch (CorruptIndexException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } finally {
            try {
                writer.close();
            } catch (CorruptIndexException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 更新索引
     * 
     * @param id
     * @param vo
     */
    public void update(String id, GoodsLuceneVo vo) {
        try {
            index_file = new File(index_path);
            Directory directory = FSDirectory.open(index_file);
            IndexWriterConfig writerConfig = new IndexWriterConfig(Version.LUCENE_4_9, analyzer);
            IndexWriter writer = new IndexWriter(directory, writerConfig);
            Document doc = builderDocument(vo);
            Term term = new Term(GoodsLuceneVo.ID, String.valueOf(id));
            writer.updateDocument(term, doc);
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除文档
     * 
     * @param id
     */
    public void delete_index(String id) {
        try {
            index_file = new File(index_path);
            Directory directory = FSDirectory.open(index_file);
            IndexWriterConfig writerConfig = new IndexWriterConfig(Version.LUCENE_4_9, analyzer);
            IndexWriter writer = new IndexWriter(directory, writerConfig);
            Term term = new Term(GoodsLuceneVo.ID, String.valueOf(id));
            writer.deleteDocuments(term);
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除所有索引
     * 
     * @param isdeletefile
     *            是否删除文件
     */
    public void deleteAllIndex(boolean isdeletefile) {
        IndexWriter indexWriter = null;
        index_file = new File(index_path);
        if ((index_file.exists()) && (index_file.isDirectory())) {
            try {
                IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_4_9, analyzer);
                indexWriter = new IndexWriter(FSDirectory.open(index_file), iwc);
                indexWriter.deleteAll();

            } catch (Exception ex) {
                ex.printStackTrace();

                if (indexWriter != null)
                    try {
                        indexWriter.close();
                    } catch (IOException localIOException) {
                    }
            } finally {
                if (indexWriter != null)
                    try {
                        indexWriter.close();
                    } catch (IOException localIOException1) {
                    }
            }
            if (isdeletefile) {

                deleteAllFile();
            }
        }
    }

    /**
     * 删除索引文件
     */
    private void deleteAllFile() {
        index_file = new File(index_path);
        File[] files = index_file.listFiles();
        for (int i = 0; i < files.length; i++)
            files[i].delete();

    }

    /**
     * 打开indexwriter
     * 
     * @return
     * @throws IOException
     */
    private IndexWriter openIndexWriter() throws IOException {
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_9, analyzer);

        index_file = new File(index_path);
        indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
        IndexWriter writer = new IndexWriter(FSDirectory.open(index_file), indexWriterConfig);
        return writer;
    }

    /**
     * 组件document
     * 
     * @param goodsLuceneVo
     * @return
     */
    private Document builderDocument(GoodsLuceneVo goodsLuceneVo) {
        Document document = new Document();
        Field id = new LongField(GoodsLuceneVo.ID, goodsLuceneVo.getVo_id(), Store.YES);
                                                        //jsoup.clean 去掉里边的HTML代码
        Field title = new TextField(GoodsLuceneVo.TITLE, Jsoup.clean(goodsLuceneVo.getVo_title(), Whitelist.none()), Store.YES);
        Field content = new TextField(GoodsLuceneVo.CONTENT, Jsoup.clean(goodsLuceneVo.getVo_content(), Whitelist.none()),
                Store.YES);
        Field type = new StringField(GoodsLuceneVo.TYPE, goodsLuceneVo.getVo_type(), Store.YES);
        Field store_price = new DoubleField(GoodsLuceneVo.STORE_PRICE, goodsLuceneVo.getVo_store_price(), Store.YES);
        Field add_time = new LongField(GoodsLuceneVo.ADD_TIME, goodsLuceneVo.getVo_add_time(), Store.YES);
        Field goods_salenum = new IntField(GoodsLuceneVo.GOODS_SALENUM, goodsLuceneVo.getVo_goods_salenum(), Store.YES);
        document.add(id);
        document.add(title);
        document.add(content);
        document.add(type);
        document.add(store_price);
        document.add(add_time);
        document.add(goods_salenum);
        return document;
    }

    /**
     * 组件vo，包括高亮
     * 
     * @param doc
     * @param query
     * @param vo
     * @throws Exception
     */
    private void builderVo(Document doc, Query query, GoodsLuceneVo vo) throws Exception {
        SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter(prefixHTML, suffixHTML);
        Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));

        highlighter.setTextFragmenter(new SimpleFragmenter(this.textmaxlength));
        String content = highlighter.getBestFragment(analyzer, GoodsLuceneVo.CONTENT, doc.get(GoodsLuceneVo.CONTENT));
        String title = highlighter.getBestFragment(analyzer, GoodsLuceneVo.TITLE, doc.get(GoodsLuceneVo.TITLE));
        if (content == null)
            vo.setVo_content(doc.get(GoodsLuceneVo.CONTENT));
        else {
            vo.setVo_content(content);
        }
        if (title == null) {
            vo.setVo_title(doc.get(GoodsLuceneVo.TITLE));
        } else {
            vo.setVo_title(title);
        }
        vo.setVo_id(Long.valueOf(doc.get(GoodsLuceneVo.ID)));
        vo.setVo_url(doc.get(GoodsLuceneVo.URL));
        vo.setVo_add_time(Long.valueOf(doc.get(GoodsLuceneVo.ADD_TIME)));
        vo.setVo_store_price(Double.valueOf(doc.get(GoodsLuceneVo.STORE_PRICE)));
    }

    /**
     * 组件volist
     * 
     * @param documents
     * @param query
     * @return
     */
    private List<GoodsLuceneVo> builderVoList(List<Document> documents, Query query) {
        List<GoodsLuceneVo> goodsVoList = new ArrayList<GoodsLuceneVo>();
        try {
            for (Document document : documents) {
                GoodsLuceneVo vo = new GoodsLuceneVo();
                builderVo(document, query, vo);
                goodsVoList.add(vo);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return goodsVoList;
    }

    /**
     * 商品参数组装
     * 
     * @param params
     * @param begin_price
     * @param end_price
     * @return
     */
    private String goodsBuilderParams(String params, double begin_price, double end_price) {
        if (params.indexOf(GoodsLuceneVo.TITLE + ":") < 0) {
            params = "(" + GoodsLuceneVo.TITLE + ":" + params + " OR " + GoodsLuceneVo.CONTENT + ":" + params + ")";
        }
        if ((begin_price >= 0.0D) && (end_price > 0.0D)) {
            params = params + " AND" + GoodsLuceneVo.STORE_PRICE + ":[" + begin_price + " TO " + end_price + "]";
        }
        return params;
    }

    /**
     * @Title: searchTotalRecord
     * @Description: 获取符合条件的总记录数
     * @param query
     * @return
     * @throws IOException
     */
    public static int searchTotalRecord(IndexSearcher searcher, Query query) throws IOException {
        TopDocs topDocs = searcher.search(query, Integer.MAX_VALUE);
        if (topDocs == null || topDocs.scoreDocs == null || topDocs.scoreDocs.length == 0) {
            return 0;
        }
        // ScoreDoc[] docs = topDocs.scoreDocs;
        return topDocs.totalHits;
    }

    /**
     * 根据页码和分页大小获取上一次的最后一个ScoreDoc 获取这个scoreDoc的时候，如果有排序，一定加上排序（sort） 否则会出现ScoreDoc 无法转换FieldDoc的错误
     */
    private static ScoreDoc getLastScoreDoc(int pageIndex, int pageSize, Query query, IndexSearcher searcher, Sort sort)
            throws IOException {
        if (pageIndex == 1)
            return null;// 如果是第一页就返回空
        int num = pageSize * (pageIndex - 1);// 获取上一页的数量
        TopDocs tds = searcher.search(query, num, sort);
        return tds.scoreDocs[num - 1];
    }
}

package com.gaibuy.foundation.lucene;

public class StoreLuceneVo {
    public static final String STORE_ID = "store_id";
    public static final String STORE_ADD_TIME = "store_add_time";
    public static final String STORE_TITLE = "store_title";
    public static final String STORE_CLASS = "store_class";
    public static final String STORE_CONTENT = "store_content";
    public static final String STORE_RECOMMEND = "store_recommend";
    public static final String STORE_AREA_TYPE = "store_area_type";
    public static final String CARD_APPROVE = "card_approve";
    public static final String REALSTORE_APPROVE = "realstore_approve";
    public static final String STORE_FAVORITE_COUNT = "store_favorite_count";
    public static final String STORE_CREDIT = "store_credit";
    public static final String STORE_GRADE = "store_grade";
    public static final String STORE_POINT = "store_point";
    public static final String STORE_AREA = "store_area";

    private Long store_id;
    private int store_area_type;
    private String store_title;
    private String store_content;
    private Long store_add_time;
    /** 推荐 */
    private String store_recommend;
    /** 实名认证 */
    private String card_approve;
    /** 实体店认证 */
    private String realstore_approve;
    /** 收藏数量 */
    private int store_favorite_count;
    /** 店铺信用 */
    private int store_credit;
    /** 级别 */
    private int store_grade;
    /** 好评率 */
    private Double store_point;
    /** 地区 */
    private Long store_area;
    /** 分类 */
    private Long store_class;

    public Long getStore_id() {
        return store_id;
    }

    public void setStore_id(Long store_id) {
        this.store_id = store_id;
    }

    public int getStore_area_type() {
        return store_area_type;
    }

    public void setStore_area_type(int store_area_type) {
        this.store_area_type = store_area_type;
    }

    public String getStore_title() {
        return store_title;
    }

    public void setStore_title(String store_title) {
        this.store_title = store_title;
    }

    public String getStore_content() {
        return store_content;
    }

    public void setStore_content(String store_content) {
        this.store_content = store_content;
    }

    public Long getStore_add_time() {
        return store_add_time;
    }

    public void setStore_add_time(Long store_add_time) {
        this.store_add_time = store_add_time;
    }

    public String getStore_recommend() {
        return store_recommend;
    }

    public void setStore_recommend(String store_recommend) {
        this.store_recommend = store_recommend;
    }

    public String getCard_approve() {
        return card_approve;
    }

    public void setCard_approve(String card_approve) {
        this.card_approve = card_approve;
    }

    public String getRealstore_approve() {
        return realstore_approve;
    }

    public void setRealstore_approve(String realstore_approve) {
        this.realstore_approve = realstore_approve;
    }

    public int getStore_favorite_count() {
        return store_favorite_count;
    }

    public void setStore_favorite_count(int store_favorite_count) {
        this.store_favorite_count = store_favorite_count;
    }

    public int getStore_credit() {
        return store_credit;
    }

    public void setStore_credit(int store_credit) {
        this.store_credit = store_credit;
    }

    public int getStore_grade() {
        return store_grade;
    }

    public void setStore_grade(int store_grade) {
        this.store_grade = store_grade;
    }

    public Double getStore_point() {
        return store_point;
    }

    public void setStore_point(Double store_point) {
        this.store_point = store_point;
    }

    public Long getStore_area() {
        return store_area;
    }

    public void setStore_area(Long store_area) {
        this.store_area = store_area;
    }

    public Long getStore_class() {
        return store_class;
    }

    public void setStore_class(Long store_class) {
        this.store_class = store_class;
    }

}

package com.gaibuy.foundation.lucene;

import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.document.Document;

public class LuceneResult {
    private List<Document> doc_list = new ArrayList<Document>();
    private List<GoodsLuceneVo> goodsVo_list = new ArrayList<GoodsLuceneVo>();
    private List<StoreLuceneVo> storeVo_list = new ArrayList<StoreLuceneVo>();
    private int pages;
    private int rows;
    private int currentPage;
    private int pageSize = 10;

    public LuceneResult(int currentPage, int pageSize) {
        this.currentPage = currentPage;
        this.pageSize = pageSize;
    }

    public List<GoodsLuceneVo> getGoodsVo_list() {
        return goodsVo_list;
    }

    public void setGoodsVo_list(List<GoodsLuceneVo> goodsVo_list) {
        this.goodsVo_list = goodsVo_list;
    }

    public List<StoreLuceneVo> getStoreVo_list() {
        return storeVo_list;
    }

    public void setStoreVo_list(List<StoreLuceneVo> storeVo_list) {
        this.storeVo_list = storeVo_list;
    }

    public List<Document> getDoc_list() {
        return doc_list;
    }

    public void setDoc_list(List<Document> doc_list) {
        this.doc_list = doc_list;
    }

    public int getPages() {
        int totalRecord = getRows();
        if (totalRecord == 0) {
            pages = 0;
        } else {
            int pageSize = getPageSize();
            pages = totalRecord % pageSize == 0 ? totalRecord / pageSize : (totalRecord / pageSize) + 1;
        }
        return this.pages;
    }

    public void setPages(int pages) {
        this.pages = pages;
    }

    public int getRows() {
        return this.rows;
    }

    public void setRows(int rows) {
        this.rows = rows;
        pages = rows / pageSize;
    }

    public int getCurrentPage() {
        if (currentPage <= 0) {
            currentPage = 1;
        } else {
            int totalPage = getPages();
            if (totalPage > 0 && currentPage > totalPage) {
                currentPage = totalPage;
            }
        }
        return this.currentPage;
    }

    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = 10;
        }
        return this.pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

}