lucene+heritrix day1

Question

package ear.lucenedemo.process;import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;import jeasy.analysis.MMAnalyzer;/**
 * 
 * @author smileWater
 * function 为要搜索的文件创建一个索引文件
 * 通常使用lucene的步骤如下：
 *1.为要处理的内容建立索引(有时可能在建立索引以前，要对文档做一些预处理工作)
 *2.构建查询的对象
 *3.利用查询对象在索引中查找
 */
public class IndexProcesser {
 //成员变量，存储创建的索引文件要存放的位置
 private String INDEX_STORE_PATH="d:\\lucene\\luceneIndex";
 public static void main(String[] args){
  IndexProcesser indexProcessor=new IndexProcesser();
  long startTime=System.currentTimeMillis();
  indexProcessor.createIndex("d:\\lucene\\luceneData\\");
  long endTime=System.currentTimeMillis();
  System.out.println("The time for create index is "+(endTime-startTime)+" ms.");
 }
 //创建索引
 /*
  * inputDir:要索引的文件存放的位置
  */
 public void createIndex(String inputDir){
  try {
   //以MMAnalyzer作为分词工具创建一个IndexWriter
   IndexWriter writer=new IndexWriter(INDEX_STORE_PATH,new MMAnalyzer(),true);
   File filesDir=new File(inputDir);
   
   //取得所有需要建立文件索引的文件数组
   File[] files=filesDir.listFiles();
   
   //遍历数组
   for(int i=0;i<files.length;i++){
    //获取文件名
    String fileName=files[i].getName();
    //判断是否是txt类型的文件
    if(fileName.substring(fileName.lastIndexOf(".")).equals(".txt")){
     //创建一个Document
     Document doc=new Document();
     
     //为文名字创建一个域field
     //Field.Store.YES表示该Field需要存储
     //Field.Store.NO 表示该Field不需要存储
     //Field.Index.No表示该Field不需要被索引，也就是用户不需要查找该Field的值
     //Field.Index.TOKENIZED表示该Field先 被分词在索引
     //Field.Index.UN_TOKENIZED表示不对该Field分词，但是要对他进行索引
     Field field=new Field("filename",files[i].getName(),Field.Store.YES,
       Field.Index.TOKENIZED);
     doc.add(field);
     
     //为文件内容创建一个域field
     field=new Field("content",loadFileToString(files[i]),Field.Store.NO,
       Field.Index.TOKENIZED);
     
     doc.add(field);
     writer.addDocument(doc);
    }
   }
   //关闭IndexWriter,一定要关闭索引
   //如果没有关闭就会发现索引目录内除了segments文件外一无所有
   writer.close();
   
   
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 public String loadFileToString(File file){
  try {
   BufferedReader br=new BufferedReader(new FileReader(file));
   StringBuffer sb=new StringBuffer();
   String line=br.readLine();
   while(line!=null){
    sb.append(line);
    line=br.readLine();
   }
   br.close();
   return sb.toString();
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   return null;
  }
 }
} package ear.lucenedemo.process;import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;/**
 * 
 * @author ffshi
 * function:针对建立好的索引提供搜索的类
 */
public class Search {
 // 全局变量，索引所处的路径
 private String INDEX_STORE_PATH="d:\\lucene\\luceneIndex";
 
 public static void main(String args[]){
  Search search=new Search();
  search.indexSearch("content","那个");
  System.out.println("***************************************************************");
  search.StringSearch("那个", "d:\\lucene\\luceneData");
 }
 
 //利用lucene API进行搜索
 public void indexSearch(String searchType,String searchKey){
  try {
   //根据索引路径建立IndexSearcher
   IndexSearcher searcher=new IndexSearcher(INDEX_STORE_PATH);
   
   //建立搜索单元，searchType代表搜索的Field，searchKey代表关键字
   Term t=new Term(searchType,searchKey);
   
   //有Term生成一个Query
   Query q=new TermQuery(t);
   
   long startTime=System.currentTimeMillis();
   //获取一个<document,frequency>的枚举对象TermDocs
   TermDocs termDocs=searcher.getIndexReader().termDocs(t);
   while(termDocs.next()){
    //输出文档中出现关键词的次数
    System.out.println(termDocs.freq());
    
    //输出搜索到关键词的文档
    System.out.println(searcher.getIndexReader().document(termDocs.doc()));
   }
   long endTime=System.currentTimeMillis();
   
   long timeOfSearch=endTime-startTime;
   System.out.println("The time for index search is "+timeOfSearch+" ms");
  
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 
 //不用lucene进行的搜索，也就是不创建索引进行搜索，直接用String自带的匹配功能
 // 可以看一下搜索用时 pk 一下lucene
 /**
  * keyword:要搜索的关键字
  * searchDir：要搜索的范围，即是指定在那个目录下进行搜索
  */
 public void StringSearch(String keyword,String searchDir){
  File fileDir=new File(searchDir);
  //返回该文件夹下面的所有文件数组
  File[] files=fileDir.listFiles();
  
  //用HashMap保存文件名和匹配次数对
  Map rs=new HashMap();
  
  long startTime=System.currentTimeMillis();
  
  //开始遍历所有文件
  for(int i=0;i<files.length;i++){
   //初始化匹配次数
   int hits=0;
   try {
    BufferedReader br=new BufferedReader(new FileReader(files[i]));
    StringBuffer sb=new StringBuffer();
    String line=br.readLine();
    while(line!=null){
     sb.append(line);
     line=br.readLine();
 
    }
    br.close();
    String stringToSearch=sb.toString();
    
    //初始化fromIndex
    int fromIndex=-keyword.length();
    //逐个匹配这个关键词
    while((fromIndex=stringToSearch.indexOf(keyword,fromIndex+keyword.length()))
      !=-1){
     hits++;
    }
    //将文件名字和匹配次数加入HashMap
    rs.put(files[i].getName(), new Integer(hits));
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   
  }
  //输出查询结果
  Iterator it=rs.keySet().iterator();
  while(it.hasNext()){
   String fileName=(String)it.next();
   Integer hits=(Integer)rs.get(fileName);
   System.out.println("find "+hits.intValue()+" matches in "+fileName);
  
  }
  long endTime=System.currentTimeMillis();
  long timeOfSearch=endTime-startTime;
  System.out.println("The time for String search is : "+timeOfSearch+" ms.");
 }}