写点什么

源码分析 Dubbo 泛化调用与泛化实现原理

  • 2021 年 11 月 12 日
  • 本文字数:3957 字

    阅读完需:约 13 分钟

if (ProtocolUtils.isBeanGenericSerialization(generic)) {


if (value == null) {


return new RpcResult(value);


} else if (value instanceof JavaBeanDescriptor) {


return new RpcResult(JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) value));


} else {


throw new RpcException(


"The type of result value is " +


value.getClass().getName() +


" other than " +


JavaBeanDescriptor.class.getName() +


", and the result is " +


value);


}


} else {


return new RpcResult(PojoUtils.realize(value, method.getReturnType(), method.getGenericReturnType()));


}


} catch (NoSuchMethodException e) {


throw new RpcException(e.getMessage(), e);


}


} else if (result.getException() instanceof GenericException) {


GenericException exception = (GenericException) result.getException();


try {


String className = exception.getExceptionClass();


Class<?> clazz = ReflectUtils.forName(className);


Throwable targetException = null;


Throwable lastException = null;


tr


【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开:qq.cn.hn/FTf 免费领取
复制代码


y {


targetException = (Throwable) clazz.newInstance();


} catch (Throwable e) {


lastException = e;


for (Constructor<?> constructor : clazz.getConstructors()) {


try {


targetException = (Throwable) constructor.newInstance(new Object[constructor.getParameterTypes().length]);


break;


} catch (Throwable e1) {


lastException = e1;


}


}


}


if (targetException != null) {


try {


Field field = Throwable.class.getDeclaredField("detailMessage");


if (!field.isAccessible()) {


field.setAccessible(true);


}


field.set(targetException, exception.getExceptionMessage());


} catch (Throwable e) {


logger.warn(e.getMessage(), e);


}


result = new RpcResult(targetException);


} else if (lastException != null) {


throw lastException;


}


} catch (Throwable e) {


throw new RpcException("Can not deserialize exception " + exception.getExceptionClass() + ", message: " + exception.getExceptionMessage(), e);


}


}


return result;


}


if (invocation.getMethodName().equals(Constants.$INVOKE) // @2


&& invocation.getArguments() != null


&& invocation.getArguments().length == 3


&& ProtocolUtils.isGeneric(generic)) {


Object[] args = (Object[]) invocation.getArguments()[2];


if (ProtocolUtils.isJavaGenericSerialization(generic)) {


for (Object arg : args) {


if (!(byte[].class == arg.getClass())) {


error(byte[].class.getName(), arg.getClass().getName());


}


}


} else if (ProtocolUtils.isBeanGenericSerialization(generic)) {


for (Object arg : args) {


if (!(arg instanceof JavaBeanDescriptor)) {


error(JavaBeanDescriptor.class.getName(), arg.getClass().getName());


}


}


}


((RpcInvocation) invocation).setAttachment(


Constants.GENERIC_KEY, invoker.getUrl().getParameter(Constants.GENERIC_KEY));


}


return invoker.invoke(invocation);


}


代码 @1:该分支是泛化实现,如果是泛化实现,则根据 generic 的值进行序列化,然后调用invoke方法,因为服务端实现为泛化实现,所有的服务提供者实现GenericeServer#invoker 方法,其实现方式就是将 Bean 转换成 Map。这些细节将在服务端 GenericFilter 序列中详细讲解。


代码 @2:泛化引用,调用方是直接通过 GenericService#$invoke 方法进行调用,以此来区分是泛化调用还是泛化引用,那不经要问,为什么 invoker.getUrl().getParameter(Constants.GENERIC_KEY)中获取的 generic 参数到底是< dubbo:service/>中配置的还是< dubbo:reference/>中配置的呢?其实不难理解:


  1. dubbo:servcie 未配置而 dubbo:reference 配置了,则代表的是消费端的,必然是泛化引用。

  2. dubbo:servcie 配置而 dubbo:reference 未配置了,则代表的是服务端的,必然是泛化实现。

  3. 如果两者都配置了,generic 以消费端为主。消费端参数与服务端参数的合并在服务发现时,注册中心首先会将服务提供者的 URL 通知消费端,然后消费端会使用当前的配置与服务提供者 URL 中的配置进行合并,如遇到相同参数,则消费端覆盖服务端。


注:这里我就不深入去探讨其实现细节,因为这部分在下文源码分析 GenericFilter 时会详细介绍 Map 与 Bean 转换的细节,包含是否序列化,之所以这里没有细说,主要是因为我先看的是 GenericFilter。


4、源码分析泛化引用 GenericFilter(服务提供者)


