1.3 索引创建过程
DocumentsWriter是由IndexWriter调用来负责对多个document建立索引的核心类,但整个索引过程并不是由一个对象来完成的。而是有一系列的对象组成的处理链(IndexingChain)来完成的(这个过程就像流水线生产汽车)。 下面是DocumentWriter开始建立索引的源代码。
//由IndexWriter调用的方法
boolean addDocument(Document doc, Analyzer analyzer){
return updateDocument(doc, analyzer, null);
}
boolean updateDocument(Document doc, Analyzer analyzer, Term delTerm){
final DocumentsWriterThreadState state = getThreadState(doc, delTerm);
final DocState docState = state.docState;
docState.doc = doc;
docState.analyzer = analyzer;
boolean success = false;
try {
//调用处理链的源头DocFieldProcessorPerThread开始对Document对象建立索引结构
final DocWriter perDoc = state.consumer.processDocument();
finishDocument(state, perDoc);
success = true;
}
.......
}
1.3.1 第一车间——DocFieldProcessorPerThread
DocFieldProcessorPerThread类是索引创建处理链的第一步。其基本任务:将document对象原料中所有相同名字的field合并成一个 DocFieldProcessorPerThread对象 ,然后更新FieldInfo信息,最后对不同名字的Field构成一个 DocFieldProcessorPerThread[]对象数组。这个数组就是下一个车间DocInverterPerField要加工的原料了。
DocFieldProcessorPerThread类完成第一步处理的核心方法就是processDocument()。在介绍这个方法之前,我们先来看看两个重要的类DocFieldProcessorPerField和FieldInfo
(1) DocFieldProcessorPerField 类是一个合并了相同名字Field的类(可见下图黄色区域)。它是后面DocInverterPerField要处理的单位原料。源码如下:
final class DocFieldProcessorPerField {
final DocFieldConsumerPerField consumer;
//记录field的名字、是否要检索,是否要存储等信息
final FieldInfo fieldInfo;
//指向下一个DocFieldProcessorPerField的指针
DocFieldProcessorPerField next;
int lastGen = -1;
//包含相同名字的field的数量
int fieldCount;
//包含的相同名字的field
Fieldable[] fields = new Fieldable[1];
public DocFieldProcessorPerField(final DocFieldProcessorPerThread perThread, final FieldInfo fieldInfo) {
this.consumer = perThread.consumer.addField(fieldInfo);
this.fieldInfo = fieldInfo;
}
public void abort() {
consumer.abort();
}
}
(2) FieldInfo 类并不是指一个Field的全部信息,而是相同名字的Field合并之后的信息。合并过程重要通过update()方法将Field的其他不同属性统一起来(可见下图蓝色区域)。部分源码如下:
final class FieldInfo {
//Field的相同名字
String name;
//是否要索引
boolean isIndexed;
//编号
int number;
....
//构造器
FieldInfo(..){
...
}
//FieldInfo更新的准则是:
//原来的Field和新的Field有一个要索引(isIndexed=true),则更新后的也索引。
//如果新的Field不需要索引,则其他操作指标不变
//如果新的Field需要索引,则只要有一个操作指标为真,就更新后的也为真
void update(...){
...
}
}
下面我们重点看看processDocument()方法是如何把Document对象加工成DocFieldProcessorPerThread[]数组的。
final class DocFieldProcessorPerThread extends DocConsumerPerThread {
//存储最后处理的结构:DocFieldProcessorPerField[]数组
DocFieldProcessorPerField[] fields = new DocFieldProcessorPerField[1];
int fieldCount;
//以Field名字作为关键字的DocFieldProcessorPerField哈希表结构
DocFieldProcessorPerField[] fieldHash = new DocFieldProcessorPerField[2];
/**
* 扩大DocFieldProcessorPerField的Hash表容量
* 每一次扩大到原来容量的2倍,并且将原来存储的DocFieldProcessorPerField对象顺序移动到Hash的最大位置处
* 比如:原来的容量为2,扩大之后的容量为4,将fieldHash[1]->fieldHash[3],fieldHash[0]->fieldHash[2]
*/
private void rehash() {
....
}
/**
*第一加工车间处理核心流程
*/
public DocumentsWriter.DocWriter processDocument() {
//初始化各项数据
consumer.startDocument();
fieldsWriter.startDocument();
//要处理的document对象
final Document doc = docState.doc;
assert docFieldProcessor.docWriter.writer.testPoint("DocumentsWriter.ThreadState.init start");
//记录处理过程中生成的DocFieldProcessorPerField的数量
fieldCount = 0;
//当前的DocFieldProcessorPerField
final int thisFieldGen = fieldGen++;
final List<Fieldable> docFields = doc.getFields();
final int numDocFields = docFields.size();
for(int i=0;i<numDocFields;i++) {
//得到doc的每个Field
Fieldable field = docFields.get(i);
final String fieldName = field.name();
//以Field的名字为key,定位到fieldHash[]的位置号hashPos
final int hashPos = fieldName.hashCode() & hashMask;
//确定fieldHash[]上指定的hashPos位置是否已经有了数据,也就是是否产生冲突
DocFieldProcessorPerField fp = fieldHash[hashPos];
//如果Field的名字不同,但fieldHash[]的hashPos位置产生了Hash冲突,则采用Hash链表结构加入到冲突位置上的链表末尾。
while(fp != null && !fp.fieldInfo.name.equals(fieldName))
fp = fp.next;
//如果fieldHash[]的hashPos位置上没有数据,则将新的Field包装成DocFieldProcessorPerField对象加入到Hash表中
if (fp == null) {
FieldInfo fi = fieldInfos.add(fieldName, field.isIndexed(), field.isTermVectorStored(),field.isStorePositionWithTermVector(), field.isStoreOffsetWithTermVector(),field.getOmitNorms(), false, field.getOmitTermFreqAndPositions());
fp = new DocFieldProcessorPerField(this, fi);
fp.next = fieldHash[hashPos];
fieldHash[hashPos] = fp;
totalFieldCount++;
//如果DocFieldProcessorPerField的Hash表存储总数量已经尝过了总容量的1/2,则扩大容量
if (totalFieldCount >= fieldHash.length/2)
rehash();
}else{ //如果产生了冲突,并且冲突位置上的Field的名字与要加入的Field名字相同,则更新冲突位置上的FieldInfo
fp.fieldInfo.update(field.isIndexed(), field.isTermVectorStored(),
field.isStorePositionWithTermVector(), field.isStoreOffsetWithTermVector(),
field.getOmitNorms(), false, field.getOmitTermFreqAndPositions());
}
//如果具有相同名字的Field,则将同名的Field合并到同一个DocFieldProcessorPerField中的Fieldable[]中
if (thisFieldGen != fp.lastGen) {
fp.fieldCount = 0;
//如果fields[]已经存满,则扩大2倍的fields[]的容量
if (fieldCount == fields.length) {
final int newSize = fields.length*2;
DocFieldProcessorPerField newArray[] = new DocFieldProcessorPerField[newSize];
System.arraycopy(fields, 0, newArray, 0, fieldCount);
fields = newArray;
}
fields[fieldCount++] = fp;
fp.lastGen = thisFieldGen;
}
//如果具有相同的Field名字,而DocFieldProcessorPerField中的Fieldable[]已经存满,则扩大2倍的此数组容量用于存放相同名字的Field
if (fp.fieldCount == fp.fields.length) {
Fieldable[] newArray = new Fieldable[fp.fields.length*2];
System.arraycopy(fp.fields, 0, newArray, 0, fp.fieldCount);
fp.fields = newArray;
}
fp.fields[fp.fieldCount++] = field;
if (field.isStored()) {
fieldsWriter.addField(field, fp.fieldInfo);
}
}
//将fields数组按field名字排序
quickSort(fields, 0, fieldCount-1);
//调用下一加工车间DocInverterPerField对每个DocFieldProcessorPerField对象进行处理
for(int i=0;i<fieldCount;i++)
fields[i].consumer.processFields(fields[i].fields, fields[i].fieldCount);
.......
}
用个图例来说明一下DocFieldProcessorPerThread类所做的工作。我们拿《索引创建(1):IndexWriter索引器 》1.1节前期工作中的doc1来作为DocFieldProcessorPerThread的原料。
原料:Document doc1 (为了说明相同Field的合并工作,我们加了一个相同名字,值不同的content Field)
Field name | Field value | isIndex | isStore |
name | 1 | false | true |
path | e:\\content\\1.txt | false | true |
content | The lucene is a good IR. I hope I can lean. | true | true |
content | Lucene 3.0 like a teacher. I love it. | true | true |
半成品: DocFieldProcessorPerField[] fields
注意,上图中的DocFieldProcessorPerField的next域都指向了null。其实,如果有Field1的名字name1与Field2的名字name2满足 HashCode(name1)=HashCode(name2) && !name1.equals(name2) 的情况下。Field2所构成的DocFieldProcessorPerField对象将加在Field1所构成的DocFieldProcessorPerField对象的next链表后面。这种组织方法便于我们在后面要讲到的建立倒排索引的处理。
总结: DocFieldProcessorPerThread 类的作用就是把Document对象加工成 DocFieldProcessorPerField [] (上图黄色区域) 。然后把每个DocField ProcessorPerThread .Fieldable[] (上图红色区域)
交给第二车间DocInverterPerField 的processFields (《索引创建(3):DocmentWriter 处理流程二》 )方法来完成了。