lucene3 建立索引文件例子

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Date;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

/**
 * 建立索引文件
 * 
 * @author chinaxxren
 * 
 */
public class CreateIndexerDir {
	// 搜索源文件
	private static String INDEX_DIR = "C:\\Documents and Settings\\admin\\桌面\\cs";
	// 建立生成索引文件夹
	private static String DATA_DIR = "C:\\Documents and Settings\\admin\\桌面\\test";

	public static void main(String[] args) throws Exception {
		long start = new Date().getTime();
		int numIndexed = index(new File(INDEX_DIR), new File(DATA_DIR));
		long end = new Date().getTime();

		System.out.println("Indexing " + numIndexed + " files took "
				+ (end - start) + " milliseconds");
	}

	/**
	 * 
	 * @param srcDir
	 *            查询的源文件
	 * @param saveDir
	 *            创建保存索引的文件目录
	 * @return 返回匹配的记录总数
	 */
	public static int index(File srcDir, File saveDir) {
		Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT); // 创建一个语法分析器
		IndexWriter writer = null;
		// 文件目录
		Directory directory = null;
		int numIndexed = 0;
		try {
			// 索引文件可放的位置：索引可以存放在两个地方1.硬盘，2.内存；
			// 放在硬盘上可以用FSDirectory()，放在内存的用RAMDirectory()不过一关机就没了
			directory = FSDirectory.open(saveDir); // 把索引文件存储到磁盘目录
			// 创建一个IndexWriter(存放索引文件的目录,分析器,Field的最大长度)
			System.out.println(IndexWriter.MaxFieldLength.UNLIMITED);
			// 可见构造它需要一个索引文件目录，一个分析器(一般用标准的这个)，一个参数是标识是否清空索引目录
			writer = new IndexWriter(directory, analyzer, true,
					IndexWriter.MaxFieldLength.UNLIMITED);
			// 索引合并因子
			// 一、SetMergeFactor（合并因子）
			// SetMergeFactor是控制segment合并频率的，其决定了一个索引块中包括多少个文档，当硬盘上的索引块达到多少时，
			// 将它们合并成一个较大的索引块。当MergeFactor值较大时，生成索引的速度较快。MergeFactor的默认值是10，建议在建立索引前将其设置的大一些。
			writer.setMergeFactor(100);
			// 二、SetMaxBufferedDocs（最大缓存文档数）
			// SetMaxBufferedDocs是控制写入一个新的segment前内存中保存的document的数目，
			// 设置较大的数目可以加快建索引速度，默认为10。
			writer.setMaxMergeDocs(1000);
			// 三、SetMaxMergeDocs（最大合并文档数）
			// SetMaxMergeDocs是控制一个segment中可以保存的最大document数目，值较小有利于追加索引的速度，默认Integer.MAX_VALUE，无需修改。
			// 在创建大量数据的索引时，我们会发现索引过程的瓶颈在于大量的磁盘操作，如果内存足够大的话，
			// 我们应当尽量使用内存，而非硬盘。可以通过SetMaxBufferedDocs来调整，增大Lucene使用内存的次数。
			indexDirectory(writer, srcDir);
			numIndexed = writer.numDocs();
			// SetUseCompoundFile这个方法可以使Lucene在创建索引库时，会合并多个 Segments 文件到一个 .cfs
			// 中。
			// 此方式有助于减少索引文件数量，对于将来搜索的效率有较大影响。
			// 压缩存储（True则为复合索引格式）
			writer.setUseCompoundFile(true);
			// 对索引进行优化
			writer.optimize();
			// 若需要从索引中删除某一个或者某一类文档，IndexReader提供了两种方法：
			// reader.DeleteDocument(int docNum)
			// reader.DeleteDocuments(Term term)
			//
			// 前者是根据文档的编号来删除该文档，docNum是该文档进入索引时Lucene的编号，是按照顺序编的；后者是删除满足某一个条件的多个文档。
			//
			// 在执行了DeleteDocument或者DeleteDocuments方法后，系统会生成一个*.del的文件，该文件中记录了删除的文档，但并未从物理上删除这些文档。此时，这些文档是受保护的，当使用Document
			// doc = reader.Document(i)来访问这些受保护的文档时，Lucene会报“Attempt to access a
			// deleted document”异常。如果一次需要删除多个文档时，可以用两种方法来解决：
			//
			// 1. 删除一个文档后，用IndexWriter的Optimize方法来优化索引，这样我们就可以继续删除另一个文档。
			//
			// 2.
			// 先扫描整个索引文件，记录下需要删除的文档在索引中的编号。然后，一次性调用DeleteDocument删除这些文档，再调用IndexWriter的Optimize方法来优化索引。

		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (writer != null) {
				try {
					writer.close(); // 关闭IndexWriter时,才把内存中的数据写到文件
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (directory != null) {
				try {
					directory.close(); // 关闭索引存放目录
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return numIndexed;
	}

	/**
	 * 递归文件
	 * 
	 * @param writer
	 * @param dir
	 * @throws IOException
	 */
	private static void indexDirectory(IndexWriter writer, File srcDir)
			throws IOException {

		File[] files = srcDir.listFiles();
		for (File src : files) {
			if (src.isDirectory()) {
				// 如果是文件继续递归
				indexDirectory(writer, src); // recurse
				// 如果是txt结尾的文件则处理
			} else if (src.getName().endsWith(".txt")) {
				indexFile(writer, src);
			}
		}
	}

	/**
	 * 建立索引表
	 * 
	 * @param writer
	 * @param f
	 * @throws IOException
	 */
	private static void indexFile(IndexWriter writer, File src)
			throws IOException {
		// 如果文件时隐藏或者文件不存在或则文件不能读，则返回
		if (src.isHidden() || !src.exists() || !src.canRead()) {
			return;
		}
		// 显示读取的文件的路径
		String path = src.getCanonicalPath();
		System.out.println("" + path);
		// 显示读取的文件内容
		String text = loadFileToString(src);
		// Document相当于数据库中的一行记录。
		Document doc = new Document();
		// Field(String name, byte[] value, Field.Store store)
		// Field(String name, Reader reader)
		// Field(String name, Reader reader, Field.TermVector termVector)
		// Field(String name, String value, Field.Store store, Field.Index
		// index)
		// Field(String name, String value, Field.Store store, Field.Index
		// index, Field.TermVector termVector)
		//      
		// 在Field中有三个内部类：Field.Index,Field.Store,Field.termVector，而构造函数也用到了它们。
		// 参数说明：
		// Field.Store：
		// Field.Store.NO：表示该Ｆield不需要存储。
		// Field.Store.Yes：表示该Ｆield需要存储。
		// Field.Store.COMPRESS：表示使用压缩方式来存储。
		// Field.Index：
		// Field.Index.NO：表示该Ｆield不需要索引。
		// Field.Index.TOKENIZED：表示该Ｆield先被分词再索引。
		// Field.Index.UN_TOKENIZED：表示不对该Ｆield进行分词，但要对其索引。
		// Field.Index.NO_NORMS：表示该Ｆield进行索引，但是要对它用Analyzer，同时禁止它参加评分，主要是为了减少内在的消耗。
		// 增加文档 Field相当于增加数据库字段一样
		//检索,获取都需要的内容,直接放index中,不过这样会增大index,保存文件的txt内容
		doc.add(new Field("contents", text, Field.Store.YES,
				Field.Index.ANALYZED));
		//大段文本内容,会用来检索,但是检索后不需要从index中取内容,可以根据url去load真实的内容 
		doc.add(new Field("contents", new FileReader(src)));
		doc.add(new Field("filename", path, Field.Store.YES,
				Field.Index.ANALYZED));
		writer.addDocument(doc);
	}

	/**
	 * 将文件读出来转化为字符串
	 * 
	 * @param file
	 *            源文件，不能是文件夹
	 * @return
	 */
	private static String loadFileToString(File file) {
		BufferedReader br = null;
		try {
			// 字符缓冲流，是个装饰流，提高文件读取速度
			br = new BufferedReader(new FileReader(file));
			StringBuffer sb = new StringBuffer();
			String line = br.readLine();
			while (null != line) {
				sb.append(line);
				line = br.readLine();
				System.out.println(line);
			}
			return sb.toString();
		} catch (FileNotFoundException e) {
			System.out.println("文件不存在!");
			return null;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		} finally {
			try {
				br.close();
			} catch (IOException e) {
				System.out.println("关闭流出现异常");
				e.printStackTrace();
			}
		}
	}
}