我们可以从java.io.InputStream类中看到，抽象出一个read方法，用来读取已经打开的InputStream实例中的字节，每次调用read方法，会读取一个字节数据，该方法抽象定义，如下所示：
public abstract int read() throws IOException;
Hadoop的DFSClient.DFSInputStream类实现了该抽象逻辑，如果我们清楚了如何从HDFS中读取一个文件的一个block的一个字节的原理，更加抽象的顶层只需要迭代即可获取到该文件的全部数据。
从HDFS读文件过程分析：获取文件对应的Block列表（原文链接：http://shiyanjun.cn/archives/925.html）中，我们已经获取到一个文件对应的Block列表信息，打开一个文件，接下来就要读取实际的物理块数据，我们从下面的几个方面来详细说明读取数据的过程。
Client从Datanode读取文件的一个字节
下面，我们通过分析DFSClient.DFSInputStream中实现的代码，读取HDFS上文件的内容。首先从下面的方法开始：
@Overridepublic synchronized int read() throws IOException { int ret = read( oneByteBuf, 0, 1 ); return ( ret <= 0 ) ? -1 : (oneByteBuf[0] & 0xff);}
上面调用read(oneByteBuf, 0, 1)读取一个字节到单字节缓冲区oneByteBuf中，具体实现见如下方法：
@Overridepublic synchronized int read(byte buf[], int off, int len) throws IOException { checkOpen(); if (closed) { throw new IOException("Stream closed"); } failures = 0; if (pos < getFileLength()) { int retries = 2; while (retries > 0) { try { if (pos > blockEnd) { currentNode = blockSeekTo(pos); } int realLen = (int) Math.min((long) len, (blockEnd - pos + 1L)); int result = readBuffer(buf, off, realLen); if (result >= 0) { pos += result; } else { throw new IOException("Unexpected EOS from the reader"); } if (stats != null && result != -1) { stats.incrementBytesRead(result); } return result; } catch (ChecksumException ce) { throw ce; } catch (IOException e) { if (retries == 1) { LOG.warn("DFS Read: " + StringUtils.stringifyException(e)); } blockEnd = -1; if (currentNode != null) { addToDeadNodes(currentNode); } if (--retries == 0) { throw e; } } } } return -1;}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
读取文件数据的一个字节，具体过程如下：
检查流对象是否处于打开状态（前面已经获取到文件对应的block列表的元数据，并打开一个InputStream对象）
从文件的第一个block开始读取，首先需要找到第一个block对应的数据块所在的Datanode，可以从缓存的block列表中查询到（如果查找不到，则会与Namenode进行一次RPC通信请求获取到）
打开一个到该读取的block所在Datanode节点的流，准备读取block数据
建立了到Datanode的连接后，读取一个字节数据到字节缓冲区中，返回读取的字节数（1个字节）
在读取的过程中，以字节为单位，通过判断某个偏移位置的字节属于哪个block（根据block元数据所限定的字节偏移范围），在根据这个block去定位某一个Datanode节点，这样就可连续地读取一个文件的全部数据（组成文件的、连续的多个block数据块）。
查找待读取的一个字节所在的Datanode节点
上面public synchronized int read(byte buf[], int off, int len) throws IOException方法，调用了blockSeekTo方法来获取，文件某个字节索引位置的数据所在的Datanode节点。其实，很容易就能想到，想要获取到数据所在的Datanode节点，一定是从block元数据中计算得到，然后根据Client缓存的block映射列表，找到block对应的Datanode列表，我们看一下blockSeekTo方法的代码实现：
private synchronized DatanodeInfo blockSeekTo(long target) throws IOException { ... ... DatanodeInfo chosenNode = null; int refetchToken = 1; while (true) { LocatedBlock targetBlock = getBlockAt(target, true); assert (target==this.pos) : "Wrong postion " + pos + " expect " + target; long offsetIntoBlock = target - targetBlock.getStartOffset(); DNAddrPair retval = chooseDataNode(targetBlock); chosenNode = retval.info; InetSocketAddress targetAddr = retval.addr; Block blk = targetBlock.getBlock(); Token<BlockTokenIdentifier> accessToken = targetBlock.getBlockToken(); if (shouldTryShortCircuitRead(targetAddr)) { try { blockReader = getLocalBlockReader(conf, src, blk, accessToken, chosenNode, DFSClient.this.socketTimeout, offsetIntoBlock); return chosenNode; } catch (AccessControlException ex) { LOG.warn("Short circuit access failed ", ex); shortCircuitLocalReads = false; } catch (IOException ex) { if (refetchToken > 0 && tokenRefetchNeeded(ex, targetAddr)) { refetchToken--; fetchBlockAt(target); continue; } else { LOG.info("Failed to read " + targetBlock.getBlock() + " on local machine" + StringUtils.stringifyException(ex)); LOG.info("Try reading via the datanode on " + targetAddr); } } } try { s = socketFactory.createSocket(); LOG.debug("Connecting to " + targetAddr); NetUtils.connect(s, targetAddr, getRandomLocalInterfaceAddr(), socketTimeout); s.setSoTimeout(socketTimeout); blockReader = RemoteBlockReader.newBlockReader(s, src, blk.getBlockId(), accessToken, blk.getGenerationStamp(), offsetIntoBlock, blk.getNumBytes() - offsetIntoBlock, buffersize, verifyChecksum, clientName); return chosenNode; } catch (IOException ex) { if (refetchToken > 0 && tokenRefetchNeeded(ex, targetAddr)) { refetchToken--; fetchBlockAt(target); } else { LOG.warn("Failed to connect to " + targetAddr + ", add to deadNodes and continue" + ex); if (LOG.isDebugEnabled()) { LOG.debug("Connection failure", ex); } addToDeadNodes(chosenNode); } if (s != null) { try { s.close(); } catch (IOException iex) { } } s = null; } }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
上面代码中，主要包括如下几个要点：
选择合适的Datanode节点，提高读取效率
在读取文件的时候，首先会从Namenode获取文件对应的block列表元数据，返回的block列表是按照Datanode的网络拓扑结构进行排序过的（本地节点优先，其次是同一机架节点），而且，Client还维护了一个dead node列表，只要此时bock对应的Datanode列表中节点不出现在dead node列表中就会被返回，用来作为读取数据的Datanode节点。
如果Client为集群Datanode节点，尝试从本地读取block
通过调用chooseDataNode方法返回一个Datanode结点，通过判断，如果该节点地址是本地地址，并且该节点上对应的block元数据信息的状态不是正在创建的状态，则满足从本地读取数据块的条件，然后会创建一个LocalBlockReader对象，直接从本地读取。在创建LocalBlockReader对象的过程中，会先从缓存中查找一个本地Datanode相关的LocalDatanodeInfo对象，该对象定义了与从本地Datanode读取数据的重要信息，以及缓存了待读取block对应的本地路径信息，可以从LocalDatanodeInfo类定义的属性来说明：
private ClientDatanodeProtocol proxy = null;private final Map<Block, BlockLocalPathInfo> cache;
如果缓存中存在待读取的block的相关信息，可以直接进行读取；否则，会创建一个proxy对象，以及计算待读取block的路径信息BlockLocalPathInfo，最后再加入到缓存，为后续可能的读取加速。我们看一下如果没有从缓存中找到LocalDatanodeInfo信息（尤其是BlockLocalPathInfo），则会执行如下逻辑：
// make RPC to local datanode to find local pathnames of blockspathinfo = proxy.getBlockLocalPathInfo(blk, token);
上面proxy为ClientDatanodeProtocol类型，Client与Datanode进行RPC通信的协议，RPC调用getBlockLocalPathInfo获取block对应的本地路径信息，可以在Datanode类中查看具体实现，如下所示：
BlockLocalPathInfo info = data.getBlockLocalPathInfo(block);
Datanode调用FSDataset（实现接口FSDatasetInterface）的getBlockLocalPathInfo，如下所示：
@Override public BlockLocalPathInfo getBlockLocalPathInfo(Block block) throws IOException { File datafile = getBlockFile(block); File metafile = getMetaFile(datafile, block); BlockLocalPathInfo info = new BlockLocalPathInfo(block, datafile.getAbsolutePath(), metafile.getAbsolutePath()); return info;}
接着可以直接去读取该block文件（如果需要检查校验和文件，会读取block的元数据文件metafile）：
... File blkfile = new File(pathinfo.getBlockPath());dataIn = new FileInputStream(blkfile);if (!skipChecksum) { File metafile = new File(pathinfo.getMetaPath()); checksumIn = new FileInputStream(metafile); BlockMetadataHeader header = BlockMetadataHeader.readHeader(new DataInputStream(checksumIn)); short version = header.getVersion(); if (version != FSDataset.METADATA_VERSION) { LOG.warn("Wrong version (" + version + ") for metadata file for " + blk + " ignoring ..."); } DataChecksum checksum = header.getChecksum(); localBlockReader = new BlockReaderLocal(conf, file, blk, token, startOffset, length, pathinfo, checksum, true, dataIn, checksumIn);} else { localBlockReader = new BlockReaderLocal(conf, file, blk, token, startOffset, length, pathinfo, dataIn);}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
在上面代码中，返回了BlockLocalPathInfo，但是很可能在这个过程中block被删除了，在删除block的时候，Namenode会调度指派该Datanode删除该block，恰好在这个时间间隔内block对应的BlockLocalPathInfo信息已经失效（文件已经被删除），所以上面这段代码再try中会抛出异常，并在catch中捕获到IO异常，会从缓存中再清除掉失效的block到BlockLocalPathInfo的映射信息。
- 如果Client非集群Datanode节点，远程读取block
如果Client不是Datanode本地节点，则只能跨网络节点远程读取，首先创建Socket连接
s = socketFactory.createSocket()LOG.debug("Connecting to " + targetAddr)NetUtils.connect(s, targetAddr, getRandomLocalInterfaceAddr(), socketTimeout)s.setSoTimeout(socketTimeout)
建立Client到目标Datanode（targetAddr）的连接，然后同样也是创建一个远程BlockReader对象RemoteBlockReader来辅助读取block数据。创建RemoteBlockReader过程中，首先向目标Datanode发送RPC请求：
// in and out will be closed when sock is closed (by the caller)DataOutputStream out = new DataOutputStream(new BufferedOutputStream(NetUtils.getOutputStream(sock,HdfsConstants.WRITE_TIMEOUT)))//write the header.out.writeShort( DataTransferProtocol.DATA_TRANSFER_VERSION )out.write( DataTransferProtocol.OP_READ_BLOCK )out.writeLong( blockId )out.writeLong( genStamp )out.writeLong( startOffset )out.writeLong( len )Text.writeString(out, clientName)accessToken.write(out)out.flush()
然后获取到DataInputStream对象来读取Datanode的响应信息：
DataInputStream in = new DataInputStream( new BufferedInputStream(NetUtils.getInputStream(sock), bufferSize));
最后，返回一个对象RemoteBlockReader：
return new RemoteBlockReader(file, blockId, in, checksum, verifyChecksum, startOffset, firstChunkOffset, sock);
借助BlockReader来读取block字节
我们再回到blockSeekTo方法中，待读取block所在的Datanode信息、BlockReader信息都已经具备，接着就可以从包含输入流（InputStream）对象的BlockReader中读取数据块中一个字节数据：
int result = readBuffer(buf, off, realLen);
将block数据中一个字节读取到buf中，如下所示：
private synchronized int readBuffer(byte buf[], int off, int len) throws IOException { IOException ioe; boolean retryCurrentNode = true; while (true) { try { return blockReader.read(buf, off, len); } catch ( ChecksumException ce ) { LOG.warn("Found Checksum error for " + currentBlock + " from " + currentNode.getName() + " at " + ce.getPos()); reportChecksumFailure(src, currentBlock, currentNode); ioe = ce; retryCurrentNode = false; } catch ( IOException e ) { if (!retryCurrentNode) { LOG.warn("Exception while reading from " + currentBlock + " of " + src + " from " + currentNode + ": " + StringUtils.stringifyException(e)); } ioe = e; } boolean sourceFound = false; if (retryCurrentNode) { sourceFound = seekToBlockSource(pos); } else { addToDeadNodes(currentNode); sourceFound = seekToNewSource(pos); } if (!sourceFound) { throw ioe; } retryCurrentNode = false; }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
通过BlockReaderLocal或者RemoteBlockReader来读取block数据，逻辑非常类似，主要是控制读取字节的偏移量，记录偏移量的状态信息，详细可以查看它们的源码。
DataNode节点处理读文件Block请求
我们可以在DataNode端看一下，如何处理一个读取Block的请求。如果Client与DataNode不是同一个节点，则为远程读取文件Block，首先Client需要发送一个请求头信息，代码如下所示：
//write the header.out.writeShort( DataTransferProtocol.DATA_TRANSFER_VERSION )out.write( DataTransferProtocol.OP_READ_BLOCK )out.writeLong( blockId )out.writeLong( genStamp )out.writeLong( startOffset )out.writeLong( len )Text.writeString(out, clientName)accessToken.write(out)out.flush()
DataNode节点端通过验证数据传输版本号（DataTransferProtocol.DATA_TRANSFER_VERSION）一致以后，会判断传输操作类型，如果是读操作DataTransferProtocol.OP_READ_BLOCK，则会通过Client建立的Socket来创建一个OutputStream对象，然后通过BlockSender向Client发送Block数据，代码如下所示：
try { blockSender = new BlockSender(block, startOffset, length, true, true, false, datanode, clientTraceFmt); } catch(IOException e) { out.writeShort(DataTransferProtocol.OP_STATUS_ERROR); throw e;}out.writeShort(DataTransferProtocol.OP_STATUS_SUCCESS); long read = blockSender.sendBlock(out, baseStream, null);
