一：简单的示例 1.1：生成索引
1.1.1：Field.Store和Field.Index
1.1.2：为数字生成索引
1.1.3：为索引加权
1.1.4：为日期生成索引
1.2：查询
1.2.1：介绍IndexReader
1.3：删除
1.3.1：还原删除的文档
1.3.2：清空回收站时面的数据
1.4：更新
前言：本教程用于Lucene3.5，Maven地址为
<dependency> <groupId>org.apache.lucene</groupId> <artifactId>lucene-core</artifactId> <version>3.5.0</version> </dependency>
一：简单的示例
我就不介绍Lucene了，想来看这篇博客的人，都知道Lucene是什么。直接给出生成索引，和查询的示例
1.1：生成索引
生成索引的代码如下：
/** * 创建索引 */ public void index(){ IndexWriter writer = null; try { //1、创建Derictory // Directory directory = new RAMDirectory();//这个方法是建立在内存中的索引 Directory directory = FSDirectory.open(new File("G:\TestLucene\index"));//这个方法是建立在磁盘上面的索引 // 2、创建IndexWriter，用完后要关闭 IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_35,new StandardAnalyzer(Version.LUCENE_35)); writer = new IndexWriter(directory,config); //3、创建Document对象 Document document = null; File fl = new File("G:\TestLucene\file"); //4、为Document添加Field for(File file : fl.listFiles()){ document = new Document();
document.add(new Field("content",new FileReader(file))); //把文件名存放到硬盘中，不作分词 document.add(new Field("fileName",file.getName(),Field.Store.YES, Field.Index.ANALYZED.NOT_ANALYZED)); //把绝对路径放到硬盘中，不作分词 document.add(new Field("path", file.getAbsolutePath(), Field.Store.YES, Field.Index.NOT_ANALYZED)); } //5、通过IndexWriter添加文档到索引中 writer.addDocument(document); } catch (IOException e) { e.printStackTrace(); } finally { if(null != writer){ try { writer.close(); } catch (IOException e) { e.printStackTrace(); } } } }
1.1.1：Field.Store和Field.Index
这里说明一个Field.Index和Field.Store
//Field.Store.YES或者NO部分 // 如果为YES，代表着是否要把这个域中的内容完全存储到文件中，方便进行还原 //如果为NO，代表着不把这个域的内容存储到文件，但是可以被索引，但是这些内容不可被还原 //Field.Index.ANALYZED:进行分词和索引，适用于标题，内容等 //Field.Index.NOT_ANALYZED：进行索引，但是不进行分词。精准的数据不分词，像id，身份证号，姓名等不分词，用于精确搜索 //Field.Index.ANALYZED_NOT_NORMS：进行分词但是不存储norm信息，这个norms中包括了索引的时间和权值等信息 //Field.Index.NOT_ANALYZED_NOT_NORMS：既不进行分词，也不存储norms信息 //Field.Index.NO：完全不进行索引
1.1.2：为数字生成索引
看过Field构造方法的人可能知道，这里面并没有对数字索引添加方法，那么会有人说，把数字转换成字符串？额。数字在索引中处理方式与字符串不同，我们可以使用一个新的对象
//搜索content中包含有着like的 TermQuery termQuery = new TermQuery(new Term("content","like")); //给数字加索引要用另一个对象 document.add(new NumericField("attachs").setIntValue(attachs[i]));
//给数字加索引要用另一个对象 //查看源码会发现，这个构造函数默认是不存储，但是会进行索引 document.add(new NumericField("attachs").setIntValue(attachs[i])); //通过这个构造方法，可以把其修改为存储，最后的boolean参数代表着是否索引 document.add(new NumericField("attachs", Field.Store.YES,true).setIntValue(attachs[i]));
这里使用一个新的字段，NumericField
1.1.3：为索引加权
大家看到搜索引擎的排序，就肯定能猜到，搜索引擎是按照了一定的要求，对查询的结果进行了排序，这里介绍一个简单的加权排序方法，后面会深入研究
//加权 document.setBoost(2.1f);
注意：权重越大，排序越前
1.1.4：为日期生成索引
既然数字有专门的NumericField，那么给日期生成索引，是不是也有DateField呢？其实是没有的，那怎么办？
但是我们都忽略了一件事，日期其实也是一个long类型的数字
document.add(new NumericField("attachs", Field.Store.YES,true).setLongValue(new Date().getTime()));
这不就行了吗？
1.2：查询
这里演示根据已生成的索引，来查询
代码如下：
/** * 搜索 */ public void searcher(){ try { //1、创建Directory Directory directory = FSDirectory.open(new File("G:\TestLucene\index")); //2、创建IndexReader，需要关闭 IndexReader reader = IndexReader.open(directory); //3、根据IndexReader创建IndexSearcher IndexSearcher searcher = new IndexSearcher(reader); //4、创建索引的Query //第二个参数代表着要搜索的域 QueryParser parser = new QueryParser(Version.LUCENE_35,"content",new StandardAnalyzer(Version.LUCENE_35)); //表示搜索content中包含java的文档 Query query = parser.parse("朱小杰");
//5、根据searcher搜索并返回TopDocs // 表示返回前面10条 TopDocs topDocs = searcher.search(query,10); //6、根据TopDocs获取ScoreDoc对象 ScoreDoc[] scoreDocs = topDocs.scoreDocs; for(ScoreDoc sd : scoreDocs){ //7、根据Searcher和ScordDoc对象获取具体的Document对象 //获取这个文档的id int doc = sd.doc; Document document = searcher.doc(doc); //8、根据Document对象获取需要的值 System.out.println("【找到】" + document.get("fileName") + " " + document.get("path") + " .." + document.get("content")); } reader.close(); } catch (IOException e) { e.printStackTrace(); } catch (ParseException e) { e.printStackTrace(); } }
1.2.1：介绍IndexReader
IndexReader顾名思义，它是用来读取索引的信息的，下面来演示一些它的用法
（1）获取文档的数量
//存储的文档数量，也就是document对象的数量，删除索引后，这个数值会减少
System.out.println("存储的文档数量: " + reader.numDocs());
（2）获取文档的总量
//存储过的文档的最大数量，删除索引后，数量不会减少
//此时删除的文件并不会完全删除，它存在回收站里面
System.out.println("文档存储的总存储量: " + reader.maxDoc());
（3）获取已删除文档的数量
System.out.println("删除文档的数量: " + reader.numDeletedDocs());
1.3：删除
下面给出删除的代码
/** * 删除索引 */ public void delete(){ try { IndexWriter writer = null; writer = new IndexWriter(directory,new IndexWriterConfig(Version.LUCENE_35,new StandardAnalyzer(Version.LUCENE_35))); //删除全部的索引 //writer.deleteAll(); //参数可以为一个查询的Query，也可以为一个Term，它是一个精确的值，代表着把id为1的给删除掉 writer.deleteDocuments(new Term("id","1")); writer.close(); } catch (IOException e) { e.printStackTrace(); } }
注意，这里的删除，并不是真的删除。执行完之后，可以在索引的目录里面看到多了一个.del的文件，那是一个类似回收站的文件，在回收站中的文件是可以进行还原的
1.3.1：还原删除的文档
之前有说到，删除并没有作真正的删除，而是把这个文件放到了类似回收站的位置中，下面来使用代码来进行还原已删除的文件
/** * 删除索引并不是完全删除，它是有着一个回收站的功能 * 上面的delete删除了一个索引，这里进行恢复 */ public void recovery(){ try { //这一步很重要，因为默认打开的reader是只读的，所以这里要通过构造方法，把它的readonly设置为false，否则会抛出异常 IndexReader reader = IndexReader.open(directory,false); //还原所有已删除的数据 reader.undeleteAll(); reader.close(); } catch (IOException e) { e.printStackTrace(); } }
注意：上面的构造方法和以往不同，后面多了一个boolean值，这个值，如果不写，默认是true，代表着只读，那么如果在这种情况下进行还原，是会抛出异常的。这里将其设置为false，也就是把只读设置为了false，这样就可以还原了。
1.3.2：清空回收站里面的数据
上面说完从回收站里面还原数据，那么回收站怎么清空掉呢？下面给出代码：
/** * 清空回收站里面的数据 */ public void clearRecovery(){ try { IndexWriter writer = new IndexWriter(directory,new IndexWriterConfig(Version.LUCENE_35,new StandardAnalyzer(Version.LUCENE_35))); writer.forceMergeDeletes(); //代表着是否等待当前操作完成后，再清空回收站里面的数据 writer.forceMergeDeletes(true); writer.close(); } catch (IOException e) { e.printStackTrace(); } }
这里面是有着两个重载的方法，其中一个是立即删除，一个是等待当前操作完成后，再删除
1.4：更新
更新一个索引的代码如下：
/** * 更新数据 */ public void update(){ try { //注意，Lucene其实并没有更新的操作，它的实际原理是先删除，再添加 IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_35,new StandardAnalyzer(Version.LUCENE_35)); IndexWriter writer = new IndexWriter(directory,config); Document document = new Document(); document.add(new Field("id","1", Field.Store.YES, Field.Index.NOT_ANALYZED)); writer.updateDocument(new Term("id","1"),document); writer.close(); } catch (IOException e) { e.printStackTrace(); } }
值得注意的是，这里的更新，并不是在原有的记录里面更新，而是先把该记录删除，然后增加新的记录，所以在查看已删除的文档数量里面会发出多出一条记录，同样的，在文档总量里面，也会增加一条记录
二：IndexReader的设计
2.1：设计单例的IndexReader
为什么要设计一个单例的IndexReader呢？大家可以试着去想像，假如说一个硬盘上面的索引，随着日期的增加，那么它的索引也就越来越多，当我打开一个IndexReader的时候，肯定是要读取索引里面的信息的，如果索引文件过多的话，那么肯定是会造成创建这个对象的时间及性能上面的消耗，所以IndexReader很有必要设计成单例的。
2.2:当索引的内容发生改变时，单例的IndexReader对象不会改变的问题
由上面的单例IndexReader，这里又有着一个新的问题，那就是在一个项目中，存在一个单例的IndexReader的时候，虽然可以大大提升性能，但是也有一个问题。IndexReader对象里面的索引内容，是在这个对象被创建的时候生成的，也只有在那个时候，IndexReader才能读取到索引目录里面的数据。
问题就是，当索引内容添加，或者删除过后，IndexReader的对象不会发生改变！！
下面来研究创建IndexReader的方法：
//根据一个Directory创建一个IndexReader IndexReader reader = IndexReader.open(directory);
上面的这个创建IndexReader的方法，将会读取索引中所有的数据，首先消耗性能是肯定的。
其实还有一个创建IndexReader的方法，如下：
//这种创建IndexReader的方法，就是把老的IndexReader对象传进去，然后会判断索引的内容是否会发生改变，如果索引内容发生改变，则会创建一个新的对象，如果索引的内容没有发生改变，则会返回空 IndexReader ir = IndexReader.openIfChanged(reader);
这是一个新的方法，通过这个方法，就可以知道是否需要产生新的IndexReader方法，下面来演示一下IndexReader的设计
public class CustomerIndexReader { static { try { directory = FSDirectory.open(new File("d:/index")); } catch (IOException e) { e.printStackTrace(); } } private static IndexReader reader = null; private static Directory directory = null; public CustomerIndexReader(){ } public IndexReader getIndexReader(){ if(directory == null){ synchronized (this){ if(directory == null){ try { reader = IndexReader.open(directory); } catch (IOException e) { e.printStackTrace(); } } } }else{ try { IndexReader ir = IndexReader.openIfChanged(reader); if(ir != null){ //如果这个对象不为空，则代表着索引发生了改变 reader = ir; } } catch (IOException e) { e.printStackTrace(); } } return reader; } }
其实IndexReader也有删除文档的方法。而且它可以保证IndexReader的数据是最新的数据。也就是reader.deleteDocument()
三：查询的方式
3.1：精确查询
何为精确查询，精确查询就相当于数据库的=号，也就是查询的字符，与索引中字符必须完全一致，才能匹配到
public void searchers(){ try { Directory directory = FSDirectory.open(new File("d:/index")); IndexReader reader = IndexReader.open(directory); IndexSearcher searcher = new IndexSearcher(reader); //这个是精确查询 Query query = new TermQuery(new Term("name","大牛")); reader.close(); } catch (IOException e) { e.printStackTrace(); } }
如上面的代码，会在name域里面找名字为“大牛”的结果，但是如果搜索“大”，或者“牛”，就找不到结果，因为TermQuery是精确查询
3.2：字符串的范围搜索
说完精确搜索，下面介绍一下范围搜索。范围搜索，也就是指在一定区间范围内查询，下面给出代码的示例。
public void searcher1(){ try { Directory directory = FSDirectory.open(new File("d:/index")); IndexReader reader = IndexReader.open(directory); IndexSearcher searcher = new IndexSearcher(reader); //这是珍上范围搜索，意思是搜索id域中，最低为1，最高为10，后面的两个boolean的参数分别代表着，是否包好最低值与最高值 //但是数字类型是查不出来的，也就是NumericField来存储field的类型，使用TermRangeQuery是查不出来的，需要使用NumericRangeQuery Query query = new TermRangeQuery("id","1","10",true,true); //查询名字以a 开头，到以f开头的 // Query query = new TermRangeQuery("name","a","f",true,true); reader.close(); } catch (IOException e) { e.printStackTrace(); } }
注意：TermRangeQuery无法查询数字的结果，也就是使用NumericField来存储的索引，但是可以查询"1","2"字符串类型的数字。
3.3：数字的范围搜索
上面说了字符串的范围搜索，而且还特意强掉了，数字不能用TermRangeQuery，那么如果数字的范围搜索，要怎么做呢？可以使用NumericRangeQuery，下面给出代码：
public void searcher2(){ try { Directory directory = FSDirectory.open(new File("d:/index")); IndexReader reader = IndexReader.open(directory); IndexSearcher searcher = new IndexSearcher(reader); //这里是int整数的查询方法，其实，还有float,long,double等方式，也都是通过NumericRangeQuery这个类 // NumericRangeQuery.newDoubleRange(..); 这是Double类型的 //NumericRangeQuery.newFloatRange(...); 这是Float类型的 //NumericRangeQuery.newLongRange(...); 这是Long类型的
//这里的意思是查询age域中，1岁到100岁的，其中，包含1岁和100岁的
Query query = NumericRangeQuery.newIntRange("age",1,100,true,true); searcher.close(); reader.close; } catch (IOException e) { e.printStackTrace(); } }
3.4：前缀搜索
前缀搜索，就是对于一个域中的前缀进行匹配，当然，它也会匹配分词后的前缀
Query query = new PrefixQuery(new Term("name","刘"));
上面的代码，会找出所有name中姓刘的数据。
注意：如果内容中进行了分词，那将会查找每一个分词中的以此字符开头的数据。
3.5：通配符搜索
通配符大家应该听说过的，那就是*代表任何字符，?代表一个字符
Query query = new WildcardQuery(new Term("content","*a?"));
3.6：连接多个条件的查询
有的时候，查询一个复杂的数据，一个搜索条件，可能不满足结果，那么就可以使用BooleanQuery
//这个query下面可以add任何多个查询条件 BooleanQuery query = new BooleanQuery(); //名字一定是张三 query.add(new TermQuery(new Term("name","张三")), BooleanClause.Occur.MUST); //名族一定不是汉族 query.add(new TermQuery(new Term("nation","汉")), BooleanClause.Occur.MUST_NOT);
//可以出现，也可以不出现 query.add(new WildcardQuery(new Term("content","a")), BooleanClause.Occur.SHOULD);
BooleanQuery就是Query的扩展类，这个类可以增加任意多个查询条件，并且通过Occur枚举过定义，查询条件的必要性
3.7：短语间隔搜索
就是查询一定区间的字符。可能这句话说不明白，我们用代码来说明：
假如我有下面的一段字符
I love lucene very much
那么我现在的目的是，我忘了中间的单词是什么了，我只记得开头为I，结尾为much，那要怎么做呢？
PhraseQuery query = new PhraseQuery(); //第一个结果，注意I会变成小写 query.add(new Term("content","i")); //代表着中间相隔3个单词 query.setSlop(3); //第二个结果 query.add(new Term("content","nuch"));
注意：大写的开头，会被转换成小写哦，但是这种方法开销很大，尽量少用
3.8：模糊查询
这里要先说明一下，模糊查询与通配符查询是有区别的。模糊查询是代表着允许有着一定的错别字
这里来进行说明一下，假如我有这样的一些name属性
jane mike kangkang
当我写出下面的代码的时候
//通过这个，肯定是可以找到mkie的结果的 FuzzyQuery query1 = new FuzzyQuery(new Term("name","mike")); //这里我把i写成了a，但是也是可以查到mike的 FuzzyQuery query2 = new FuzzyQuery(new Term("name","make"));
上面的代码代表着，FuzzyQuery，允许有着一定的错别字
那么可以控制查询字符的错别字吗？
答案是可以的，如下面的代码：
//通过第2个float参数调整相似度，值越低，代表相似度越低，容错率越高 FuzzyQuery query3 = new FuzzyQuery(new Term("name","make"),0.5f,0);
它会有着一定的容错率
3.9：QueryParser的使用
在刚开始的示例中，就使用过QueryParser的这个对象，现在就来重点的说明一下。
QueryParser它支持一定的查询表达式，什么是查询表达式呢？下面用代码来演示一下
//创建一个默认搜索域为content的parser QueryParser parser = new QueryParser(Version.LUCENE_35,"content",new StandardAnalyzer(Version.LUCENE_35)); //改变字符串的默认操作符，下面改成AND //parser.setDefaultOperator(QueryParser.Operator.AND); //开启第一个字符的通配符的匹配，lucene默认是关闭的，因为效率太低 parser.setAllowLeadingWildcard(true); //搜索content中包含like的 Query query = parser.parse("like"); //搜索有dog或者cat的，空格默认就是OR query = parser.parse("dog cat"); //改变搜索域为name，搜索其中的jie query = parser.parse("name:jie"); //使用通配符*和?来进行匹配 query = parser.parse("name:j*"); //通配符默认是不能放在首位的，因为其效率太低，lucene默认关闭了，上面已经开始，所以不会抛异常 query = parser.parse("name:*e"); //搜索name中没有dog，默认域content中有eat的条件 query = parser.parse("- name:dog + eat"); //匹配一个区间，TO必须是大写，这个区间是开区间，这个是字符的1，数字的不能 query = parser.parse("id:[1 TO 3]"); //这个是闭区间，只会匹配到2，这个是字符的1，数字的不能 query = parser.parse("id:{1 TO 3}"); //默认域中是dog或者cat，但是age是11的 query = parser.parse("(dog OR cat) AND age:11"); //匹配两个相连的字符串，这里不会被分割，代表着默认域中，这两个字符串相连的才会被搜索出来 query = parser.parse(""hello world"");