代码地址：https://gitee.com/shaojiepeng/wsm-lucene
 ### wsm-lucene
一个简单的Lucene工具类，通过注释的方式来配置构建索引的字段。提供新建索引、查找、删除、更新方法，支持分页。

### 所需jar包
1. lucene-core:2.4.0
2. lucene-analyzers:2.4.1
3. commons-logging:1.2

### 背景
以前在做某个feature的时候，鉴于存储在DB中的数据量过大，故使用Lucene来优化查找性能。
相信大家在某些场景下会把DB中的数据读出来，建索引来优化查找。那么这个工具类就比较适合这些场景了。

### 如何使用
 **从附件中下载jar包直接导入到项目中，或者下载此Maven项目的源码，使用项目依赖的方式导入你的项目。** 

1. 通过注释的方式配置需要构建索引的model类

```
 **@IndexClass** ：注释，说明此model类需要构建索引
 **indexDirPath** ：索引所存放的物理位置，如："D:/Index"

 **@IndexField** ：注释，说明此字段需要构建索引
 **fieldStore** ：Lucene中的Field.Store同义，不懂请自行查询资料
 **fieldIndex** ：Lucene中的Field.Index同义，不懂请自行查询资料
```




2. 创建索引
```

IndexService indexService = new IndexServiceImpl();
/** 构建索引的接口
 * List：model的集合
 * Class: model的class
 *
 * return boolean
**/
indexService.buildIndex(List, Class)
```




3.查找
```
ArrayList<SearchParamModel> searchParams = new ArrayList<>();
/**添加查询的条件，如果有多个查询条件，则添加SearchParamModel
 * fieldName：需要查找的字段，即model中的成员变量
 * fieldValue：需要查找字段的值，这个不解释
 * BooleanType：Lucene中BooleanClause.Occur值，不懂请自行查询资料
**/
searchParams.add(new SearchParamModel(fieldName, fieldValue, BooleanType));
IndexService indexService = new IndexServiceImpl();
/** 查询的接口
 * searchParams：不解释
 * Class: model的class
 *
 * return model的集合
**/
List objs = indexService.search(searchParams, Class);
```





IndexService中还支持update, delete和分页查找的方法，请自行查阅代码。


觉得不错，请点个赞吧。

• 重新看lucene源码
• 看es源码
• 对比lucene和es
• 基于lucene实现自己的搜索框架

前言



我们在使用百度和谷歌等搜索引擎的时候，你会发现，搜索引擎会把和我们输入的关键字以红色的字体显示，来突出显示结果的准确性，这就是高亮显示的使用场景



准备



使用Highlighter需要导入相应的jar包，maven项目可以加入如下依赖



<dependency>

            <groupId>org.apache.lucene</groupId>

            <artifactId>lucene-highlighter</artifactId>

            <version>5.5.0</version>

   </dependency>



直接看代码





/**

 * @author kl by 2016/3/19

 * @boke www.kailing.pub

 */

public class FieldSetBoostTest {

    //索引目录

    String indexDir="E:\\LuceneIndex";

    //测试数据

    String theme="中国";

    String []title={"中国是一个伟大的国家","我爱你的的祖国,美丽的中国","是什么，中国令美日等国虎视眈眈"};

    /**

     * Lucence5.5返回IndexWriter实例

     * @param directory

     * @return

     */

    public IndexWriter getIndexWriter(Directory directory){

        Analyzer analyzer=new CJKAnalyzer();//中日韩二元分词

        IndexWriterConfig writerConfig=new IndexWriterConfig(analyzer);

        IndexWriter writer=null;

        try {

            writer =new IndexWriter(directory,writerConfig);

        }catch (Exception e){

            e.printStackTrace();

        }

        return writer;

    }

    public Directory getDirctory(String indexDir){

        Directory directory=null;

        try {

            directory=FSDirectory.open(Paths.get(indexDir));

        }catch (IOException e){

            e.printStackTrace();

        }

        return directory;

    }

    /**

     * 创建索引不加权

     * @throws Exception

     */

    public void Indexer()throws Exception{

       IndexWriter writer=getIndexWriter(getDirctory(indexDir));

        Document doc=null;

        for(String str:title){

            doc=new Document();

            //Lucence5.5 Fileld有多个实现，StringFIeld不分词  TextField分词

            doc.add(new StringField("theme",theme, Field.Store.YES));

            Field field=new TextField("title",str, Field.Store.YES);

            doc.add(field);

            writer.addDocument(doc);

        }

        writer.close();

    }



    /**

     * 关键命中词高亮输出处理

     * @param query

     * @param context

     * @return

     * @throws Exception

     */

    public static String getHighlighterString(Query query,String context)throws Exception{

        //对促成文档匹配的实际项进行评分

        QueryScorer scorer=new QueryScorer(query);

        //设置高亮的HTML标签格式

        Formatter  simpleHTMLFormatter=new SimpleHTMLFormatter("","");

        //实例化高亮分析器

        Highlighter highlighter=new Highlighter(simpleHTMLFormatter,scorer);

        //提供静态方法，支持从数据源中获取TokenStream，进行token处理

        TokenStream tokenStream=new CJKAnalyzer().tokenStream("title", new StringReader(context));

        return highlighter.getBestFragment(tokenStream, context);

    }

