问题描述：
服务A依赖服务B的dubbo接口yyyMethod，其中传参XxxRequest中有个枚举类型APP，有时服务A调用yyyMethod后的代码会出现异常（非必现）。
@Data
public class XxxRequest implements Serializable {
private APP app;
.....
}
@Data
@Builder
public class XxxResponse implements Serializable {
private String code;
private String msg;
private Map<String, Object> ext;
private Boolean result;
}
@Override
public XxxResponse yyyMethod(XxxRequest request) {
if (request == null) {
return XxxResponse.builder().build();
}
boolean result = ....;
return XxxResponse.builder()
.code("8000")
.result(result)
.build();
}
ServiceA中的调用代码：
Transaction transaction = Cat.newTransaction("aaaa", "bbb");
try{
XxxRequest request = new XxxRequest();
request.setApp(APP.xxx);
....
response = serviceB.yyyMethod(request);
if(response != null && !response.getResult()){
......
}
}catch (Exception e) {
transaction.setStatus(e);
log.warn("xxxxx fail! errorMsg:{}", e.getMessage());
} finally {
transaction.complete();
}
2. 排查过程及猜想
因为ServiceA中的代码调用中的log.warn日志中没有带出异常e的堆栈，所以给问题排查带来一定难度。从日志中看：xxxxx fail! errorMsg:null。也无法确定异常的类型，然后去Cat碰运气上找对应transaction的exception类型，发现是一个java.lang.NullPointerException。
transaction.setStatus(e)会将异常的类型带上，代码如下：
public void setStatus(Throwable e) {
this.status = e.getClass().getName();
this.statusCode = -1;
}
由上步骤能确定异常类型为NullPointerException，但是因为没有堆栈，所以暂时怀疑是XxxResponse中的result的大Boolean是个null，所以才出现的NPE。
于是去yyyMethod方法中去查找result可能返回空的逻辑，也就只能定位到request==null时，才会返回result=null的XxxResponse了，但是ServiceA中的代码调用中request是不为null的，所以有点困惑。苦想无果，暂时搁置。
第二天注意到了XxxRequest中的枚举值，之前也看过Dubbo文档中说过的枚举值的最佳实践。但是也没说调用方传入服务端不识别的枚举值时，会出现什么后果。显示去检查ServiceA和ServiceB中的APP所在包的版本，发现不一致，ServiceA的版本领先于ServiceB，所以存在枚举值不一致的情况。于是开始写Demo去实验：调用方传入服务端不识别的枚举值时的标签。
Demo验证及Dubbo源码debug分析：
demo验证：
-
本地将ServiceB中的APP对应jar包版本指定为低版本，启动是增加参数：dubbo.provider.version=ZJX 防止测试环境流量访问。
-
demo测试方法：
参数app传一个ServiceB没有：
public class ServiceBTest extends BaseDubboServiceTest<ServiceB> {
@Test
@AssignEnv(value = Env.TEST, version="ZJX")
public void testYyyMethod() {
XxxRequest request = new XxxRequest();
request.setApp(APP.xxxx);
....
System.out.println(getService().yyyMethod(request));
}
}
- 测试结果：
yyyMethod中拿到的request是一个null, 结果返回了一个result为null的XxxResponse实例。
Dubbo源码debug分析：
以下为dubbo 2.7代码为例，直接跳到解析参数的地方：org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation.decode(Channel channel, InputStream input)
....
args = new Object[pts.length];
for (int i = 0; i < args.length; i++) {
try {
args[i] = in.readObject(pts[i]);
} catch (Exception e) {
if (log.isWarnEnabled()) {
log.warn("Decode argument failed: " + e.getMessage(), e);
}
}
}
....
org.apache.dubbo.common.serialize.Serialization上默认使用的是hessian2，也就是说请求的时候，序列化使用的是hessian2，那么反序列化也是用的hessian2。对应：org.apache.dubbo.common.serialize.hessian2.Hessian2Serialization
package org.apache.dubbo.common.serialize;
@SPI("hessian2")
public interface Serialization {
.....
}
大致链路：Hessian2Serialization->Hessian2ObjectInput->Hessian2Input->SerializerFactory.getDeserializer(Class).readObject(AbstractHessianInput)
SerializerFactory中对自定义Class使用的是默认的反序列化类：JavaDeserializer
protected Deserializer getDefaultDeserializer(Class cl) {
return new JavaDeserializer(cl);
}
JavaDeserializer中大致分两步：
- 实例化对象
@Override
public Object readObject(AbstractHessianInput in, String[] fieldNames)
throws IOException {
try {
Object obj = instantiate();
return readObject(in, obj, fieldNames);
} catch (IOException e) {
throw e;
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new IOExceptionWrapper(_type.getName() + ":" + e.getMessage(), e);
}
}
- 反序列化属性值并注入对象
public Object readObject(AbstractHessianInput in,
Object obj,
String[] fieldNames)
throws IOException {
try {
int ref = in.addRef(obj);
for (int i = 0; i < fieldNames.length; i++) {
String name = fieldNames[i];
FieldDeserializer deser = (FieldDeserializer) _fieldMap.get(name);
if (deser != null)
deser.deserialize(in, obj);
else
in.readObject();
}
Object resolve = resolve(obj);
if (obj != resolve)
in.setRef(ref, resolve);
return resolve;
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new IOExceptionWrapper(obj.getClass().getName() + ":" + e, e);
}
}
枚举类型对应的反序列化类是：com.alibaba.com.caucho.hessian.io.EnumDeserializer. 大致逻辑是找到对应枚举类，调用其valueOf(Class, String) 方法去获取对应的枚举值。
/**
* Deserializing an enum valued object
*/
public class EnumDeserializer extends AbstractDeserializer {
private Class _enumType;
private Method _valueOf;
public EnumDeserializer(Class cl) {
// hessian/33b[34], hessian/3bb[78]
if (cl.isEnum())
_enumType = cl;
else if (cl.getSuperclass().isEnum())
_enumType = cl.getSuperclass();
else
throw new RuntimeException("Class " + cl.getName() + " is not an enum");
try {
_valueOf = _enumType.getMethod("valueOf",
new Class[]{Class.class, String.class});
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public Class getType() {
return _enumType;
}
@Override
public Object readMap(AbstractHessianInput in)
throws IOException {
String name = null;
while (!in.isEnd()) {
String key = in.readString();
if (key.equals("name"))
name = in.readString();
else
in.readObject();
}
in.readMapEnd();
Object obj = create(name);
in.addRef(obj);
return obj;
}
@Override
public Object readObject(AbstractHessianInput in, String[] fieldNames)
throws IOException {
String name = null;
for (int i = 0; i < fieldNames.length; i++) {
if ("name".equals(fieldNames[i]))
name = in.readString();
else
in.readObject();
}
Object obj = create(name);
in.addRef(obj);
return obj;
}
private Object create(String name)
throws IOException {
if (name == null)
throw new IOException(_enumType.getName() + " expects name.");
try {
return _valueOf.invoke(null, _enumType, name);
} catch (Exception e) {
throw new IOExceptionWrapper(e);
}
}
}
Enum.valueOf逻辑：
public static <T extends Enum<T>> T valueOf(Class<T> enumType,
String name) {
T result = enumType.enumConstantDirectory().get(name);
if (result != null)
return result;
if (name == null)
throw new NullPointerException("Name is null");
throw new IllegalArgumentException(
"No enum constant " + enumType.getCanonicalName() + "." + name);
}
所以当枚举值是我当前枚举不存在的值时，valueOf方法会抛异常IllegalArgumentException。EnumDeserializer中会抛出IOExceptionWrapper, 一直往上抛到DecodeableRpcInvocation.decode中对于参数处理的部分（下图）：可以看出参数反序列化失败的异常被catch住后忽略了，造成的结果就是整个XxxRequest参数值为null了。
....
args = new Object[pts.length];
for (int i = 0; i < args.length; i++) {
try {
args[i] = in.readObject(pts[i]);
} catch (Exception e) {
if (log.isWarnEnabled()) {
log.warn("Decode argument failed: " + e.getMessage(), e);
}
}
}
....
结论：
- 异常堆栈在日志中一定要带出来，不然无法定位到异常发生的具体行，就有点无头苍蝇的感觉。
- 参数为null的处理逻辑，要么就按失败处理，返回指定错误码；要么就不处理，等报NPE，也方便及时发现问题。
- 枚举的使用最佳实践参考官方：最佳实践。其中第二点说明了对于可变的枚举值，不建议使用枚举。在不识别的枚举值反序列化时，会出现异常，当该参数直接是方法的参数时，那么服务端获取到的该参数值为null；当枚举是自定义类中的属性，那么服务端获取到的该自定义类参数的值将会是null.
网友评论