private void judgeException(HSFResponse hsfResp, int timeout) {
    if (hsfResp.isError()) {
      if (ResponseStatus.CLIENT_TIMEOUT == hsfResp.getStatus())
        throw new HSFTimeOutException(getErrorLog(hsfResp.getErrorMsg()), String.valueOf(timeout)); 
      if (hsfResp.getAppResponse() instanceof Throwable)
        throw new HSFException(hsfResp.getErrorMsg(), (Throwable)hsfResp.getAppResponse()); 
      throw new HSFException(String.valueOf(hsfResp.getStatus().getCode()), hsfResp.getErrorMsg());
    } 
  }

SERVER_GETCODER(10, "server send coders"),
  OK(20, "HSF Provider process succeed."),
  CLIENT_TIMEOUT(30, "client timeout"),
  SERVER_TIMEOUT(31, "server timeout"),
  CLIENT_WRITE_ERROR(32, "client write error"),
  BAD_REQUEST(40, "bad request"),
  BAD_RESPONSE(50, "Some unknown exception happened in hsf provider during process IO protocol.Please check hsf.log in provider's machine."),
  SERVICE_NOT_FOUND(60, "service not found"),
  METHOD_NOT_FOUND(61, "method not found"),
  HTTP_INTERCEPTOR_NOT_FOUND(62, "HSF http cannot find a interceptor to process this request"),
  TOP_SERVICE_TRANSFORMER_NOT_FOUND(63, "Top transformer not found"),
  TOP_TRANSFORMER_ERROR(64, "exception happened in top transformer"),
  SERVICE_ERROR(70, "HSF Provider catch some exception when invoke biz method."),
  SERVER_ERROR(80, "server error"),
  THREADPOOL_BUSY(81, "Provider's HSF thread pool is full."),
  COMM_ERROR(82, "Communication error"),
  UNKNOWN_CODE(83, "Unknown code"),
  SERVER_SERIALIZE_ERROR(84, "Deserialize request error on provider side.Please make sure the arguments of request are serializable and your dependency is latest"),
  PERMISSION_VERIFY_REJECT(85, "HSF Provider reject your request because spas verify your permission failed."),
  UNIT_VERIFY_REJECT(86, "HSF Provider reject your request because of wrong target unit."),
  TPS_VERIFY_REJECT(87, "HSF Provider reject your request because of exceeding tps limit."),
  SERVER_CLOSING(88, "server will close soon"),
  CLIENT_ERROR(90, "client error"),
  UNKNOWN_ERROR(91, "Some unknown exception happened in hsf provider.Please check hsf.log in provider's machine."),
  WHITELIST_VERIFY_REJECT(92, "HSF Provider reject your request because of the consumer is not in whitelist."),
  CLIENT_DESERIALIZE_ERROR(100, "server send coders"),
  REGION_VERIFY_REJECT(101, "HSF Provider reject your request because of wrong target region."),
  FILTER_EXCEPTION(102, "HSF Filter exception");

public ResponsePacket serverCreate(RPCResult rpcResult, Stream serverStream) {
    byte[] bodyBytes;
    long requestId = rpcResult.getResponseContext().getRequestId();
    byte serializeType = rpcResult.getResponseContext().getSerializeType();
    Serializer serializer = SerializerSelector.getInstance().select(serializeType);
    byte[] responseMapBody = null;
    byte status = rpcResult.getHsfResponse().getStatus().getCode();
    try {
      if (rpcResult.isError()) {
        if (rpcResult.getErrorMsg() != null) {
          bodyBytes = rpcResult.getErrorMsg().getBytes(RemotingConstants.DEFAULT_CHARSET);
        } else {
          bodyBytes = "unknown error".getBytes(RemotingConstants.DEFAULT_CHARSET);
        } 
      } else {
        if (status == ResponseStatus.SERVICE_ERROR.getCode())
          status = ResponseStatus.OK.getCode(); 
        bodyBytes = serializer.serialize(rpcResult.getAppResponse(), serverStream);
      } 
      if (rpcResult.getResponseContext().isResponseAttachmentSupported()) {
        Map responseAttachmentMap = rpcResult.getAttachments();
        if (responseAttachmentMap != null && !responseAttachmentMap.isEmpty())
          responseMapBody = serializer.serialize(rpcResult.getAttachments(), serverStream); 
      } 
    } catch (Exception e) {
      String errorMsg = "Serialize response error on provider side.Please make sure your DO is serializable and your dependency is latest.";
      String errorCodeStr = LoggerHelper.getErrorCodeStr("HSF", "HSF-0037", "BIZ", errorMsg);
      log.error("HSF-0037", errorCodeStr + serverStream, e);
      bodyBytes = errorMsg.getBytes(RemotingConstants.DEFAULT_CHARSET);
      status = ResponseStatus.SERVER_SERIALIZE_ERROR.getCode();
    } 
    return (ResponsePacket)new HSFResponsePacket(requestId, serializeType, status, bodyBytes, responseMapBody);
  }

