2007-08-10

自己写的lucene的高亮类

网上有很多高亮的类，但我觉得太负责了（也许他们觉得这样性能更高），我写了一个很简单采用je分词+正则解决高亮问题，实际使用下来还是不错的：

java 代码
  1. import java.util.Iterator;   
  2. import java.util.List;   
  3.   
  4. /**  
  5.  * @author edwardpro  
  6.  *   
  7.  */  
  8. public class HighlightProcess {   
  9.   
  10.     /**  
  11.      *   
  12.      */  
  13.     private String str;   
  14.   
  15.     private String key;   
  16.   
  17.     private static final String HIGH_LIGHT = "<span class=\"red\">$1</span>";   
  18.   
  19.     public HighlightProcess(String str, String key) {   
  20.         // TODO Auto-generated constructor stub   
  21.         this.str = str;   
  22.         this.key = key;   
  23.     }   
  24.   
  25.     /**  
  26.      * @return the str  
  27.      */  
  28.     public String getStr() {   
  29.         return str;   
  30.     }   
  31.   
  32.     /**  
  33.      * @param str  
  34.      *            the str to set  
  35.      */  
  36.     public void setStr(String str) {   
  37.         this.str = str;   
  38.     }   
  39.   
  40.     public String getResult() {   
  41.   
  42.         List<String> list = WordsManager.splitStrToList(key);   
  43.         for (Iterator it = list.iterator(); it.hasNext();) {   
  44.             String target = (String) it.next();   
  45.             this.str = RegxTools.regxReplace(this.str, target, HIGH_LIGHT);   
  46.         }   
  47.         return this.str;   
  48.     }   
  49.   
  50. }  

分词这边使用了一个工厂方法，用来装载词库的，返回的是JE分词对象：

java 代码
  1. import java.io.File;   
  2. import java.io.FileNotFoundException;   
  3. import java.io.FileReader;   
  4. import java.io.IOException;   
  5. import java.util.ArrayList;   
  6. import java.util.Iterator;   
  7. import java.util.List;   
  8. import java.util.StringTokenizer;   
  9.   
  10. import jeasy.analysis.MMAnalyzer;   
  11.   
  12. import org.apache.log4j.Logger;   
  13.   
  14.   
  15. public class WordsManager {   
  16.   
  17.     private static final Logger logger = Logger.getLogger(WordsManager.class);   
  18.   
  19.     private static MMAnalyzer mmanalyzer;   
  20.   
  21.     private static final String DEF_SPT = "<>";   
  22.   
  23.     static {   
  24.         init();   
  25.     }   
  26.   
  27.     private static void init() {   
  28.         reload();   
  29.         mmanalyzer = new MMAnalyzer();   
  30.     }   
  31.   
  32.     public static void reload() {   
  33.         if (AppInit.getScb().getExtDic() != null  
  34.                 && !AppInit.getScb().getExtDic().equalsIgnoreCase("")) {   
  35.             File dir = new File(AppInit.getScb().getExtDic());   
  36.             File[] dics = dir.listFiles();   
  37.             // add dict file   
  38.             for (int i = 0; i < dics.length; i++) {   
  39.                 try {   
  40.                     MMAnalyzer.addDictionary(new FileReader(dics[i]));   
  41.                 } catch (FileNotFoundException e) {   
  42.                     // TODO Auto-generated catch block   
  43.                     logger.error("Read File Error", e);   
  44.                 }   
  45.             }   
  46.         }   
  47.     }   
  48.   
  49.     /**  
  50.      * @return the mmanalyzer  
  51.      */  
  52.     public static MMAnalyzer getMmanalyzer() {   
  53.         return mmanalyzer;   
  54.     }   
  55.   
  56.     /**  
  57.      * @param mmanalyzer  
  58.      *            the mmanalyzer to set  
  59.      */  
  60.     public static void setMmanalyzer(MMAnalyzer mmanalyzer) {   
  61.         WordsManager.mmanalyzer = mmanalyzer;   
  62.     }   
  63.   
  64.     public static String[] splitStrToArray(String source) {   
  65.         try {   
  66.             String target = mmanalyzer.segment(source, DEF_SPT);   
  67.             String[] ts = target.split(DEF_SPT);   
  68.             return ts;   
  69.         } catch (IOException e) {   
  70.             // TODO Auto-generated catch block   
  71.             e.printStackTrace();   
  72.         }   
  73.         return null;   
  74.     }   
  75.   
  76.     public static List<String> splitStrToList(String source) {   
  77.         List<String> ret = new ArrayList<String>();   
  78.         try {   
  79.             String target = mmanalyzer.segment(source, DEF_SPT);   
  80.             StringTokenizer st = new StringTokenizer(target, DEF_SPT);   
  81.             for (; st.hasMoreTokens();) {   
  82.                 ret.add(st.nextToken());   
  83.             }   
  84.         } catch (IOException e) {   
  85.             // TODO Auto-generated catch block   
  86.             logger.error("segment error", e);   
  87.         }   
  88.         return ret;   
  89.   
  90.     }   
  91.   
  92.     public static void removeTag(String content) {   
  93.         MMAnalyzer.removeWord(content);   
  94.     }   
  95. }   

正则方法：

java 代码
  1. String reg="<span class='red'>$1</span>";  
java 代码
  1. public static String regxReplace(String str, String key, String rep) {   
  2.     Pattern p = Pattern.compile("(" + key + ")", Pattern.CASE_INSENSITIVE);   
  3.     Matcher m = p.matcher(str);   
  4.     return m.replaceAll(rep);   
  5. }  

原理很简单，利用分词分开，然后用这则一个个匹配掉目标中的关键字，由于实际中大部分都是替换标题和200字的描述所以并没有使用流方法，下次有时间改用流或者stringbuffer或者其他更接近分词的方法来做下看看，有什么问题，欢迎大家拍砖

评论
gw_noah 2008-01-08
[/u][/color][color=orange][/color][color=red][color=greens][/color][u]
引用
[b][/b][i][/i]
    

  • 

    

  1. 

[img][/img][url][/url][align=left][/align][size=xx-small][/size]




    
  

  
    

      
发表评论

      

        
  






        
您还没有登录，请登录后发表评论 


    

  
    





        

        
        

          

          

            
            
edwardpro

          

          

            
            
搜索本博客


              
              

          

          
          
          

            
最近加入圈子

            
          

            

              
存档

              
            

          

            
最新评论