`
thinkerAndThinker
  • 浏览: 284710 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

[lucene]使用lucene建立网站搜索服务

 
阅读更多

lucene是一个全文检索引擎(非分布式),使用java编写并且可以很方便的嵌入到各种系统中以实现全文检索功能,其通过对字符串进行分词,然后针对分词结果分别建立索引,存入内存或者磁盘,以提供搜索服务,这个功能用起来就像是一个单机版的google,模糊匹配的结果会被展示给用户。应用lucene较为出名的就包括了eclipse的帮助系统。

很多时候搜索这个概念会含糊不清,通常意义上对于一个网站的搜索功能是针对于从数据库中捞取数据并通过freemarker或者velocity渲染模板后展示出来,然后搜索的另一个含义,是针对于文件系统而言,将文件的内容进行搜索并读取文件展示出来。那么对于lucene而言,显然更大的用于之地在于后者,虽然前者的功能也是能够实现。
我们可以想象google的服务器不断的定时dump全球Internet的网页,然后放入自己的存储区域,通过检索评级等一系列的复杂算法,建立针对于关键字的索引,当用户输入关键字进行查询的时候,她会根据建立的索引以及评级等信息进行相似度的判断并展现出查询结果。当然具体的过程会远远比这个复杂。这里要说的是建立搜索的这个概念,从简单的数据库查询的思想出脱离出来,建立一个全文检索的概念。

索引可以理解成现实中书籍的目录,通过这个目录可以很快的定位到具体的页数,拿到想要的结果。这个和数据库的索引是一样的功能,都是为了提高效率,然后数据库却无法实现一个高效的模糊匹配,通常而言的%like%语句,是一条一条的数据比对类似于书籍的翻页过程,这样的效率是极其低下而且对于数据库系统而言是很大的性能耗费,尤其是当有多个关键字的时候,多个%like%的查询条件足以让DBA疯掉。

所以对于模糊匹配的查询而言,高效而准确是一个关键的因素。而lucene的优势就是通过对文本进行分词,通过分词得到一系列的关键字以用于建立索引,同时使用自己默认的socre相关度算法进行排序,通常而言如果对于搜索结果有自己特殊的排序要求,可以在使用lucene建立索引之前,先将数据排好序,可以防止lucene默认的排序之外再次进行排序操作。

对于原理性的知识,可以参看网络上的一些文章,google一下看到很多写的都不错,个人不是很擅长写这种原理性的东西,所以下面做一个小实验,来熟悉一下具体的lucene step by step

 

我们的需求是针对于一个网站的帮助系统开发一个搜索功能,用户输入自己希望搜索的问题或者关键字,我们通过lucene进行搜索并展示结果给用户。

 

就是这样简单的一个需求,假设我们的帮助系统的文档是存放在数据库中的,这个数据量在百这个级别,很小的一个数据量。我们先模拟一个小数据量来实现这个功能,如果数据量是百万级那需要进行分布式的索引建立和搜索,那将涉及到其他额外的很多条件和问题解决方案。

我们希望通过这个系统的开发,不但能解决当前的帮助系统的问题,还可以一定程度上解决一些数据量较小的其他搜索问题,所以是势必需要我们去开发一个通用的中间件,并且通过一定的控制手段来注入特定的业务。

要建立索引,我们需要知道面对的数据对象是谁?哪张表?在哪些字段上建立索引?这几个是关键因素,当然还包括了索引文件存放位置等小问题暂且掠过。这几个关键的因素我们需要注入到我们开发的中间件中,通过配置注入的方式隔离具体的业务代码交织。

怎么做呢?如何去从数据库中获取数据并建立索引呢?索引文件以多大的频率更新?

看看代码:

 

[java] view plaincopy
 
  1. package com.normandy.position.common;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.ArrayList;  
  5. import java.util.Arrays;  
  6. import java.util.Collection;  
  7. import java.util.HashMap;  
  8. import java.util.Iterator;  
  9. import java.util.List;  
  10. import java.util.Map;  
  11.   
  12. import org.apache.commons.lang.StringUtils;  
  13. import org.apache.log4j.Logger;  
  14. import org.apache.lucene.analysis.Analyzer;  
  15. import org.apache.lucene.analysis.cjk.CJKAnalyzer;  
  16. import org.apache.lucene.document.Document;  
  17. import org.apache.lucene.document.Field;  
  18. import org.apache.lucene.index.CorruptIndexException;  
  19. import org.apache.lucene.index.IndexReader;  
  20. import org.apache.lucene.index.IndexReader.FieldOption;  
  21. import org.apache.lucene.index.IndexWriter;  
  22. import org.apache.lucene.index.Term;  
  23. import org.apache.lucene.queryParser.ParseException;  
  24. import org.apache.lucene.queryParser.QueryParser;  
  25. import org.apache.lucene.search.Hits;  
  26. import org.apache.lucene.search.IndexSearcher;  
  27. import org.apache.lucene.search.Query;  
  28. import org.apache.lucene.store.LockObtainFailedException;  
  29. import org.springframework.jdbc.core.JdbcTemplate;  
  30.   
  31. /** 
  32.  * 使用lucene进行搜索服务 
  33.  * <p> 
  34.  * 适用于数据量不大的单机搜索服务,对于数据量较大的搜索,建议使用分布式搜索 
  35.  * </p> 
  36.  *  
  37.  * @author quzishen 
  38.  * @version 1.0 
  39.  */  
  40. public class LuceneSearcher implements Runnable {  
  41.     protected final Logger logger = Logger.getLogger(LuceneSearcher.class);  
  42.   
  43.     /** ~~~ 类名 */  
  44.     private String className;  
  45.     /** ~~~ 需要建立索引的域列表字符串,以“,”隔开 */  
  46.     private String fieldsStr;  
  47.     /** ~~~ 默认的索引存放目录 */  
  48.     private String defaultIndexDir = "c:/index/";  
  49.     /** ~~~ 配置中需要索引字段的默认分隔符 */  
  50.     private static final String DEFAULT_KEY_FIELD_SPLIT = ",";  
  51.     /** ~~~ 默认的标记符名称,如果fieldsStr中含有主键,则使用主键名称*/  
  52.     private static final String DEFAULT_ID = "id";  
  53.     /** ~~~ 是否每次重新建立索引 */  
  54.     private boolean IS_REBUILD_INDEX = true;  
  55.     /** ~~~ 默认的建立索引的最大数目 */  
  56.     private int DEFAULT_MAX_INDEX_NUMS = Integer.MAX_VALUE;  
  57.     /** ~~~ 特别针对于匿名内部类提供的操作jdbc模板 */  
  58.     private JdbcTemplate jdbcTemplate;  
  59.   
  60.     /** 
  61.      * 建立索引,初始化操作 
  62.      *  
  63.      * @throws RuntimeException 
  64.      */  
  65.     public void initIndex() throws RuntimeException {  
  66.         if (StringUtils.isBlank(fieldsStr) || StringUtils.isBlank(className)) {  
  67.             throw new RuntimeException("can not build the index by null value of field and className.");  
  68.         }  
  69.   
  70.         long beginTime = System.currentTimeMillis();  
  71.         if (logger.isInfoEnabled()) {  
  72.             logger.info("begin to build the lucene index...");  
  73.         }  
  74.   
  75.         Analyzer analyzer = new CJKAnalyzer();  
  76.         try {  
  77.             // 获取需要建立索引的域  
  78.             List<String> fieldList = getKeyWordsList();  
  79.               
  80.             IndexWriter indexWriter = new IndexWriter(defaultIndexDir, analyzer, IS_REBUILD_INDEX);  
  81.             // 控制写入一个新的segment前在内存中保存的最大的document数目  
  82.             indexWriter.setMaxBufferedDocs(500);  
  83.             // 控制多个segment合并的频率  
  84.             indexWriter.setMaxMergeDocs(100);  
  85.   
  86.             buildIndex(fieldList,indexWriter);  
  87.   
  88.             indexWriter.optimize();  
  89.             indexWriter.close();  
  90.             long endTime = System.currentTimeMillis();  
  91.             if (logger.isInfoEnabled()) {  
  92.                 logger.info("end to build the lucene index...,use time :"  
  93.                         + (endTime - beginTime) + "ms.");  
  94.             }  
  95.   
  96.         } catch (IOException e) {  
  97.             logger.error("create index failed!check the authentation!", e);  
  98.             throw new RuntimeException("create index failed!check the authentation!", e);  
  99.         } catch (ClassNotFoundException e) {  
  100.             logger.error("class not found : " + className, e);  
  101.             throw new RuntimeException("class not found : " + className, e);  
  102.         }  
  103.     }  
  104.   
  105.     /** 
  106.      * 重新建立索引 
  107.      */  
  108.     public void run() {  
  109.         if(logger.isDebugEnabled()){  
  110.             logger.debug("rebuild the index for lucene start...");  
  111.         }  
  112.         long begin = System.currentTimeMillis();  
  113.           
  114.         removeAllIndex();  
  115.         initIndex();  
  116.           
  117.         long end = System.currentTimeMillis();  
  118.         if(logger.isDebugEnabled()){  
  119.             logger.debug("rebuild the index for lucene end..."+(end - begin)+"ms.");  
  120.         }  
  121.     }  
  122.   
  123.     /** 
  124.      * 重新建立索引 
  125.      * @throws RuntimeException 
  126.      */  
  127.     public void refreshIndex() throws RuntimeException {  
  128.         new Thread(this).start();  
  129.     }  
  130.   
  131.     /** 
  132.      * 删除所有的索引,将根据主键一次性全部删除 
  133.      * @throws RuntimeException 
  134.      */  
  135.     @SuppressWarnings("unchecked")  
  136.     public void removeAllIndex() throws RuntimeException {  
  137.         try {  
  138.             // reader  
  139.             IndexReader indexReader = IndexReader.open(defaultIndexDir);  
  140.             Analyzer analyzer = new CJKAnalyzer();  
  141.             IndexWriter indexWriter = new IndexWriter(defaultIndexDir,analyzer);  
  142.             // 获取所有的索引名称集合  
  143.             Collection<String> indexs = indexReader.getFieldNames(FieldOption.INDEXED);  
  144.             // 检查是否包含主键  
  145.             String keyName = getKeyName();  
  146.             if(!indexs.contains(keyName)){  
  147.                 return;  
  148.             }  
  149.             // 遍历并删除  
  150.             int maxDocNum = indexReader.maxDoc();  
  151.             for(int k = 0;k < maxDocNum ;k++){  
  152.                 Document document = indexReader.document(k);  
  153.                 String value = document.get(keyName);  
  154.                 Term term = new Term(keyName,value);  
  155.                 indexWriter.deleteDocuments(term);  
  156.                 if(logger.isDebugEnabled()){  
  157.                     logger.debug("delete the index of ["+keyName+","+value+"]");  
  158.                 }  
  159.                   
  160.                 logger.error("delete the index of ["+keyName+","+value+"]");  
  161.             }  
  162.               
  163.             indexWriter.optimize();  
  164.             indexWriter.close();  
  165.             indexReader.flush();  
  166.             indexReader.close();  
  167.         } catch (CorruptIndexException e) {  
  168.             logger.error("create index failed!", e);  
  169.             throw new RuntimeException("create index failed!",e);  
  170.         } catch (LockObtainFailedException e) {  
  171.             logger.error("create index failed!", e);  
  172.             throw new RuntimeException("create index failed!",e);  
  173.         } catch (IOException e) {  
  174.             logger.error("create index failed!check the authentation!", e);  
  175.             throw new RuntimeException("create index failed!",e);  
  176.         } catch (ClassNotFoundException e) {  
  177.             logger.error("class not found!", e);  
  178.             throw new RuntimeException("create index failed!",e);  
  179.         }  
  180.     }  
  181.           
  182.     /** 
  183.      * 从数据库中取出数据,建立索引用于全文检索 
  184.      * @param fieldList 建立索引的字段列表 
  185.      * @param indexWriter 
  186.      * @throws RuntimeException 
  187.      */  
  188.     @SuppressWarnings("unchecked")  
  189.     private void buildIndex(List<String> fieldList,IndexWriter indexWriter) throws RuntimeException{  
  190.         try{  
  191.             // 获取类型  
  192.             Class<? extends Object> objectClass = Class.forName(className);  
  193.             // 匿名内部类  
  194.             AbstractBaseDAO abstractBaseDAO = new AbstractBaseDAO() {  
  195.             };  
  196.             abstractBaseDAO.setJdbcTemplate(jdbcTemplate);  
  197.             // 获取第一页  
  198.             Paginal<? extends Object> paginal = abstractBaseDAO.queryFieldsListForPaging(objectClass, null, fieldList, 11000);  
  199.             // 修正分页总数,如果搜索结果总数超过最大值,则使用最大值  
  200.             int totalCount = paginal.getTotalCount();  
  201.             totalCount = totalCount > DEFAULT_MAX_INDEX_NUMS ? DEFAULT_MAX_INDEX_NUMS : totalCount;  
  202.             paginal.setTotalCount(totalCount);  
  203.             // 需要分页的数目  
  204.             int pageNum = paginal.getPageNum();  
  205.             // 循环从数据库分页读取数据  
  206.             for (int i = 0; i < pageNum; i++) {  
  207.                 // 查询结果列表  
  208.                 List<? extends Object> resultList = paginal.getResultList();  
  209.                 Iterator<? extends Object> resultIndex = resultList.iterator();  
  210.       
  211.                 while (resultIndex.hasNext()) {  
  212.                     // 每一个新建document,防止field重名覆盖  
  213.                     Document document = new Document();  
  214.                     Object object = resultIndex.next();  
  215.                     Iterator<String> fieldIndex = fieldList.iterator();  
  216.                       
  217.                     while (fieldIndex.hasNext()) {  
  218.                         // 获取需要分页的域  
  219.                         String field = fieldIndex.next();  
  220.                         // 过滤空白  
  221.                         if (StringUtils.isBlank(field)) {  
  222.                             continue;  
  223.                         }  
  224.                         // 获取值  
  225.                         Object value = ((Map<String, Object>) object).get(field);  
  226.                         // 写入doc  
  227.                         document.add(new Field(field, value.toString(), Field.Store.YES, Field.Index.TOKENIZED));  
  228.                     }  
  229.                     // 写入索引文件  
  230.                     indexWriter.addDocument(document);  
  231.                 }//while  
  232.             }//for  
  233.         } catch (CorruptIndexException e) {  
  234.             logger.error("create index failed!", e);  
  235.             throw new RuntimeException("create index failed!",e);  
  236.         } catch (LockObtainFailedException e) {  
  237.             logger.error("create index failed!", e);  
  238.             throw new RuntimeException("create index failed!",e);  
  239.         } catch (IOException e) {  
  240.             logger.error("create index failed!check the authentation!", e);  
  241.             throw new RuntimeException("create index failed!",e);  
  242.         } catch (ClassNotFoundException e) {  
  243.             logger.error("class not found!", e);  
  244.             throw new RuntimeException("create index failed!",e);  
  245.         }  
  246.     }  
  247.       
  248.     /** 
  249.      * 查询服务 
  250.      * @param keywords 查询字 
  251.      * @return 
  252.      */  
  253.     public List<Map<String,String>> search(String keywords){  
  254.         //~~~ return value  
  255.         List<Map<String,String>> result = new ArrayList<Map<String,String>>();  
  256.           
  257.         try {  
  258.             // 搜索执行器  
  259.             IndexSearcher indexSearcher = new IndexSearcher(defaultIndexDir);  
  260.             // 分词器  
  261.             Analyzer analyzer = new CJKAnalyzer();  
  262.             // 关键字列表  
  263.             List<String> keyWordsList = getKeyWordsList();  
  264.               
  265.             for(String indexName : keyWordsList){  
  266.                 QueryParser queryParser = new QueryParser(indexName,analyzer);  
  267.                 Query query = queryParser.parse(keywords);  
  268.                 Hits hits = indexSearcher.search(query);  
  269.                 if(logger.isDebugEnabled()){  
  270.                     logger.debug("search result count:"+hits.length());  
  271.                 }  
  272.                   
  273.                 for(int i=0;i<hits.length();i++){  
  274.                     Document document = hits.doc(i);  
  275.                     Map<String,String> resultMap = new HashMap<String,String>();  
  276.                     for(String field : keyWordsList){  
  277.                         if(StringUtils.isBlank(field)){  
  278.                             continue;  
  279.                         }  
  280.                         String value = document.get(field);  
  281.                         resultMap.put(field, value);  
  282.                     }  
  283.                       
  284.                     result.add(resultMap);  
  285.                 }  
  286.             }  
  287.               
  288.         } catch (CorruptIndexException e) {  
  289.             logger.error("create index failed!", e);  
  290.             throw new RuntimeException("create index failed!",e);  
  291.         } catch (LockObtainFailedException e) {  
  292.             logger.error("create index failed!", e);  
  293.             throw new RuntimeException("create index failed!",e);  
  294.         } catch (IOException e) {  
  295.             logger.error("create index failed!check the authentation!", e);  
  296.             throw new RuntimeException("create index failed!",e);  
  297.         } catch (ClassNotFoundException e) {  
  298.             logger.error("class not found!", e);  
  299.             throw new RuntimeException("create index failed!",e);  
  300.         } catch (ParseException e) {  
  301.             logger.error("parse keyword exception!", e);  
  302.             throw new RuntimeException("parse keyword exception!",e);  
  303.         }  
  304.           
  305.         return result;  
  306.     }  
  307.       
  308.     /** 
  309.      * 获取配置的主键名称 
  310.      */  
  311.     @SuppressWarnings({ "rawtypes""unchecked" })  
  312.     private String getKeyName() throws ClassNotFoundException{  
  313.         Class objectClass = Class.forName(className);  
  314.         Table table = (Table) objectClass.getAnnotation(Table.class);  
  315.         String keyName = table.keyField();  
  316.         return StringUtils.isBlank(keyName)? DEFAULT_ID : keyName.toLowerCase();  
  317.     }  
  318.       
  319.     /** 
  320.      * 根据配置的关键字串获取关键字列表,自动补全主键 
  321.      */  
  322.     private List<String> getKeyWordsList() throws ClassNotFoundException{  
  323.         // 获取需要建立索引的域  
  324.         String[] fields = StringUtils.split(fieldsStr.toLowerCase(), DEFAULT_KEY_FIELD_SPLIT);  
  325.         // 转换成列表形式  
  326.         List<String> fieldList = Arrays.asList(fields);  
  327.         // 如果配置的索引字段串不包含主键,则手动添加主键,也就是主键必须创建索引用于标示doc  
  328.         String keyName = getKeyName();  
  329.         if(!fieldList.contains(keyName)){  
  330.             fieldList.add(keyName);  
  331.         }  
  332.           
  333.         return fieldList;  
  334.     }  
  335.   
  336.     // ~~~~~~~~~~~~~~~~~~~~~getter && setter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~***//  
  337.     public void setClassName(String className) {  
  338.         this.className = className;  
  339.     }  
  340.   
  341.     public void setFieldsStr(String fieldsStr) {  
  342.         this.fieldsStr = fieldsStr;  
  343.     }  
  344.   
  345.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
  346.         this.jdbcTemplate = jdbcTemplate;  
  347.     }  
  348.   
  349.     public void setDefaultIndexDir(String defaultIndexDir) {  
  350.         this.defaultIndexDir = defaultIndexDir;  
  351.     }  
  352. }  

 

 

这个是我们的中间件,提供的是索引建立、索引更新和搜索服务,其中有几个变量如className指明了要针对哪个Do对象所对应的表来建立全文检索,fieldsStr指明了需要建立索引的字段,以逗号分开,其他的参数也都很简单。

我们需要根据配置的字段去查询数据库已完成索引的建立工作,那么如何获取呢?我们说过不希望通过显示的业务代码来完成,所以这里使用了前段时间开发的一个jdbcTemplate的封装抽象类,其中的查询字段列表的方法来得到特定字段值的列表,为了不显示的使用业务DAO,我们使用了一个匿名内部类来完成。具体的过程可以参见前面的文章。其中与之有所不同的是,在删除索引的时候,我们需要有一个类似于记录ID的标志位来标记唯一约束,以防止误删的情况,这里由于数据来自于数据库,所以很自然的我们选择使用数据库记录ID,如果用户配置的索引串中没有配置ID,那我们将通过注解的方式自动获取其配置在DO类中的ID名称,如果注解中也没配置,那么将使用默认的名称“id”。

看看我们的注解:

 

[java] view plaincopy
 
  1. package com.normandy.position.common;  
  2.   
  3. import java.lang.annotation.Documented;  
  4. import java.lang.annotation.ElementType;  
  5. import java.lang.annotation.Retention;  
  6. import java.lang.annotation.RetentionPolicy;  
  7. import java.lang.annotation.Target;  
  8.   
  9. /** 
  10.  * 针对于数据库表的配置的注解 
  11.  *  
  12.  * 工程名称:NormandyPosition    
  13.  * 类型名称:Table    
  14.  * 概要: 
  15.  * <p> 目前主要用于配置数据库表名,主键名 </p>      
  16.  * 创建时间:2010-7-28 上午10:40:42    
  17.  * 创建人:quzishen    
  18.  * 最后修改时间:2010-7-28 上午10:40:42    
  19.  * 最后修改内容:    
  20.  * @version 1.0 
  21.  */  
  22. @Documented  
  23. @Retention(RetentionPolicy.RUNTIME)  
  24. @Target(ElementType.TYPE)  
  25. public @interface Table {  
  26.     /**~~~~ 表名*/  
  27.     String tableName() default("table");  
  28.     /**~~~~ 主键名称*/  
  29.     String keyField() default("id");  
  30. }  

 

看看用法:

 

[java] view plaincopy
 
  1. package com.normandy.position.domain;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.Date;  
  5.   
  6. import com.normandy.position.common.Table;  
  7.   
  8. @Table(tableName = "NOR_QUICK_NEWS",keyField="id")  
  9. public class NorQuickNews implements Serializable {  
  10.     private static final long serialVersionUID = -4777096683339361256L;  
  11.     private long id;  
  12.     private String prop1;  
  13.     private String prop2;  
  14.     private String prop3;  
  15.     private String prop4;  
  16.     private String prop5;  
  17.     private String prop6;  
  18.     private String prop7;  
  19.     private String prop8;  
  20.     private String prop9;  
  21.     private String name;  
  22.     private Date gmt_Create;  
  23.   
  24.     public long getId() {  
  25.         return id;  
  26.     }  
  27.   
  28.     public void setId(long id) {  
  29.         this.id = id;  
  30.     }  
  31.   
  32.     public String getProp1() {  
  33.         return prop1;  
  34.     }  
  35.   
  36.     public void setProp1(String prop1) {  
  37.         this.prop1 = prop1;  
  38.     }  
  39.   
  40.     public String getProp2() {  
  41.         return prop2;  
  42.     }  
  43.   
  44.     public void setProp2(String prop2) {  
  45.         this.prop2 = prop2;  
  46.     }  
  47.   
  48.     public String getProp3() {  
  49.         return prop3;  
  50.     }  
  51.   
  52.     public void setProp3(String prop3) {  
  53.         this.prop3 = prop3;  
  54.     }  
  55.   
  56.     public String getProp4() {  
  57.         return prop4;  
  58.     }  
  59.   
  60.     public void setProp4(String prop4) {  
  61.         this.prop4 = prop4;  
  62.     }  
  63.   
  64.     public String getProp5() {  
  65.         return prop5;  
  66.     }  
  67.   
  68.     public void setProp5(String prop5) {  
  69.         this.prop5 = prop5;  
  70.     }  
  71.   
  72.     public String getProp6() {  
  73.         return prop6;  
  74.     }  
  75.   
  76.     public void setProp6(String prop6) {  
  77.         this.prop6 = prop6;  
  78.     }  
  79.   
  80.     public String getProp7() {  
  81.         return prop7;  
  82.     }  
  83.   
  84.     public void setProp7(String prop7) {  
  85.         this.prop7 = prop7;  
  86.     }  
  87.   
  88.     public String getProp8() {  
  89.         return prop8;  
  90.     }  
  91.   
  92.     public void setProp8(String prop8) {  
  93.         this.prop8 = prop8;  
  94.     }  
  95.   
  96.     public String getProp9() {  
  97.         return prop9;  
  98.     }  
  99.   
  100.     public void setProp9(String prop9) {  
  101.         this.prop9 = prop9;  
  102.     }  
  103.   
  104.     public String getName() {  
  105.         return name;  
  106.     }  
  107.   
  108.     public void setName(String name) {  
  109.         this.name = name;  
  110.     }  
  111.   
  112.     public Date getGmt_Create() {  
  113.         return gmt_Create;  
  114.     }  
  115.   
  116.     public void setGmt_Create(Date gmt_Create) {  
  117.         this.gmt_Create = gmt_Create;  
  118.     }  
  119.   
  120. }  

 

配置文件中,我们添加相关的配置:

 

[java] view plaincopy
 
  1. <bean id="luceneSearcher" class="com.normandy.position.common.LuceneSearcher" depends-on="jdbcTemplate">  
  2.     <property name="defaultIndexDir">  
  3.         <value>${lucene.index.dir}</value>  
  4.     </property>  
  5.     <property name="className" value="com.normandy.position.domain.NorQuickNews" />  
  6.     <property name="fieldsStr" value="id,prop1,prop2" />  
  7. </bean>  

 

为了完成自动刷新,我们添加配置任务:

 

[xhtml] view plaincopy
 
  1. <bean id="timetaskScheduler"  
  2.     class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
  3.     <property name="triggers">  
  4.         <list>  
  5.             <ref local="luceneTrigger" />  
  6.         </list>  
  7.     </property>  
  8.     <property name="autoStartup">  
  9.         <value>true</value>  
  10.     </property>  
  11.     <property name="schedulerName">  
  12.         <value>timetaskScheduler</value>  
  13.     </property>  
  14. </bean>  
  15.   
  16. <bean id="luceneTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
  17.     <property name="jobDetail">  
  18.         <bean  
  19.             class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
  20.             <property name="targetObject" ref="luceneSearcher" />  
  21.             <property name="targetMethod" value="refreshIndex" />  
  22.         </bean>  
  23.     </property>  
  24.     <property name="cronExpression" value="0 */15 * * * ?" />  
  25. </bean>  

 

 

这样就完成了开发工作。系统启动先建立索引,然后每隔15分钟将刷新一次索引。自动刷新我们的策略是删除所有的索引,重新建立索引,这个特别针对于数据量较小的操作,如果数据量稍微大一些,不推荐采用这种方式,我们需要进行一个自动识别的工作,只刷新变更过的记录,而不要过多的开销系统来重新全部重建。这里由于数据量较小,所以为了方便,我们直接删除所有索引重新建立。在后续的工作中,我们将重点研究如何精准刷新。

看看单元测试代码:

 

[java] view plaincopy
 
  1. package com.normandy.positiontest;  
  2.   
  3. import java.util.List;  
  4. import java.util.Map;  
  5.   
  6. import junit.framework.TestCase;  
  7.   
  8. import org.springframework.context.ApplicationContext;  
  9. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  10. import org.springframework.jdbc.core.JdbcTemplate;  
  11.   
  12. import com.normandy.position.common.LuceneSearcher;  
  13.   
  14. public class LuceneSearcherTest extends TestCase {  
  15.     private LuceneSearcher luceneSearcher;  
  16.     private JdbcTemplate jdbcTemplate;  
  17.   
  18.     @Override  
  19.     protected void setUp() throws Exception {  
  20.         super.setUp();  
  21.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(  
  22.                 "com/normandy/positiontest/applicationContext.xml");  
  23.         luceneSearcher = (LuceneSearcher) applicationContext  
  24.                 .getBean("luceneSearcher");  
  25.         jdbcTemplate = (JdbcTemplate)applicationContext.getBean("jdbcTemplate");  
  26.         luceneSearcher.setJdbcTemplate(jdbcTemplate);  
  27.     }  
  28.       
  29.     public void testInit(){  
  30.         luceneSearcher.initIndex();  
  31.     }  
  32.       
  33.     public void testRemoveAllIndex(){  
  34.         luceneSearcher.removeAllIndex();  
  35.     }  
  36.       
  37.     public void testRefreshIndex(){  
  38.         luceneSearcher.refreshIndex();  
  39.     }  
  40.       
  41.     public void testSearch(){  
  42.         List<Map<String,String>> list = luceneSearcher.search("prop1");  
  43.         System.out.println(list.size());  
  44.     }  
  45. }  

 

 

万里长征只走了第一步,剩下的事情还有很多,这个只是最简单的一个例子,万事开头难,在熟练应用的基础上进行二次开发或者源码分析将是接下来的主要工作思路。

分享到:
评论

相关推荐

    Lucene使用代码实例之搜索文档

    《Lucene使用代码实例之搜索文档》 Lucene是一个高性能、全文检索库,它提供了强大的文本分析和索引功能,广泛应用于搜索引擎开发和其他需要高效文本处理的场景。本篇文章主要面向初学者,通过实例详细解释如何使用...

    lucene 对 xml建立索引

    ### Lucene对XML文档建立索引的技术解析与实践 #### 一、引言 随着互联网技术的迅猛发展,非结构化数据(如XML文档)在企业和组织中的应用日益广泛。如何高效地处理这些非结构化的数据,特别是进行快速检索成为了一...

    lucene详细使用教程

    Lucene 提供了索引和搜索文档的基本框架,包括分词、建立倒排索引、查询解析、结果排序等功能。 **安装与配置** 在使用 Lucene 之前,首先需要将其添加到项目依赖中。如果你使用的是 Maven,可以在 pom.xml 文件中...

    用lucene对数据库建立索引及搜索

    **使用Lucene对数据库建立索引及搜索** Lucene是一个高性能、可伸缩的信息检索库,它是Apache软件基金会的顶级项目之一。它提供了一个简单但功能强大的API,用于在各种数据源上创建全文搜索引擎,包括数据库。在本...

    用Lucene.net对数据库建立索引及搜索

    《使用Lucene.NET对数据库建立索引及搜索》 在信息技术领域,搜索引擎是不可或缺的一部分,尤其是在处理大量数据时。Lucene.NET是一个强大的全文搜索引擎库,它允许开发人员在应用程序中集成高级搜索功能。本文将...

    最简单的Lucene建立、搜索索引的方法

    **Lucene简介** Lucene是Apache软件基金会的一个开放源代码项目,它是一个高性能、全文本检索库,...通过上述步骤,你可以在MyEclipse10环境下使用Lucene快速建立和搜索索引,为你的应用程序添加强大的全文检索功能。

    lucene站内搜索

    2. **分词(Tokenization)**: Lucene使用Analyzer对输入文本进行分词,将长句子拆分成独立的单词或短语,这是建立索引的基础。 3. **文档(Document)**: 在Lucene中,每个要搜索的信息被视为一个Document,包含多...

    Lucene结合Sql建立索引

    Lucene的使用者不需要深入了解有关全文检索的知识,仅仅学会使用库中的一个类,你就为你的应用实现全文检索的功能. 不过千万别以为Lucene是一个象google那样的搜索引擎,Lucene甚至不是一个应用程序,它仅仅是一个工具,...

    Lucene3.1使用教程

    对于站内搜索,例如在BBS或BLOG中,你可以创建一个索引,将所有文章的标题和内容作为字段,利用Lucene的API建立索引。当用户输入搜索词时,通过查询API查找匹配的文章,并按照相关性返回结果。 ### 五、总结 ...

    Lucene原理及使用总结

    【Lucene简介】 Lucene是一个基于Java的全文信息检索工具包,它被广泛应用于构建搜索引擎和文本检索系统。...通过理解Lucene的基本原理和使用方法,我们可以构建出高效、灵活的全文搜索引擎,满足各种信息检索需求。

    Lucene.NET结合Sql建立全文检索Demo源码

    **Lucene.NET结合Sql建立全文检索** Lucene.NET是一个开源的全文搜索引擎库,它是Apache Lucene项目的一部分,专为.NET Framework设计。这个项目的目标是提供一个高性能、可扩展且易于使用的全文检索API。在.NET...

    使用Lucene.net进行全文搜索

    本文将深入探讨如何使用Lucene.NET进行全文搜索,特别是针对多关键字匹配的场景。 首先,我们需要了解Lucene.NET的基本概念。Lucene是一个开源的文本搜索库,它的核心功能包括文档索引、搜索和排序。Lucene.NET是这...

    开发自己的搜索引擎 lucene + heritrix

    4. 使用Lucene建立索引系统。这部分工作包括为抓取的数据建立全文索引,并对索引进行优化,以支持快速有效的搜索。 5. 设计用户界面。一个友好的用户界面对于用户体验至关重要,需要设计直观、易用的搜索界面。 6. ...

    lucene 高级搜索项目

    通过以上分析,我们可以看出这个“Lucene 高级搜索项目”全面覆盖了Lucene的核心技术,从基础的索引创建到复杂的附件搜索和全文搜索,再到插件开发和Solr的使用,为学习和实践Lucene提供了丰富的素材。

    用LUCENE连击MYSQL建立索引并搜索的JAVA代码。

    总之,使用Lucene和MySQL联合开发的Java应用程序能够提供高效、灵活的搜索体验,这对于处理大量结构化文本数据的系统来说是极其重要的。通过掌握这种技术,开发者可以构建出满足用户需求的高性能搜索解决方案。

    lucene的简单介绍以及使用

    它不是一个可以直接使用的应用程序,而是一个为开发者提供构建全文搜索功能的底层库,核心库为 lucene-core-2.2.0.jar。Lucene 提供了丰富的 API 和工具,帮助开发人员在各种应用中实现高效的全文检索功能。 **...

    Lucene检索文本,建立索引

    在这个场景中,我们将探讨如何利用Lucene来检索文本并建立索引,同时结合Struts框架构建一个Web程序。 首先,**Lucene** 是一个开源的Java库,它提供了完整的搜索功能,包括分词、索引创建、查询解析和结果排序。它...

    ssm+lucene

    - 使用Lucene的Analyzer对文本进行分词处理。 - 建立倒排索引并保存到硬盘或内存中。 - 实现搜索接口,用户输入关键词后,通过Lucene的QueryParser解析查询,并执行搜索。 - 返回搜索结果,通常会结合SpringMVC...

    lucene全文检索简单索引和搜索实例

    《Lucene全文检索:简单索引与搜索实例详解》 Lucene是Apache软件基金会的开源项目,是一款强大的全文检索库,被广泛应用于Java开发中,为开发者提供了构建高性能搜索引擎的能力。在本文中,我们将深入探讨如何基于...

Global site tag (gtag.js) - Google Analytics