HFile写入Cell浅析（一）
在HBase中，无论是MemStore的flush，还是HFile的Compact，都会涉及到新HFile的产生，那么HFile是如何产生的呢？我们又是如何将数据Cell写入到HFile中的呢？本文，我们将会大家简单介绍下HFile写入Cell的主体流程。
在《HFile文件格式》一文中，我们简单给大家介绍了HFile文件内容的组织形式，理解这篇文章，将会对理解本文有所帮助，请读者自行阅读。
HFile文件Cell的写入，发起的一个地方，就是MemStore flush时，StoreFlusher的performFlush()方法，如下：
/**
* Performs memstore flush, writing data from scanner into sink.
* 执行memstore的刷新，将数据从scanner写入到sink
*
* @param scanner Scanner to get data from.
* @param sink Sink to write data to. Could be StoreFile.Writer.
* @param smallestReadPoint Smallest read point used for the flush.
*/
protected void performFlush(InternalScanner scanner,
Compactor.CellSink sink, long smallestReadPoint) throws IOException {
int compactionKVMax =
conf.getInt(HConstants.COMPACTION_KV_MAX, HConstants.COMPACTION_KV_MAX_DEFAULT);
List<Cell> kvs = new ArrayList<Cell>();
boolean hasMore;
do {
hasMore = scanner.next(kvs, compactionKVMax);
if (!kvs.isEmpty()) {
// 循环Cell列表，调用Compactor.CellSink的sink方法，append数据到磁盘
for (Cell c : kvs) {
// If we know that this KV is going to be included always, then let us
// set its memstoreTS to 0. This will help us save space when writing to
// disk.
// 如果我们知道这个KV是包括总,然后让我们设置它memstoreTS为0。这将帮助我们节省空间在写入磁盘。
sink.append(c);
}
kvs.clear();
}
} while (hasMore);
} 它会循环的将Cell写入Compactor.CellSink类型的sink，那么这个sink是什么呢？在performFlush()方法的上层调用者DefaultStoreFlusher的flushSnapshot()方法中，首先会调用HStore的createWriterInTmp()方法生成一个StoreFile.Writer实例writer，然后将这个writer作为参数sink传入performFlush()方法，如下：
// Write the map out to the disk
// 创建Writer
writer = store.createWriterInTmp(
cellsCount, store.getFamily().getCompression(), false, true, true);
writer.setTimeRangeTracker(snapshot.getTimeRangeTracker());
IOException e = null;
try {
performFlush(scanner, writer, smallestReadPoint);
} catch (IOException ioe) {
e = ioe;
// throw the exception out
throw ioe;
} finally {
if (e != null) {
writer.close();
} else {
finalizeWriter(writer, cacheFlushId, status);
}
} 我们再看这个StoreFile.Writer类型的writer是如何生成的，进入HStore的createWriterInTmp()方法，代码如下：
// 创建StoreFile的StoreFile，需要使用上述信息，比如文件系统、文件路径、合并器、最大keyvalue数目、有利节点等
StoreFile.Writer w = new StoreFile.WriterBuilder(conf, writerCacheConf,
this.getFileSystem())// 文件系统
.withFilePath(fs.createTempName())// 文件路径
.withComparator(comparator)// 合并器
.withBloomType(family.getBloomFilterType())
.withMaxKeyCount(maxKeyCount)// 最大keyvalue数目
.withFavoredNodes(favoredNodes)// 有利节点
.withFileContext(hFileContext)// HFile上下文信息
.build(); 而在StoreFile.WriterBuilder的build()方法最后，会new一个StoreFile.Writer实例，在其构造方法中，会生成一个HFile.Writer实例writer，如下：
writer = HFile.getWriterFactory(conf, cacheConf)
.withPath(fs, path)
.withComparator(comparator)
.withFavoredNodes(favoredNodes)
.withFileContext(fileContext)
.create(); 而这个HFile.Writer实例writer则是通过HFile中WriterFactory获取的，如下：
/**
* Returns the factory to be used to create {@link HFile} writers
*/
public static final WriterFactory getWriterFactory(Configuration conf,
CacheConfig cacheConf) {
int version = getFormatVersion(conf);
switch (version) {
case 2:
return new HFileWriterV2.WriterFactoryV2(conf, cacheConf);
case 3:
return new HFileWriterV3.WriterFactoryV3(conf, cacheConf);
default:
throw new IllegalArgumentException("Cannot create writer for HFile " +
"format version " + version);
}
} HBase中包含两种类型的WriterFactoryV2，分别为HFileWriterV2.WriterFactoryV2和HFileWriterV3.WriterFactoryV3，今天我们以HFileWriterV2.WriterFactoryV2为例，其creaet的HFile.Writer实例其实为HFileWriterV2类型，如下：
@Override
public Writer createWriter(FileSystem fs, Path path,
FSDataOutputStream ostream,
KVComparator comparator, HFileContext context) throws IOException {
context.setIncludesTags(false);// HFile V2 does not deal with tags at all!
return new HFileWriterV2(conf, cacheConf, fs, path, ostream,
comparator, context);
}
} 那么，最开始的sink调用append循环写入Cell，实际上最终调用的是HFileWriterV2的append()方法，如下：
public void append(final Cell cell) throws IOException {
appendGeneralBloomfilter(cell);
appendDeleteFamilyBloomFilter(cell);
writer.append(cell);// 调用HFile的Writer的append()方法，将数据写入文件
trackTimestamps(cell);// 记录本次Put操作的时间戳
} 这个writer的实例化就是我们上面讲到的HFileWriterV2的实例化。下面，我们重点看下HFileWriterV2的append()方法，如下：
/**
* Add key/value to file. Keys must be added in an order that agrees with the
* Comparator passed on construction.
*
* @param cell Cell to add. Cannot be empty nor null.
* @throws IOException
*/
@Override
public void append(final Cell cell) throws IOException {
// 从Cell中获取数据value、偏移量voffset、长度vlength
byte[] value = cell.getValueArray();
int voffset = cell.getValueOffset();
int vlength = cell.getValueLength();
// checkKey uses comparator to check we are writing in order.
// 检测给定Cell，确保key是有序的，dupKey为true说明key没有换，false说明key已更改
boolean dupKey = checkKey(cell);
// 检测value，确保value不为null
checkValue(value, voffset, vlength);
if (!dupKey) {// 换key时才检测block边界
checkBlockBoundary();
}
if (!fsBlockWriter.isWriting()) {
// 申请新块
newBlock();
}
// 写入Cell
fsBlockWriter.write(cell);
// 累加Key长度totalKeyLength和Value长度totalValueLength
totalKeyLength += CellUtil.estimatedSerializedSizeOfKey(cell);
totalValueLength += vlength;
// Are we the first key in this block?
// 标记该数据块中写入的第一个key，firstCellInBlock
if (firstCellInBlock == null) {
// If cell is big, block will be closed and this firstCellInBlock reference will only last
// a short while.
firstCellInBlock = cell;
}
// TODO: What if cell is 10MB and we write infrequently? We'll hold on to the cell here
// indefinetly?
// 标记上次写入Cell，即lastCell赋值为当前cell
lastCell = cell;
// 条目计数加1
entryCount++;
// 更新maxMemstoreTS
this.maxMemstoreTS = Math.max(this.maxMemstoreTS, cell.getSequenceId());
} 逻辑很简单，大体如下：
1、首先从Cell中获取数据value、偏移量voffset、长度vlength；
2、然后调用checkKey()方法，检测给定Cell，确保key是有序的，dupKey为true说明key没有换，false说明key已更改；
3、接着调用checkValue()方法，检测value，确保value不为null；
4、换key时才检测block边界，此时调用的是checkBlockBoundary()方法；
5、如果需要申请新的数据块的话，调用newBlock()方法申请新的数据块，判断的依据是fsBlockWriter的isWriting()返回为false，表明文件系统数据块写入者暂停写入；
6、调用fsBlockWriter的write()方法写入Cell；
7、累加Key长度totalKeyLength和Value长度totalValueLength；
8、如果需要，标记该数据块中写入的第一个key，firstCellInBlock；
9、标记上次写入Cell，即lastCell赋值为当前cell；
10、条目计数entryCount加1；
11、更新maxMemstoreTS。
检测block边界的checkBlockBoundary()方法如下：
/**
* At a block boundary, write all the inline blocks and opens new block.
*
* @throws IOException
*/
protected void checkBlockBoundary() throws IOException {
// 如果fsBlockWriter已写入大小小于hFileContext中定义的块大小，直接返回
if (fsBlockWriter.blockSizeWritten() < hFileContext.getBlocksize())
return;
// 结束上一个块
finishBlock();
// 写入InlineBlocks
writeInlineBlocks(false);
// 申请新块
newBlock();
} 它会首先判断fsBlockWriter已写入大小，如果fsBlockWriter已写入大小小于hFileContext中定义的块大小，说明block未越界，直接返回，否则的话，说明block已经达到或者超过设定的阈值，此时，需要做以下处理：
1、调用finishBlock()方法，结束上一个block；
2、调用writeInlineBlocks()方法，写入InlineBlocks；
3、调用newBlock()方法，申请新块。
未完待续！