2. 程式人生 > >原始碼分析Dubbo 泛化呼叫與泛化實現原理

原始碼分析Dubbo 泛化呼叫與泛化實現原理

阿新 • • 發佈：2018-12-13

   本文將重點分析Dubbo的兩個重要特性：泛化呼叫與泛化實現。
   1、泛化引用：
在這裡插入圖片描述
   通常是服務呼叫方沒有引入API包，也就不包含介面中的實體類，故服務呼叫方只能提供Map形式的資料，由服務提供者根據Map轉化成對應的實體。
   2、泛化實現
在這裡插入圖片描述
   泛化實現，是指服務提供者未引入API包，也就不包含介面用於傳輸資料的實體類，故客戶端發起呼叫前，需要將mode轉化為Map。
從上面分析，其實所謂的泛化本質上就是Map與Bean的轉換。

   3、原始碼分析客戶端用於泛化呼叫的過濾器GenericImplFilter

public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        String generic = invoker.getUrl().getParameter(Constants.GENERIC_KEY);
        if (ProtocolUtils.isGeneric(generic)                                                                                  // @1
                && !Constants.$INVOKE.equals(invocation.getMethodName())
                && invocation instanceof RpcInvocation) {
            RpcInvocation invocation2 = (RpcInvocation) invocation;
            String methodName = invocation2.getMethodName();
            Class<?>[] parameterTypes = invocation2.getParameterTypes();
            Object[] arguments = invocation2.getArguments();

            String[] types = new String[parameterTypes.length];
            for (int i = 0; i < parameterTypes.length; i++) {
                types[i] = ReflectUtils.getName(parameterTypes[i]);
            }

            Object[] args;
            if (ProtocolUtils.isBeanGenericSerialization(generic)) {
                args = new Object[arguments.length];
                for (int i = 0; i < arguments.length; i++) {
                    args[i] = JavaBeanSerializeUtil.serialize(arguments[i], JavaBeanAccessor.METHOD);
                }
            } else {
                args = PojoUtils.generalize(arguments);
            }

            invocation2.setMethodName(Constants.$INVOKE);
            invocation2.setParameterTypes(GENERIC_PARAMETER_TYPES);
            invocation2.setArguments(new Object[]{methodName, types, args});
            Result result = invoker.invoke(invocation2);

            if (!result.hasException()) {
                Object value = result.getValue();
                try {
                    Method method = invoker.getInterface().getMethod(methodName, parameterTypes);
                    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;
                    try {
                        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;
	private Team team;
	//省略get set方法
}
public class Team {
	private int id;
	private String name;
	// 省略其他屬性與set get方法
}
用Map表示Student為：
{
	“class”:"somepackeage.Student",
	"id":1,
	"name":"dingw",
	"team":
	{
		"class" : "somepackage.Team",
		"id":2,
		"name":"t"
	}
}

   也就是通過class來標識該Map需要反序列化的pojo型別。
   程式碼@4：處理< dubbo:reference generic=“nativejava” /> 啟用泛化引用，並使用nativejava序列化引數，在服務端這邊通過nativejava反序列化引數成pojo物件。
   程式碼@5：處理< dubbo:reference generic=“bean” /> 啟用泛化引用，並使用javabean序列化引數，在服務端這邊通過javabean反序列化引數成pojo物件。
   程式碼@6：序列化API方法中宣告的型別，構建new RpcInvocation(method, args, inv.getAttachments())呼叫環境，繼續呼叫後續過濾器。
   程式碼@7：處理執行結果，如果是nativejava或bean，則需要對返回結果序列化，如果是generic=true，則使用PojoUtils.generalize序列化，也即將pojo序列化為Map。
   泛化呼叫與泛化引用，就介紹到這裡了。

相關推薦

原始碼分析Dubbo非同步呼叫與事件回撥機制

   本文將詳細分析Dubbo服務非同步呼叫與事件回撥機制。    1、非同步呼叫與事件回撥機制    1.1 非同步回撥    1.2 事件回撥    2、原始碼分析非同步呼叫與事件回撥機制    在Dubbo中，引入特定的過

原始碼分析Dubbo 泛化呼叫與泛化實現原理

   本文將重點分析Dubbo的兩個重要特性：泛化呼叫與泛化實現。    1、泛化引用：    通常是服務呼叫方沒有引入API包，也就不包含介面中的實體類，故服務呼叫方只能提供Map形式的資料，由服務提供者根據Map轉化成對應的實體。    2、泛化實現  

深入原始碼分析Java執行緒池的實現原理

程式的執行，其本質上，是對系統資源（CPU、記憶體、磁碟、網路等等）的使用。如何高效的使用這些資源是我們程式設計優化演進的一個方向。今天說的執行緒池就是一種對CPU利用的優化手段。 網上有不少介紹如何使用執行緒池的文章，那我想說點什麼呢？我希望通過學習執行緒池原理，明白所有

JAVA中的集合原始碼分析一：ArrayList的內部實現原理

作為以java為語言開發的android開發者，集合幾乎天天都要打交道，無論是使用頻率最高的ArrayList還是HashSet，都頻繁的出現在平時的工作中。但是其中的原理之前卻一直沒深入探究，接下來記錄一下這次自己學習ArrayList原始碼的過程。 一.構造方法：

Android LruCache原始碼分析，圖片快取演算法的實現原理

今日科技快訊昨日，記者從中國聯通處獨家獲悉，聯通計劃在北京、天津、上海、深圳、杭州、南京、雄安7

dubbo原始碼分析-RPC遠端呼叫模組與Remoting通訊模組協作細節

閱讀需要技能： 1.設計模式：理解代理模式。JDK動態代理類的使用。 2.設計模式：理解裝飾模式。 3.Netty網路通訊程式設計,server,handler,channel 4.瞭解Dubbo基本原理，Dubbo模組各層分包關係

RPC框架（八）dubbo原始碼分析--dubbo呼叫過程分析

一、概述 消費端呼叫遠端服務介面時，使用上和呼叫普通的java介面是沒有任何區別，但是服務消費者和提供者是跨JVM和主機的，客戶端如何封裝請求讓服務端理解請求並且解析服務端返回的介面呼叫結果，服務端如何解析客戶端的請求並且向客戶端返回呼叫結果，這些框

dubbo原始碼分析22 -- consumer 傳送與接收原理

在前面的文章中,我們分析了 dubbo 從 provider 進行服務暴露,然後把服務資訊註冊到註冊中心上面解耦 consumer 與 provider 的呼叫。consumer 通過 javassist 建立代理物件引用遠端服務。當通過代理物件呼叫遠端服務的時候，講到進行真

dubbo原始碼分析23 -- provider 接收與傳送原理

在前面一篇部落格中分享了 dubbo 在網路通訊當中的 consumer 的傳送以及接收原理。通過叢集容錯最終選擇一個合適的 Invoke 通過 netty 直聯呼叫 provider 的服務。眾所周知， netty 是基於 Java Nio 的 Reactor 模型的非同步

tomcat 9.0.11 原始碼分析--總結startup.sh與catalina.sh

startup.sh與catalina.sh只是啟動指令碼，通過環境變數與指令碼所在目錄確定java的啟動引數來正確啟動tomcat, 從引數可以找到啟動類是org.apache.catalina.startup.Bootstrap裡的main方法 指令碼中常用判斷 if [ -z

原始碼分析SharePreferences的apply與commit的區別

apply與commit有什麼區別 還是從原始碼分析來說明問題： 接上圖示記B1處，看下： 所以這個handler傳送訊息後，handleMessage會被呼叫看下： 上圖提到的Runnable物件是哪個呢？？就是enqueueDiskWrite方法裡的

原始碼分析Apache Shiro 加密與登入驗證

前言 最近用到Shiro安全框架，做加密驗證的時候遇到一些問題，對Shiro內部登入驗證流程有些疑惑，網上的多數Shiro的環境搭建只是簡單的明文密碼匹配，甚至有些文章的註釋也不盡正確。在這裡記錄下通過分析原始碼的整理。 大綱 使用Shiro提供的類進行密碼加密

分散式事務中介軟體 TCC-Transaction 原始碼分析 —— Dubbo 支援

1. 概述 本文分享 Dubbo 支援。 TCC-Transaction 通過 Dubbo 隱式傳參的功能，避免自己對業務程式碼的入侵。可能有同學不太理解為什麼說 TCC-Transaction 對業務程式碼有一定的入侵性，一起來看個程式碼例子： 程式碼來自 t

dubbo基於呼叫攔截擴充套件實現分散式呼叫追蹤

      在基於dubbo的分散式應用叢集中，除錯會變得比較麻煩，不知道一個請求會被髮送到哪一臺機器上。我們可以通過dubbo的SPI擴充套件中的呼叫攔截擴充套件，來解決這個問題。       dubbo的呼叫攔截擴充套件可以對服務提供方和消費方的呼叫進行攔截，然後加

原始碼分析Dubbo服務提供者、服務消費者併發度控制機制

   本文將詳細分析< dubbo:service executes=”“/>與< dubbo:reference actives = “”/>的實現機制，深入探討Dubbo自身的保護機制。 1、原始碼分析ExecuteLimitFil

雲客Drupal8原始碼分析之臨時儲存與訊息服務

前言：臨時儲存與訊息服務之間並沒有什麼直接關聯，由於她們都是系統基礎元件，內容也比較簡單，為後續主題做準備，所以放在一起講解。 臨時儲存概述： 臨時儲存用來儲存一些臨時性的資料，超期後會被刪除，比如節點在儲存前的預覽資料，她和快取不一樣，她是臨時性的、不能被重建的資料，依據

RabbitMQ客戶端原始碼分析(五)之ConsumerWorkSerivce與WorkPool

RabbitMQ-java-client版本 com.rabbitmq:amqp-client:4.3.0 RabbitMQ版本宣告: 3.6.15 WorkPool WorkPool可以認

RabbitMQ客戶端原始碼分析(七)之Channel與ChannelManager

RabbitMQ-java-client版本 com.rabbitmq:amqp-client:4.3.0 RabbitMQ版本宣告: 3.6.15 Channel uml圖 tran

spring事物--04原始碼分析-事務處理攔截器的實現分析

事務處理攔截器的實現分析 通過上面的分析，很明確spring在事務方面aop是怎麼玩的了。那麼真正要處理事務是ProxyFactory.getObject() 方法返回的代理物件，通過呼叫代理物件的方法時，攔截器有一個invoker() 方法會被回撥（aop的玩法）。

記一次 JVM 原始碼分析(3.記憶體管理與GC)

簡介 miniJVM 的記憶體管理的實現較為簡單 記憶體分配使用了開源的 ltalloc 庫 GC就是經典的 Mark-Sweep GC 物件分配 物件分配要關注的就兩個過程 New 一個 Java 物件的過程 記憶體塊在堆上分配的過程 物件在 JVM