import org.apache.hadoop.ipc.protobuf.ProtocolInfoProtos.GetProtocolSignatureResponseProto; //导入依赖的package包/类
@Override
public GetProtocolSignatureResponseProto getProtocolSignature(
    RpcController controller, GetProtocolSignatureRequestProto request)
    throws ServiceException {
  GetProtocolSignatureResponseProto.Builder builder = GetProtocolSignatureResponseProto
      .newBuilder();
  String protocol = request.getProtocol();
  String rpcKind = request.getRpcKind();
  long[] versions;
  try {
    versions = getProtocolVersionForRpcKind(RPC.RpcKind.valueOf(rpcKind),
        protocol);
  } catch (ClassNotFoundException e1) {
    throw new ServiceException(e1);
  }
  if (versions == null) {
    return builder.build();
  }
  for (long v : versions) {
    ProtocolSignatureProto.Builder sigBuilder = ProtocolSignatureProto
        .newBuilder();
    sigBuilder.setVersion(v);
    try {
      ProtocolSignature signature = ProtocolSignature.getProtocolSignature(
          protocol, v);
      for (int m : signature.getMethods()) {
        sigBuilder.addMethods(m);
      }
    } catch (ClassNotFoundException e) {
      throw new ServiceException(e);
    }
    builder.addProtocolSignature(sigBuilder.build());
  }
  return builder.build();
}
 

import org.apache.hadoop.ipc.protobuf.ProtocolInfoProtos.GetProtocolSignatureResponseProto; //导入依赖的package包/类
/**
 * Verify that ProtocolMetaInfoServerSideTranslatorPB correctly looks up
 * the server registry to extract protocol signatures and versions.
 */
@Test
public void testProtocolMetaInfoSSTranslatorPB() throws Exception {
  TestImpl1 impl = new TestImpl1();
  server = new RPC.Builder(conf).setProtocol(TestProtocol1.class)
      .setInstance(impl).setBindAddress(ADDRESS).setPort(0).setNumHandlers(2)
      .setVerbose(false).build();
  server.addProtocol(RPC.RpcKind.RPC_WRITABLE, TestProtocol0.class, impl);
  server.start();

  ProtocolMetaInfoServerSideTranslatorPB xlator = 
      new ProtocolMetaInfoServerSideTranslatorPB(server);

  GetProtocolSignatureResponseProto resp = xlator.getProtocolSignature(
      null,
      createGetProtocolSigRequestProto(TestProtocol1.class,
          RPC.RpcKind.RPC_PROTOCOL_BUFFER));
  //No signatures should be found
  Assert.assertEquals(0, resp.getProtocolSignatureCount());
  resp = xlator.getProtocolSignature(
      null,
      createGetProtocolSigRequestProto(TestProtocol1.class,
          RPC.RpcKind.RPC_WRITABLE));
  Assert.assertEquals(1, resp.getProtocolSignatureCount());
  ProtocolSignatureProto sig = resp.getProtocolSignatureList().get(0);
  Assert.assertEquals(TestProtocol1.versionID, sig.getVersion());
  boolean found = false;
  int expected = ProtocolSignature.getFingerprint(TestProtocol1.class
      .getMethod("echo", String.class));
  for (int m : sig.getMethodsList()) {
    if (expected == m) {
      found = true;
      break;
    }
  }
  Assert.assertTrue(found);
}
 

import org.apache.hadoop.ipc.protobuf.ProtocolInfoProtos.GetProtocolSignatureResponseProto; //导入依赖的package包/类
/**
 * Returns whether the given method is supported or not.
 * The protocol signatures are fetched and cached. The connection id for the
 * proxy provided is re-used.
 * @param rpcProxy Proxy which provides an existing connection id.
 * @param protocol Protocol for which the method check is required.
 * @param rpcKind The RpcKind for which the method check is required.
 * @param version The version at the client.
 * @param methodName Name of the method.
 * @return true if the method is supported, false otherwise.
 * @throws IOException
 */
public static boolean isMethodSupported(Object rpcProxy, Class<?> protocol,
    RPC.RpcKind rpcKind, long version, String methodName) throws IOException {
  InetSocketAddress serverAddress = RPC.getServerAddress(rpcProxy);
  Map<Long, ProtocolSignature> versionMap = getVersionSignatureMap(
      serverAddress, protocol.getName(), rpcKind.toString());

  if (versionMap == null) {
    Configuration conf = new Configuration();
    RPC.setProtocolEngine(conf, ProtocolMetaInfoPB.class,
        ProtobufRpcEngine.class);
    ProtocolMetaInfoPB protocolInfoProxy = getProtocolMetaInfoProxy(rpcProxy,
        conf);
    GetProtocolSignatureRequestProto.Builder builder = 
        GetProtocolSignatureRequestProto.newBuilder();
    builder.setProtocol(protocol.getName());
    builder.setRpcKind(rpcKind.toString());
    GetProtocolSignatureResponseProto resp;
    try {
      resp = protocolInfoProxy.getProtocolSignature(NULL_CONTROLLER,
          builder.build());
    } catch (ServiceException se) {
      throw ProtobufHelper.getRemoteException(se);
    }
    versionMap = convertProtocolSignatureProtos(resp
        .getProtocolSignatureList());
    putVersionSignatureMap(serverAddress, protocol.getName(),
        rpcKind.toString(), versionMap);
  }
  // Assuming unique method names.
  Method desiredMethod;
  Method[] allMethods = protocol.getMethods();
  desiredMethod = null;
  for (Method m : allMethods) {
    if (m.getName().equals(methodName)) {
      desiredMethod = m;
      break;
    }
  }
  if (desiredMethod == null) {
    return false;
  }
  int methodHash = ProtocolSignature.getFingerprint(desiredMethod);
  return methodExists(methodHash, version, versionMap);
}