Bobo源码札记1
Bobo源码笔记1
Bobo将field的数据缓存到内存中，与lucene中的FieldCache类的作用相似。
抽象类 FacetHandler<D> 是最基本的类，对于BoboIndexReader，它像一个工具，用于获取数据，然后存储到内存中。
以最简单的实现类SimpleFacetHandler做分析。SimpleFacetHandler只能做简单的归类，比如在电商应用中，一个Docment表示一个产品，其中一个field代表该商品的颜色，blue、red或者green，那么可以通过SimpleFacetHandler对搜索结果进行过滤，例如只要red颜色的商品～
class SimpleFacetHandler extends FacetHandler<FacetDataCache> implements FacetScoreable
其中load（）函数用于IndexReader中获取Field数据，并将这些数据存储内存中，是Bobo初始化的主要工作。
public FacetDataCache load(BoboIndexReader reader) throws IOException {
FacetDataCache dataCache = new FacetDataCache();
dataCache.load(_indexFieldName, reader, _termListFactory);
return dataCache;
}
FacetDataCache、MultiValueFacetDataCache类是具体进行获取、存储数据的，load()是主要函数。
1、 其中FacetDataCache是指field中只能有一个term，也就是说该属性是唯一的，用上面电商商品的例子，就是一个
商品的颜色只能是blue或者red，而不能包括多个。
2、MultiValueFacetDataCache是field中可以有多个term，多个属性值的
FacetDataCache类的 load( )函数：
public void load(String fieldName,IndexReader reader,TermListFactory<T> listFactory) throws IOException
{
String field = fieldName.intern();
int maxDoc = reader.maxDoc();
//order实际上就是一个大数组，下标是docid，对应的值对应该文档的属性值(唯一的term)的index，通过index可以从freqlist、valArray等获取到该term的数据
BigSegmentedArray order = this.orderArray;
if (order == null) // we want to reuse the memory
{
order = newInstance(_termCountSize, maxDoc);
} else
{
order.ensureCapacity(maxDoc); // no need to fill to 0, we are reseting the
// data anyway
}
this.orderArray = order;
IntArrayList minIDList = new IntArrayList();
IntArrayList maxIDList = new IntArrayList();
IntArrayList freqList = new IntArrayList();
int length = maxDoc + 1;
TermValueList<T> list = listFactory == null ? (TermValueList<T>) new TermStringList()
: listFactory.createTermList();
TermDocs termDocs = reader.termDocs();
TermEnum termEnum = reader.terms(new Term(field, ""));
int t = 0; // current term number 就是上面order中对应的index，每个term对应自己的index
list.add(null);
minIDList.add(-1);
maxIDList.add(-1);
freqList.add(0);
// int df = 0;
t++;
try
{
do
{
Term term = termEnum.term();
if (term == null || term.field() != field)
break;
if (t > order.maxValue())
{
throw new IOException("maximum number of value cannot exceed: "
+ order.maxValue());
}
// store term text
// we expect that there is at most one term per document
if (t >= length)
throw new RuntimeException("there are more terms than "
+ "documents in field \"" + field
+ "\", but it's impossible to sort on " + "tokenized fields");
list.add(term.text());//将该term的text存到valArray 中
termDocs.seek(termEnum);
// freqList.add(termEnum.docFreq()); // doesn't take into account
// deldocs
int minID = -1;
int maxID = -1;
int df = 0;
if (termDocs.next())
{
df++;
int docid = termDocs.doc();
order.add(docid, t);
minID = docid;
while (termDocs.next())
{
df++;
docid = termDocs.doc();
order.add(docid, t);//记录下该doc对应的term
}
maxID = docid;
}
freqList.add(df);//添加term的df
minIDList.add(minID);//该term的倒排表中最小的docid
maxIDList.add(maxID);//该term的倒排表中最大的docid
t++;
} while (termEnum.next());
} finally
{
termDocs.close();
termEnum.close();
}
list.seal();
this.valArray = list;
this.freqs = freqList.toIntArray();
this.minIDs = minIDList.toIntArray();
this.maxIDs = maxIDList.toIntArray();
}
MultiValueFacetDataCache 的load()函数与 FacetDataCache基本一样，只是存储docid和index对应关系的地方不同，不是用大数组存储而是用 BufferedLoader 来存储。
- 下边分析一下BufferedLoader ，其成员 _info 是BigIntArray类型，就是个大数组
_buffer是BigIntBuffer类型，是一个动态分配的大数组
BigIntBuffer其实也相当于一个大数组，只不过是动态分配的，也算做了个hash，对数组分页，1024一个page
public class BigIntBuffer
{
private static final int PAGESIZE = 1024;
private static final int MASK = 0x3FF;
private static final int SHIFT = 10;
private ArrayList<int[]> _buffer;
private int _allocSize;
private int _mark;
public BigIntBuffer()
{
_buffer = new ArrayList<int[]>();
_allocSize = 0;
_mark = 0;//表示当前数组中当前可以存储数据的指针
}
public int alloc(int size)
{
if(size > PAGESIZE) throw new IllegalArgumentException("size too big");
if((_mark + size) > _allocSize)
{
int[] page = new int[PAGESIZE];//每次申请1024个int大小的内存，一页
_buffer.add(page);
_allocSize += PAGESIZE;
}
int ptr = _mark;
_mark += size;//将_mark指针向后移size个位置
return ptr;
}
public void reset()
{
_mark = 0;
}
public void set(int ptr, int val)
{
int[] page = _buffer.get(ptr >> SHIFT);
page[ptr & MASK] = val;
}
public int get(int ptr)
{
int[] page = _buffer.get(ptr >> SHIFT);
return page[ptr & MASK];
}
}
BufferedLoader类的add（int docid，int val）函数：
_info 是BigIntArray类型，就是个大数组，他申请的size是maxdoc的2倍，当field中的属性值(即term个数)小于等于2时，不需要_buffer存储，使用_info存储就可以了。大于2时就要使用_buffer了
//_info 是BigIntArray类型，就是个大数组
//_buffer是BigIntBuffer类型，是一个动态分配的大数组
public final boolean add(int id, int val)
{
int ptr = _info.get(id << 1);
if(ptr == EOD)
{
// 第一次插入，即插入id文档的第一个term
_info.add(id << 1, val);
return true;
}
int cnt = _info.get((id << 1) + 1);
if(cnt == EOD)
{
// 第二次插入，即插入id文档的第二个term
_info.add((id << 1) + 1, val);
return true;
}
if(ptr >= 0)
{
//此id的文档已经有2个term插入过了，那么要使用_buffer了
int firstVal = ptr;
int secondVal = cnt;
ptr = _buffer.alloc(SEGSIZE);//这里SEGSIZE等于8
_buffer.set(ptr++, EOD);//申请的内存的第一个位置填EOD，非EOD表示该id下term大于8，前面还有该id的term
_buffer.set(ptr++, firstVal);
_buffer.set(ptr++, secondVal);
_buffer.set(ptr++, val);
cnt = 3;
}
else
{
ptr = (- ptr);
if (cnt >= _maxItems) return false; // exceeded the limit
if((ptr % SEGSIZE) == 0)//意味着上一次申请的SEGSIZE个位置已经填满了
{
int oldPtr = ptr;//保存上一次申请的内存的指针
ptr = _buffer.alloc(SEGSIZE);//再申请一块SEGSIZE大小的内存
_buffer.set(ptr++, (- oldPtr));//将上一次啊申请内存指针写入新内存的第一个位置
}
_buffer.set(ptr++, val);//储存新加入的元素
cnt++;
}
_info.add(id << 1, (- ptr));
_info.add((id << 1) + 1, cnt);
return true;
}
//从id的文档中，读取对应的term（属性）
private final int readToBuf(int id, int[] buf)
{
int ptr = _info.get(id << 1);
int cnt = _info.get((id << 1) + 1);
int i;
if(ptr >=0)
{//ptr>0说明该文档的属性小于等于2（<2）
// read in-line data
i = 0;
buf[i++] = ptr;
if(cnt >= 0) buf[i++] = cnt;
return i;
}
// read from segments
//ptr<0 要从内存中读取term了
i = cnt;
while(ptr != EOD)
{
ptr = (- ptr) - 1;//得到最后的那个term的位置
int val;
while((val = _buffer.get(ptr--)) >= 0)//不是某次申请的SEGSIZE个位置的第一个位置
{
buf[--i] = val;
}
ptr = val;//如果这里的ptr不是EOD，那么指向上一个申请的内存块的最后一个位置
}
if(i > 0)
{
throw new RuntimeException("error reading buffered data back");
}
return cnt;
}