    @Test

    public void searcherTest()throws Exception{

        //  Indexer();

        IndexReader reader= DirectoryReader.open(getDirctory(indexDir));

        IndexSearcher is=new IndexSearcher(reader);

        System.out.println("总的文档数："+reader.numDocs());

        QueryParser qp=new QueryParser("title",new CJKAnalyzer());

        String q="中国";

        Query query=qp.parse(q);

        TopDocs tDocs=is.search(query,11);

        System.out.println("查询-》"+q+"《-总共命中【"+tDocs.totalHits+"】条结果");

        for (ScoreDoc scoredoc:tDocs.scoreDocs){

            Document doc = is.doc(scoredoc.doc);

            String context=doc.get("title");

            if(context!=null){

                System.out.println(getHighlighterString(query,context));

            }



        }

    }

}

查询效果如下：

原文地址：http://www.kailing.pub/article/index/arcid/82.html

前言



任何数据量大的情况下，取数据的时候都需要做分页的处理，比如我们百度的时候，结果往往有上千万的结果，而当前呈现在的只有几页的内容，这就是分页的场景，lucene也提供了分页查询的支持



认识searchafter



使用IndexSearcher的searchafter方法可以轻松实现分页查询，如下图







searchafter有多个重载的方法，其中有些searchafter方法Lucene已不推荐使用了，用的多的就searchAfter(final ScoreDoc after, Query query, int numHits)



它有三个形参，分别是



after:上一页最后一个ScoreDoc；



query：query接口实现类的对象，query对象可以通过QueryParser类来创建，也可以自己new Query接口的某一个特定接口实现类；



numHits:每页显示的条数



searchafter官方文档说明地址



重点在下面



/**

 * Created by 小陈 on 2016/3/25.

 */

public class IndexerPaging {

    //测试数据，模拟数据库表结构

    private static String[] ids={"1","2","3","4","5","6"}; //用户ID

    private static String [] names={"kl","kl","kl","kl","kl","fds"};

    private static String [] describes={"shi yi ge mei nan zi","Don't know","Is an idiot\n","Is an idiot\n","Is an idiot\n","Is an idiot\n"};

    //索引存储地址

    private static String indexDir="E:\\javaEEworkspace\\LuceneDemo\\LuceneIndex";



    /**

     * 获取操作索引实体,并添加测试数据

     * @param indexDir 索引存储位置

     * @return

     * @throws Exception

     */

    public static void getIndexWriter(String indexDir)throws Exception{

        IndexWriterConfig writerConfig=new IndexWriterConfig(getAnalyzer());

        IndexWriter indexWriter=new IndexWriter(FSDirectory.open(Paths.get(indexDir)),writerConfig);

        Document document=new Document();

        //Field.Store.YES或者NO(存储域选项)

        //设置为YES表示或把这个域中的内容完全存储到文件中，方便进行文本的还原

        //设置为NO表示把这个域的内容不存储到文件中，但是可以被索引，此时内容无法完全还原(doc.get)

        for(int i=0;i1){

                 int pageIndexLast=(pageIndex-1)*pageSize-1;

                 TopDocs hits=searcher.search(query,pageIndexLast);

                 if(hits.totalHits>=pageIndexLast)

                     return hits.scoreDocs[pageIndexLast];



             }

             return null;

    }



    public static void searcher(String indexDir,String q,int pageIndex,int pageSize)throws Exception{

        Directory directory= FSDirectory.open(Paths.get(indexDir));

        IndexReader reader= DirectoryReader.open(directory);

        IndexSearcher indexSearcher=new IndexSearcher(reader);

        QueryParser queryParser=new QueryParser("names",new StandardAnalyzer());

        Query query=queryParser.parse(q);

        //分页查询

        TopDocs hits=  indexSearcher.searchAfter(getPageLastScoreDoc(pageIndex,pageSize,query,indexSearcher),query,pageSize);//查询首次的30条

        System.out.println("匹配 "+q+"查询到"+hits.totalHits+"个记录");

        for (ScoreDoc scoreDoc:hits.scoreDocs){

            Document doc=indexSearcher.doc(scoreDoc.doc);

            System.out.println(doc.get("describes"));//打印Document的fileName属性

        }

        reader.close();

        directory.close();//关闭连接

    }

    /**

     * 得到默认分词器

     * @return

     */

    public static Analyzer getAnalyzer(){

        return new StandardAnalyzer();

    }



    @Test

    public void  Test()throws Exception{

//     getIndexWriter(indexDir);

        searcher(indexDir,"kl",1,10);//查询测试

    }



}

原文地址：http://www.kailing.pub/article/index/arcid/80.html