Java Message.getSerializedSize方法代码示例

import com.google.protobuf.Message; //导入方法依赖的package包/类
/**
 * @param m Message to serialize delimited; i.e. w/ a vint of its size preceeding its
 * serialization.
 * @return The passed in Message serialized with delimiter.  Return null if <code>m</code> is null
 * @throws IOException
 */
public static ByteBuffer getDelimitedMessageAsByteBuffer(final Message m) throws IOException {
  if (m == null) return null;
  int serializedSize = m.getSerializedSize();
  int vintSize = CodedOutputStream.computeRawVarint32Size(serializedSize);
  byte [] buffer = new byte[serializedSize + vintSize];
  // Passing in a byte array saves COS creating a buffer which it does when using streams.
  CodedOutputStream cos = CodedOutputStream.newInstance(buffer);
  // This will write out the vint preamble and the message serialized.
  cos.writeMessageNoTag(m);
  cos.flush();
  cos.checkNoSpaceLeft();
  return ByteBuffer.wrap(buffer);
}
 

import com.google.protobuf.Message; //导入方法依赖的package包/类
/**
 * @return Size on the wire when the two messages are written with writeDelimitedTo
 */
public static int getTotalSizeWhenWrittenDelimited(Message ... messages) {
  int totalSize = 0;
  for (Message m: messages) {
    if (m == null) continue;
    totalSize += m.getSerializedSize();
    totalSize += CodedOutputStream.computeRawVarint32Size(m.getSerializedSize());
  }
  Preconditions.checkArgument(totalSize < Integer.MAX_VALUE);
  return totalSize;
}
 

import com.google.protobuf.Message; //导入方法依赖的package包/类
/**
 * This is a server side method, which is invoked over RPC. On success
 * the return response has protobuf response payload. On failure, the
 * exception name and the stack trace are returned in the protobuf response.
 */
@Override
public Pair<Message, CellScanner> call(BlockingService service, MethodDescriptor md,
    Message param, CellScanner cellScanner, long receiveTime, MonitoredRPCHandler status)
throws IOException {
  try {
    status.setRPC(md.getName(), new Object[]{param}, receiveTime);
    // TODO: Review after we add in encoded data blocks.
    status.setRPCPacket(param);
    status.resume("Servicing call");
    //get an instance of the method arg type
    long startTime = System.currentTimeMillis();
    PayloadCarryingRpcController controller = new PayloadCarryingRpcController(cellScanner);
    Message result = service.callBlockingMethod(md, controller, param);
    long endTime = System.currentTimeMillis();
    int processingTime = (int) (endTime - startTime);
    int qTime = (int) (startTime - receiveTime);
    int totalTime = (int) (endTime - receiveTime);
    if (LOG.isTraceEnabled()) {
      LOG.trace(CurCall.get().toString() +
          ", response " + TextFormat.shortDebugString(result) +
          " queueTime: " + qTime +
          " processingTime: " + processingTime +
          " totalTime: " + totalTime);
    }
    long requestSize = param.getSerializedSize();
    long responseSize = result.getSerializedSize();
    metrics.dequeuedCall(qTime);
    metrics.processedCall(processingTime);
    metrics.totalCall(totalTime);
    metrics.receivedRequest(requestSize);
    metrics.sentResponse(responseSize);
    // log any RPC responses that are slower than the configured warn
    // response time or larger than configured warning size
    boolean tooSlow = (processingTime > warnResponseTime && warnResponseTime > -1);
    boolean tooLarge = (responseSize > warnResponseSize && warnResponseSize > -1);
    if (tooSlow || tooLarge) {
      // when tagging, we let TooLarge trump TooSmall to keep output simple
      // note that large responses will often also be slow.
      logResponse(new Object[]{param},
          md.getName(), md.getName() + "(" + param.getClass().getName() + ")",
          (tooLarge ? "TooLarge" : "TooSlow"),
          status.getClient(), startTime, processingTime, qTime,
          responseSize);
    }
    return new Pair<Message, CellScanner>(result, controller.cellScanner());
  } catch (Throwable e) {
    // The above callBlockingMethod will always return a SE.  Strip the SE wrapper before
    // putting it on the wire.  Its needed to adhere to the pb Service Interface but we don't
    // need to pass it over the wire.
    if (e instanceof ServiceException) e = e.getCause();

    // increment the number of requests that were exceptions.
    metrics.exception(e);

    if (e instanceof LinkageError) throw new DoNotRetryIOException(e);
    if (e instanceof IOException) throw (IOException)e;
    LOG.error("Unexpected throwable object ", e);
    throw new IOException(e.getMessage(), e);
  }
}