Hadoop源码分析（16）
1、 RPC解析
在文档（15）中解析了实际进行远程调用client类的call方法。在该文档中提到的其本质是使用java的NIO与远端的服务器进行连接。并通过channel将需要执行的方法的数据发送过去，然后等待远端将执行结果返回给客户端。
hdfs的组件中很多都有RPC的server端，之前文档分析到namenode启动的时候会从journalnode中读取其存储的editlog，因此需要使用RPC获取其存储的editlog列表。所以这里按照分析的思路，以journalnode的RPC服务端为例。
这里先以journalnode的启动为入口，分析其如何启动RPC服务的。
在文档（3）中提到了在文件hdfs中会有hdfs所有组件所用的类。其中启动journalnode所用的类为：org.apache.hadoop.hdfs.qjournal.server.JournalNode。这个类的main方法如下：
public static void main(String[] args) throws Exception {
StringUtils.startupShutdownMessage(JournalNode.class, args, LOG);
try {
System.exit(ToolRunner.run(new JournalNode(), args));
} catch (Throwable e) {
LOG.error("Failed to start journalnode.", e);
terminate(-1, e);
}
}重点在第4行，这行的重点是ToolRunner类的run方法，这个方法会闯入一个新建的journalnode对象和传入main方法args。这个run方法如下：
public static int run(Configuration conf, Tool tool, String[] args)
throws Exception{
if(conf == null) {
conf = new Configuration();
}
GenericOptionsParser parser = new GenericOptionsParser(conf, args);
//set the configuration back, so that Tool can configure itself
tool.setConf(conf);
//get the args w/o generic hadoop args
String[] toolArgs = parser.getRemainingArgs();
return tool.run(toolArgs);
}这里的重点在于最后一行，调用tool的run方法。这里的tool实际是传入的journalnode对象。其run方法如下：
public int run(String[] args) throws Exception {
start();
return join();
}这里主要调用的是start方法，方法内容如下：
public void start() throws IOException {
Preconditions.checkState(!isStarted(), "JN already running");
validateAndCreateJournalDir(localDir);
DefaultMetricsSystem.initialize("JournalNode");
JvmMetrics.create("JournalNode",
conf.get(DFSConfigKeys.DFS_METRICS_SESSION_ID_KEY),
DefaultMetricsSystem.instance());
InetSocketAddress socAddr = JournalNodeRpcServer.getAddress(conf);
SecurityUtil.login(conf, DFSConfigKeys.DFS_JOURNALNODE_KEYTAB_FILE_KEY,
DFSConfigKeys.DFS_JOURNALNODE_KERBEROS_PRINCIPAL_KEY, socAddr.getHostName());
registerJNMXBean();
httpServer = new JournalNodeHttpServer(conf, this);
httpServer.start();
httpServerURI = httpServer.getServerURI().toString();
rpcServer = new JournalNodeRpcServer(conf, this);
rpcServer.start();
}与RPC相关的在第22行，这里创建了一个JournalNodeRpcServer对象。这个方法的构造方法如下：
JournalNodeRpcServer(Configuration conf, JournalNode jn) throws IOException {
this.jn = jn;
Configuration confCopy = new Configuration(conf);
// Ensure that nagling doesn't kick in, which could cause latency issues.
confCopy.setBoolean(
CommonConfigurationKeysPublic.IPC_SERVER_TCPNODELAY_KEY,
true);
InetSocketAddress addr = getAddress(confCopy);
RPC.setProtocolEngine(confCopy, QJournalProtocolPB.class,
ProtobufRpcEngine.class);
QJournalProtocolServerSideTranslatorPB translator =
new QJournalProtocolServerSideTranslatorPB(this);
BlockingService service = QJournalProtocolService
.newReflectiveBlockingService(translator);
this.server = new RPC.Builder(confCopy)
.setProtocol(QJournalProtocolPB.class)
.setInstance(service)
.setBindAddress(addr.getHostName())
.setPort(addr.getPort())
.setNumHandlers(HANDLER_COUNT)
.setVerbose(false)
.build();
// set service-level authorization security policy
if (confCopy.getBoolean(
CommonConfigurationKeys.HADOOP_SECURITY_AUTHORIZATION, false)) {
server.refreshServiceAcl(confCopy, new HDFSPolicyProvider());
}
}首先是第12行的setProtocolEngine方法，这个方法在文档（14）中介绍过，其主要作用是设置接口使用的engine类。然后是第14行到第17行，创建一个service用来处理远程调用的方法。最后是第19行到第26行创建rpc server。
这里RPC server的方式与文档（13）使用的方式相同。首先创建一个Builder类，然后向builder中设置需要的参数，最后再调用build方法创建server。其中重点在build方法。其内容如下：
public Server build() throws IOException, HadoopIllegalArgumentException {
if (this.conf == null) {
throw new HadoopIllegalArgumentException("conf is not set");
}
if (this.protocol == null) {
throw new HadoopIllegalArgumentException("protocol is not set");
}
if (this.instance == null) {
throw new HadoopIllegalArgumentException("instance is not set");
}
return getProtocolEngine(this.protocol, this.conf).getServer(
this.protocol, this.instance, this.bindAddress, this.port,
this.numHandlers, this.numReaders, this.queueSizePerHandler,
this.verbose, this.conf, this.secretManager, this.portRangeConfig);
}
}首先是第2行到第10行，这里主要是检查一些参数。重点在第12行这里先用getProtocolEngine方法获取engine类，然后调用engine类的getServer方法。getProtocolEngine方法在文档（14）中也提到过，它最终获取的类是是上文设置的ProtobufRpcEngine类。这个类的getserver方法内容如下：
@Override
public RPC.Server getServer(Class<?> protocol, Object protocolImpl,
String bindAddress, int port, int numHandlers, int numReaders,
int queueSizePerHandler, boolean verbose, Configuration conf,
SecretManager<? extends TokenIdentifier> secretManager,
String portRangeConfig)
throws IOException {
return new Server(protocol, protocolImpl, conf, bindAddress, port,
numHandlers, numReaders, queueSizePerHandler, verbose, secretManager,
portRangeConfig);
}这里是直接创建了一个server对象，这个server对象是其内部类继承于RPC的server，其内容如下：
public static class Server extends RPC.Server这个类的构造方法如下：
public Server(Class<?> protocolClass, Object protocolImpl,
Configuration conf, String bindAddress, int port, int numHandlers,
int numReaders, int queueSizePerHandler, boolean verbose,
SecretManager<? extends TokenIdentifier> secretManager,
String portRangeConfig)
throws IOException {
super(bindAddress, port, null, numHandlers,
numReaders, queueSizePerHandler, conf, classNameBase(protocolImpl
.getClass().getName()), secretManager, portRangeConfig);
this.verbose = verbose;
registerProtocolAndImpl(RPC.RpcKind.RPC_PROTOCOL_BUFFER, protocolClass,
protocolImpl);
}这里的重点有两个，第一个是第7行的super方法，这个方法会调用父类的构造方法。第二个是第11行的registerProtocolAndImpl方法，这两个方法会将远程调用的接口与其实现类进行封装存储。
这里先解析registerProtocolAndImpl方法，其内容如下：
void registerProtocolAndImpl(RpcKind rpcKind, Class<?> protocolClass,
Object protocolImpl) {
String protocolName = RPC.getProtocolName(protocolClass);
long version;
try {
version = RPC.getProtocolVersion(protocolClass);
} catch (Exception ex) {
LOG.warn("Protocol " + protocolClass +
" NOT registered as cannot get protocol version ");
return;
}
getProtocolImplMap(rpcKind).put(new ProtoNameVer(protocolName, version),
new ProtoClassProtoImpl(protocolClass, protocolImpl));
LOG.debug("RpcKind = " + rpcKind + " Protocol Name = " + protocolName + " version=" + version +
" ProtocolImpl=" + protocolImpl.getClass().getName() +
" protocolClass=" + protocolClass.getName());
}这段代码实际不复杂，首先是第3行拿到接口的名称，然后是第8行拿到接口的版本号。然后是第16行先用getProtocolImplMap方拿到存储该接口信息的map，然后使用put方法将数据设置到map中。其中key是封装了接口名称与版本的ProtoNameVer类对象，value是封装了接口与实现类的ProtoClassProtoImpl类对象。这两个类都是单纯用来存储数据的，没有其他特殊方法。
用来获取map的getProtocolImplMap方法，也很简单，其内容如下：
Map<ProtoNameVer, ProtoClassProtoImpl> getProtocolImplMap(RPC.RpcKind rpcKind) {
if (protocolImplMapArray.size() == 0) {// initialize for all rpc kinds
for (int i=0; i <= RpcKind.MAX_INDEX; ++i) {
protocolImplMapArray.add(
new HashMap<ProtoNameVer, ProtoClassProtoImpl>(10));
}
}
return protocolImplMapArray.get(rpcKind.ordinal());
}首先是第2行，如果protocolImplMapArray中没有数据，便根据RpcKind的最大值来向其中添加hashmap。这里的protocolImplMapArray是一个ArrayList。最后是第8行根据传入的rpcKind类获取对应的map。
然后再看这个server的super方法，这个方法调用的是其父类RPC的server。其内容如下：
protected Server(String bindAddress, int port,
Class<? extends Writable> paramClass, int handlerCount,
int numReaders, int queueSizePerHandler,
Configuration conf, String serverName,
SecretManager<? extends TokenIdentifier> secretManager,
String portRangeConfig) throws IOException {
super(bindAddress, port, paramClass, handlerCount, numReaders, queueSizePerHandler,
conf, serverName, secretManager, portRangeConfig);
initProtocolMetaInfo(conf);
}这里可以看见第7行又调用了父类的构造方法。这个类继承于ipc的Server类，定义如下所示：
public abstract static class Server extends org.apache.hadoop.ipc.Server这里创建的server的继承关系如下：首先是engine类ProtobufRpcEngine，在这个类的getServer方法会创建server对象。它创建的server是其内部类Server类的对象，这个类有继承于RPC类的内部类Server类。然后这个Server又继承于ipc包下的Server类。
