理解Document
Lucene没有定义数据源,而是定义了一个通用的文档结构,这个文档结构就是LuceneDocument包下的Document类.
一个Document对应于你在进行网页抓取的时候一个msword,一个pdf,一个html,一个text等.Lucene的这种形式可以定义
非常灵活的应用,只要前端有相应的转换器把数据源转成Document结构就可以了.
一个Document内部维护一个Field的vector.
好,我们一起来看一下document的核心源码(只有定义,没有实现)
public final class Document implements java.io.Serializable {
List fields = new Vector();//成员变量
//boost用来表示此document的重要程度,默认为1.0,会作用于document中的所有的field
private float boost = 1.0f;
public Document() {}
public void setBoost(float boost) {this.boost = boost;}
public float getBoost() {return boost;}
public final void add(Field field)
public final void removeField(String name)
public final void removeFields(String name)
public final Field getField(String name)
public final String get(String name)
public final Enumeration fields()
public final Field[] getFields(String name)
public final String[] getValues(String name)
public final String toString()
理解Field
刚才提到一个Document中有一个用来存储Field的vector,那么什么是Field.你可以简单的认为Field是一个<name,value>
name为域（Field）的名字，例如title，body，subject，data等等。value就是文本。我们来看一下源码定义,不就OK了.
(由于Field是Lucene中非常重要的概念,所以我们拿来源码看一下)
public final class Field implements java.io.Serializable {
private String name = "body";
private String stringValue = null;
private boolean storeTermVector = false;
private Reader readerValue = null;
private boolean isStored = false;
private boolean isIndexed = true;
private boolean isTokenized = true;
/*以前一直不了解boost为何？其实boost就是由于后来进行相关度排序时用的,由于在query时，
*每个term都分属与一个field。同样的term当其属于不同的field时，其重要性不一样，譬如
*field:<title>中的term就要比field:<content>中的term重要！而这个重要性如何体现就
*可以通过boost进行设定。可以把field:<title>的boost至设大一些
*注意boost在Document中还有整个的设定.
*/
private float boost = 1.0f;
public void setBoost(float boost) {this.boost = boost;}
public float getBoost() { return boost;}
public static final Field Keyword(String name, String value) {return new Field(name, value, true, true, false);}
public static final Field UnIndexed(String name, String value) {return new Field(name, value, true, false, false);}
public static final Field Text(String name, String value) {return Text(name, value, false);}
public static final Field Keyword(String name, Date value) {return new Field(name, DateField.dateToString(value), true, true, false);}
public static final Field Text(String name, String value, boolean storeTermVector) {
return new Field(name, value, true, true, true, storeTermVector);}
public static final Field UnStored(String name, String value) {
return UnStored(name, value, false);}
public static final Field UnStored(String name, String value, boolean storeTermVector) {
return new Field(name, value, false, true, true, storeTermVector); }
public static final Field Text(String name, Reader value) {
return Text(name, value, false);}
public static final Field Text(String name, Reader value, boolean storeTermVector) {
Field f = new Field(name, value);
f.storeTermVector = storeTermVector;
return f;
}
public String name() { return name; }
public String stringValue() { return stringValue; }
public Reader readerValue() { return readerValue; }
public Field(String name, String string,
boolean store, boolean index, boolean token) {
this(name, string, store, index, token, false);
}
//最低层的构造函数
public Field(String name, String string,
boolean store, boolean index, boolean token, boolean storeTermVector)
Field(String name, Reader reader)
public final boolean isStored() { return isStored; }
public final boolean isIndexed() { return isIndexed; }
public final boolean isTokenized() { return isTokenized; }
public final boolean isTermVectorStored() { return storeTermVector; }
public final String toString()
public final String toString2()//我加的用来返回六元组
}
代码可能看起来有点长,不过看一下就知道了Field其实是一个六元组,咱们上文说其是<name,value>对是一种简化形式.
Field的六元组形式为<name,stringValue,isStored,isIndexed,isTokenized,isTermVectorStored>,Field提供了不同的构造函数
主要有一下几个
|
方法 数据挖掘研究院 |
切词 |
索引 数据挖掘实验室 |
存储 数据挖掘实验室 |
用途 数据挖掘研究院 |
|
Field.Text(String name, String value) |
Yes 数据挖掘研究院 |
Yes 数据挖掘研究院 |
Yes 数据挖掘研究院 |
切分,索引,并存储，比如：title，subject |
|
Field Text(String name, Reader value) |
Yes |
Yes 数据挖掘研究院 |
Yes 数据挖掘研究院 |
与上面同, Term Vector并不存储此Field 数据挖掘研究院 |
|
Field Text(String name, String value, boolean storeTermVector) |
Yes 数据挖掘研究院 |
Yes 数据挖掘研究院 |
Yes |
切分,索引,存储，比如：title,subject.于上面不同的加入了一个控制变量 数据挖掘研究院 |
|
Field Text(String name, Reader value, boolean storeTermVector) |
Yes |
Yes 数据挖掘研究院 |
Yes |
切分,索引,存储，比如：title,subject.于上面不同的加入了一个控制变量 数据挖掘研究院 |
|
Field.Keyword(String name, String value) |
No 数据挖掘实验室 |
Yes 数据挖掘研究院 |
Yes |
不切分,索引,存储，比如：date,url |
|
Field Keyword(String name, Date value) |
|
|
|
不切分,存储,索引,用来返回hits 数据挖掘研究院 |
|
Field.UnIndexed(String name, String value) |
No 数据挖掘研究院 |
No 数据挖掘研究院 |
Yes |
不切分,不索引，存储，比如：文件路径 |
|
Field.UnStored(String name, String value) 数据挖掘研究院 |
Yes |
Yes 数据挖掘研究院 |
No |
只全文索引，不存储 数据挖掘研究院 |
|
Field UnStored(String name, String value, boolean storeTermVector) 数据挖掘实验室 |
Yes |
Yes |
No 数据挖掘研究院 |
于上面相同,不同的是加入了一个控制变量 数据挖掘研究院 |
总的来看,Field的构造函数就只有四种形式,Text,KeyWord,UnIndexed,UnStored,只不过每种函数往往有多种变形罢了.
编一段代码来测试一下Document类和Field类
public class TestDocument
{
private Document makeDocumentWithFields() throws IOException
{
Document doc = new Document();
doc.add(Field.Text("title","title"));
doc.add(Field.Text("subject","ubject"));
doc.add(Field.Keyword("date","2005.11.12"));
doc.add(Field.Keyword("url","www.tju.edu.cn"));
doc.add(Field.UnIndexed("filepath","D:\Lucene"));
doc.add(Field.UnStored("unstored","This field is unstored"));
Field field;
for(int i=0;i<doc.fields.size();i++)
{
field =(Field)doc.fields.get(i);
System.out.println(field.toString());
System.out.println("对应的六元组形式为");
System.out.println(field.toString2());
}
return doc;
}
public void GetValuesForIndexedDocument() throws IOException
{
RAMDirectory dir = new RAMDirectory();
IndexWriter writer = new IndexWriter(dir,new StandardAnalyzer(),true);
writer.addDocument(makeDocumentWithFields());
writer.close();
Searcher searcher = new IndexSearcher(dir);
Query query = new TermQuery(new Term("title","title"));
//Hits 由匹配的Document组成.
Hits hits = searcher.search(query);
System.out.println("Document的结构形式");
System.out.println(hits.doc(0));
}
public static void main(String [] args)
{
TestDocument testDocument = new TestDocument();
try
{
testDocument.GetValuesForIndexedDocument();
}
catch (IOException ioe)
{
ioe.printStackTrace();
}
}
}
其结果如下:
Text<title:title>
对应的六元组形式为
Field:<name,stringValue,isStored,isIndexed,isTokenized,isTermVectorStored> is:<title,title,true,true,true,false>
Text<subject:ubject>
对应的六元组形式为
Field:<name,stringValue,isStored,isIndexed,isTokenized,isTermVectorStored> is:<subject,ubject,true,true,true,false>
Keyword<date:2005.11.12>
对应的六元组形式为
Field:<name,stringValue,isStored,isIndexed,isTokenized,isTermVectorStored> is:<date,2005.11.12,true,true,false,false>
Keyword<url:www.tju.edu.cn>
对应的六元组形式为
Field:<name,stringValue,isStored,isIndexed,isTokenized,isTermVectorStored> is:<url,www.tju.edu.cn,true,true,false,false>
Unindexed<filepath:D:Lucene>
对应的六元组形式为
Field:<name,stringValue,isStored,isIndexed,isTokenized,isTermVectorStored> is:<filepath,D:Lucene,true,false,false,false>
UnStored<unstored>
对应的六元组形式为
Field:<name,stringValue,isStored,isIndexed,isTokenized,isTermVectorStored>is:<unstored,This field is unstored,false,true,true,false>
Document的结构形式
Document<Text<title:title> Text<subject:ubject> Keyword<date:2005.11.12> Keyword<url:www.tju.edu.cn> Unindexed<filepath:D:Lucene>>
相信当你看着输出结果时,你会对Document和Field这两个类有更好的认识!Document和Field是Lucene中非常重要索引的基本概念,所以需要好好理解.