@Activate(group = Constants.PROVIDER, order = -20000)


public class GenericFilter implements Filter {


@Override


public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {


if (inv.getMethodName().equals(Constants.$INVOKE)


&& inv.getArguments() != null


&& inv.getArguments().length == 3


&& !ProtocolUtils.isGeneric(invoker.getUrl().getParameter(Constants.GENERIC_KEY))) { // @1


String name = ((String) inv.getArguments()[0]).trim();


String[] types = (String[]) inv.getArguments()[1];


Object[] args = (Object[]) inv.getArguments()[2];


try {


Method method = ReflectUtils.findMethodByMethodSignature(invoker.getInterface(), name, types); // @2


Class<?>[] params = method.getParameterTypes();


if (args == null) {


args = new Object[params.length];


}


String generic = inv.getAttachment(Constants.GENERIC_KEY);


if (StringUtils.isEmpty(generic)


|| ProtocolUtils.isDefaultGenericSerialization(generic)) { // @3


args = PojoUtils.realize(args, params, method.getGenericParameterTypes());


} else if (ProtocolUtils.isJavaGenericSerialization(generic)) { // @4


for (int i = 0; i < args.length; i++) {


if (byte[].class == args[i].getClass()) {


try {


UnsafeByteArrayInputStream is = new UnsafeByteArrayInputStream((byte[]) args[i]);


args[i] = ExtensionLoader.getExtensionLoader(Serialization.class)


.getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)


.deserialize(null, is).readObject();


} catch (Exception e) {


throw new RpcException("Deserialize argument [" + (i + 1) + "] failed.", e);


}


} else {


throw new RpcException(


"Generic serialization [" +


Constants.GENERIC_SERIALIZATION_NATIVE_JAVA +


"] only support message type " +


byte[].class +


" and your message type is " +


args[i].getClass());


}


}


} else if (ProtocolUtils.isBeanGenericSerialization(generic)) { // @5


for (int i = 0; i < args.length; i++) {


if (args[i] instanceof JavaBeanDescriptor) {


args[i] = JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) args[i]);


} else {


throw new RpcException(


"Generic serialization [" +


Constants.GENERIC_SERIALIZATION_BEAN +


"] only support message type " +


JavaBeanDescriptor.class.getName() +


" and your message type is " +


args[i].getClass().getName());


}


}


}


Result result = invoker.invoke(new RpcInvocation(method, args, inv.getAttachments())); // @6


if (result.hasException()


&& !(result.getException() instanceof GenericException)) {


return new RpcResult(new GenericException(result.getException()));


}


if (ProtocolUtils.isJavaGenericSerialization(generic)) { // @7


try {


UnsafeByteArrayOutputStream os = new UnsafeByteArrayOutputStream(512);


ExtensionLoader.getExtensionLoader(Serialization.class)


.getExtension(Constants.GENERIC_SERIALIZATION_NATIVE_JAVA)


.serialize(null, os).writeObject(result.getValue());


return new RpcResult(os.toByteArray());


} catch (IOException e) {


throw new RpcException("Serialize result failed.", e);


}


} else if (ProtocolUtils.isBeanGenericSerialization(generic)) {


return new RpcResult(JavaBeanSerializeUtil.serialize(result.getValue(), JavaBeanAccessor.METHOD));


} else {


return new RpcResult(PojoUtils.generalize(result.getValue()));


}


} catch (NoSuchMethodException e) {


throw new RpcException(e.getMessage(), e);


} catch (ClassNotFoundException e) {


throw new RpcException(e.getMessage(), e);


}


}


return invoker.invoke(inv);


}


}


代码 @1:如果方法名为 $invoker,并且只有 3 个参数,并且服务端实现为非返回实现,则认为本次服务调用时客户端泛化引用服务端,客户端的泛化调用,需要将请求参数反序列化为该接口真实的 pojo 对象。


代码 @2:根据接口名(API 类)、方法名、方法参数类型列表,根据反射机制获取对应的方法。


代码 @3:处理普通的泛化引用调用,即处理<dubbo:referecnce generic=“true” …/>,只需要将参数列表 Object[]反序列化为 pojo 即可,具体的反序列化为 PojoUtils#realize,其实现原理如下:


在 JAVA 的世界中,pojo 通常用 map 来表示,也就是一个 Map 可以用来表示一个对象的值,那从一个 Map 如果序列化一个对象呢?其关键的要素是要在 Map 中保留该对象的类路径名。例如现在有这样一个对象:


public class Student {


private int id;


private String name;

评论

发布
暂无评论
源码分析Dubbo 泛化调用与泛化实现原理