public Serializer getCustomSerializer(Class cl) {
    Serializer serializer = this._customSerializerMap.get(cl.getName());
    if (serializer == AbstractSerializer.NULL)
      return null; 
    if (serializer != null)
      return serializer; 
    try {
      Class<?> serClass = Class.forName(cl.getName() + "HessianSerializer", false, cl.getClassLoader());
      Serializer ser = (Serializer)serClass.newInstance();
      this._customSerializerMap.put(cl.getName(), ser);
      return ser;
    } catch (ClassNotFoundException e) {
      log.log(Level.ALL, e.toString(), e);
    } catch (Exception e) {
      throw new HessianException(e);
    } 
    this._customSerializerMap.put(cl.getName(), AbstractSerializer.NULL);
    return null;
  }

@Name("hessian")
@Summary("HSF Hessian Test")
@Description(Constants.EXAMPLE +
        "  hessian cn.chinapost.jdpt.tms.api.transport.dto.ContractCollectVolumnCapacity \n" +
        Constants.WIKI + Constants.WIKI_HOME + "hessian")
public class HSFHessianCommand extends AnnotatedCommand {
    private static final Logger logger = LoggerFactory.getLogger(HSFHessianCommand.class);
    private String classPattern;
    @Argument(argName = "class-pattern", index = 0)
    @Description("Class name pattern, use either '.' or '/' as separator")
    public void setClassPattern(String classPattern) {
        this.classPattern = classPattern;
    }
    @Override
    public void process(final CommandProcess process) {
        RowAffect affect = new RowAffect();
        Instrumentation inst = process.session().getInstrumentation();
        String cp = "com.taobao.hsf.com.caucho.hessian.io.ContextSerializerFactory";
        boolean isRegEx = false;
        String hashCode = null;
        List<Class<?>> matchedClasses = new ArrayList<Class<?>>(SearchUtils.searchClass(inst, cp, isRegEx, hashCode));
        Class contextSerializerFactoryCls = matchedClasses.get(0);
        logger.info(contextSerializerFactoryCls + ",classLoader is " + contextSerializerFactoryCls.getClassLoader());
        matchedClasses = new ArrayList<Class<?>>(SearchUtils.searchClass(inst, classPattern, isRegEx, hashCode));
        Class ccvcCls = matchedClasses.get(0);
        ClassLoader ccvcCll = ccvcCls.getClassLoader();
        logger.info(ccvcCls + ",classLoader is " + ccvcCll);
        Object contextSerializserFactory = null;
        try {
            contextSerializserFactory = MethodUtils.invokeStaticMethod(contextSerializerFactoryCls,"create",ccvcCll);
            Object serializer = MethodUtils.invokeMethod(contextSerializserFactory,"getCustomSerializer",ccvcCls);
            logger.info("=========== serializer " + serializer);
        }catch (Exception e){
            logger.error("ContextSerializserFactory.getCustomSerializer",e);
        }
        Class<?> serClass = null;
        String clsName = ccvcCls.getName() + "HessianSerializer";
        try{
            serClass = Class.forName(clsName, false, ccvcCll);
        }catch (ClassNotFoundException e){
            logger.error( "1_" + clsName,e);
        } catch (NullPointerException e){
            logger.error("1_" + clsName,e);
        } catch (Exception e){
            logger.error("1_" + clsName,e);
        }
        if(serClass != null){
            try{
                Object ser = serClass.newInstance();
                logger.info( clsName + " instance is " + ser);
            }catch (Exception e){
                logger.error("newInstance error",e);
            }
        }
        affect.rCnt(matchedClasses.size());
        process.appendResult(new RowAffectModel(affect));
        process.end();
    }
    @Override
    public void complete(Completion completion) {
        if (!CompletionUtils.completeClassName(completion)) {
            super.complete(completion);
        }
    }
}