| <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Apache Dubbo – Upgrade Compatibility</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/</link><description>Recent content in Upgrade Compatibility on Apache Dubbo</description><generator>Hugo -- gohugo.io</generator><language>en</language><atom:link href="https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/index.xml" rel="self" type="application/rss+xml"/><item><title>Docs3-V2: 2.x to 3.x Operation Guide</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/2.x-to-3.x-compatibility-guide/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/2.x-to-3.x-compatibility-guide/</guid><description> |
| <h2 id="benefits-of-upgrading-to-dubbo-3x">Benefits of upgrading to Dubbo 3.X</h2> |
| <p>Dubbo3 still maintains the classic architecture of 2.x. Its main responsibility is to solve the communication between microservice processes, and to better manage and control microservice clusters through rich service governance (such as address discovery, traffic management, etc.); The upgrade of the framework is comprehensive, reflected in almost every aspect of the core Dubbo features, through the upgrade to achieve a comprehensive improvement in stability, performance, scalability, and ease of use.</p> |
| <p><img src="https://dubbo.apache.org/imgs/v3/concepts/architecture-1.png" alt="architecture-1"></p> |
| <ul> |
| <li>**Universal communication protocol. ** The new RPC protocol should abandon the private protocol stack, use the more general HTTP/2 protocol as the transport layer carrier, and use the standardized features of the HTTP protocol to solve the problems of traffic versatility and penetration, so that the protocol can better respond Scenarios such as front-end and back-end docking, gateway proxy, etc.; supports the Stream communication mode, which meets the demands of different business communication models and brings greater throughput to the cluster.</li> |
| <li>**For millions of cluster instances, the cluster is highly scalable. ** With the promotion of micro-service practices, the scale of micro-service cluster instances is also constantly expanding, which benefits from the characteristics of light-weight micro-services and easy horizontal expansion, but also brings a burden to the entire cluster capacity, especially It is some centralized service governance components; Dubbo3 needs to solve various resource bottlenecks caused by the expansion of instance scale, and realize truly unlimited horizontal expansion.</li> |
| <li>**Comprehensively embrace cloud native. **</li> |
| </ul> |
| <h2 id="dubbo-30-new-features">Dubbo 3.0 new features</h2> |
| <p>The new features provided by Dubbo 3.0 include:</p> |
| <ul> |
| <li>** New address discovery model (application-level service discovery). ** |
| <ul> |
| <li>See <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/service-discovery/service-discovery-samples/">Application-Level Service Discovery Migration Samples</a>.</li> |
| <li>See <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/service-discovery/migration-service-discovery/">Migration steps for application-level service discovery</a></li> |
| <li>See <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/service-discovery/service-discovery-rule/">Description of application-level service discovery address migration rules</a></li> |
| </ul> |
| </li> |
| <li>**The next generation of the HTTP/2-based Triple protocol. ** |
| <ul> |
| <li>See <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/migration-triple/">Triple Protocol Migration Steps</a></li> |
| <li>See <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/reference-manual/protocol/triple/guide/">Triple protocol usage</a></li> |
| <li>See <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/reference-manual/protocol/triple/overview/">Triple Protocol Design and Implementation</a>.</li> |
| </ul> |
| </li> |
| <li>**Unified routing rules. ** |
| <ul> |
| <li>See <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/advanced-features-and-usage/traffic/mesh-style/">Design and Implementation of Unified Routing Rules</a></li> |
| </ul> |
| </li> |
| </ul> |
| <h2 id="compatibility-check-before-upgrade">Compatibility check before upgrade</h2> |
| <p>In the process of cross-version upgrade, the existing risks are from big to small: directly modify Dubbo source code -&gt; expand based on Dubbo SPI extension points -&gt; use methods based on API or Spring.</p> |
| <h3 id="1-directly-modify-dubbo-source-code">1. Directly modify Dubbo source code</h3> |
| <p>For those who need to directly modify this part of Dubbo source code, the modifying party must judge whether it works normally in the higher version. For this non-standard behavior, Dubbo cannot guarantee its previous compatibility. In addition, the modification of Dubbo at runtime through javagent or asm is also within this scope. Most of these modifications can be detected by the scanning tools provided below.</p> |
| <h3 id="2-spi-extension">2. SPI extension</h3> |
| <h4 id="incompatibilities">Incompatibilities</h4> |
| <p>For SPI extensions, except that the two mechanisms of application-level service direction and EventDispatcher have been destructively modified in 3.x, most of the extensions provided in 2.7.x are also provided in 3.x. There are two areas to focus on in this section:</p> |
| <ul> |
| <li>Event bus: Due to the complexity of event management, the support of EventDispatcher and EventListener in Dubbo 3.x has been removed. If there is a use of the corresponding extension mechanism, please consider refactoring to an extension corresponding to the Dubbo function.</li> |
| <li>Application-level service discovery: The overall mechanism of application-level service discovery in Dubbo 2.7 has been completely refactored in Dubbo 3.x, and the performance and stability of functions have been greatly improved. Therefore, we recommend that you do not use the application-level service discovery mechanism in Dubbo 2.7. If there is a corresponding extension, you can re-verify the implementation based on the new code after upgrading to Dubbo 3.x (most APIs for application-level service discovery are forward Compatible).</li> |
| </ul> |
| <h4 id="optimization-items-optional">Optimization items (optional)</h4> |
| <p>In addition, Dubbo 3.x has optimized the working mechanism of some extension points, which can greatly improve the performance of the application.</p> |
| <ul> |
| <li> |
| <ol> |
| <li>Interceptor mechanism</li> |
| </ol> |
| </li> |
| </ul> |
| <p>Dubbo can intercept requests based on Filter interceptors. In Dubbo 2.7, it is supported to intercept the request after the routing address is selected. In Dubbo 3.x, a new ClusterFilter mechanism is abstracted, which can greatly reduce the memory usage, and has great benefits for ultra-large-scale clusters. |
| If you have some interceptors on the consumer side that are implemented based on the Filter mechanism, and if there is no logic that is strongly bound to the remote IP address, we recommend that you add the corresponding <code>org.apache.dubbo.rpc.Filter</code> SPI extension point Migrated to the new SPI extension point <code>org.apache.dubbo.rpc.cluster.filter.ClusterFilter</code>. The method definitions of the two interfaces are exactly the same.</p> |
| <ul> |
| <li> |
| <ol start="2"> |
| <li>Router -&gt; StateRouter</li> |
| </ol> |
| </li> |
| </ul> |
| <p>Dubbo provides Router, the ability to dynamically select and route, and most of the service governance capabilities are also implemented based on this Router extension point. In Dubbo 3.x, Dubbo abstracts a new StateRouter mechanism based on Router, which can greatly optimize address selection performance and memory usage. We will publish more about StateRouter in subsequent documents.</p> |
| <h3 id="3-api--spring-usage">3. API / Spring usage</h3> |
| <p>For the use based on API or Spring, Dubbo 3.x and 2.7.x are used in the same way. In Dubbo 3.x, some invalid configurations are strongly checked, and this part of the exception will directly report an error during the startup process. , please follow the prompts to modify.</p> |
| <h2 id="upgrade-process">Upgrade process</h2> |
| <h3 id="1-dependency-upgrade">1. Dependency upgrade</h3> |
| <p>If you use Nacos as the registration center, due to the support of Nacos features, you need to upgrade Nacos Server to 2.x before upgrading to Dubbo 3.x (refer to the document <a href="https://nacos.io/zh-cn/docs/v2/upgrading/2.0.0-upgrading.html">https://nacos.io/zh-cn/docs/v2 /upgrading/2.0.0-upgrading.html</a>), and then upgrade the Nacos Client of the application . No processing is required if using a Zookeeper registry. |
| If you are using Spring Cloud Alibaba Dubbo for access, please upgrade to xxx due to changes in some internal APIs of Dubbo.</p> |
| <p>Please upgrade to the latest version 3.1.3 for Dubbo dependencies. Dubbo and the corresponding springboot starter GAV are as follows.</p> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-xml" data-lang="xml"><span style="display:flex;"><span><span style="color:#268bd2">&lt;dependency&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;groupId&gt;</span>org.apache.dubbo<span style="color:#268bd2">&lt;/groupId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;artifactId&gt;</span>dubbo<span style="color:#268bd2">&lt;/artifactId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;version&gt;</span>3.1.3<span style="color:#268bd2">&lt;/version&gt;</span> |
| </span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;/dependency&gt;</span> |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;dependency&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;groupId&gt;</span>org.apache.dubbo<span style="color:#268bd2">&lt;/groupId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;artifactId&gt;</span>dubbo-spring-boot-starter<span style="color:#268bd2">&lt;/artifactId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;version&gt;</span>3.1.3<span style="color:#268bd2">&lt;/version&gt;</span> |
| </span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;/dependency&gt;</span> |
| </span></span></code></pre></div><h3 id="2-gray-scale-upgrade">2. Gray scale upgrade</h3> |
| <p>The Dubbo 3 upgrade has no special restrictions on the release process, and it can be released according to normal business. |
| Since Dubbo is undergoing changes and upgrades across major versions, please release as many batches as possible during the release, and at the same time increase the time interval between the first batch and the second batch of releases, and make sufficient observations. |
| During the publishing process, we recommend that you first upgrade the downstream of the application (that is, the service provider), and then proceed with subsequent publishing after verifying that the service is processed normally.</p> |
| <h3 id="3-upgrade-observation-indicators">3. Upgrade observation indicators</h3> |
| <p>During the release process, there are the following latitude indicators to judge whether there is a problem with the upgrade.</p> |
| <ul> |
| <li>CPU, memory usage of the machine</li> |
| <li>Interface request success rate</li> |
| <li>Interface Request RT</li> |
| <li>Log error message</li> |
| <li>Does the custom extension behave as expected</li> |
| </ul> |
| <h2 id="precautions">Precautions</h2> |
| <h3 id="1-application-level-service-discovery">1. Application-level service discovery</h3> |
| <p>Due to design problems in the application-level service discovery model of Dubbo 2.7, a large number of format changes have been made in Dubbo 3.x, so the application-level service discovery of 2.7.x and 3.x may not be able to subscribe to each other. sex. Although Dubbo will eliminate unrecognized instances, from the perspective of stability, if you enable the application-level service discovery feature in 2.7.x (not registered by default in 2.7.x), we recommend first Turn it off, and turn it on again after upgrading to 3.x.</p></description></item><item><title>Docs3-V2: Guide to Migrating Dubbo Protocol to Triple Protocol</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/migration-triple/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/migration-triple/</guid><description> |
| <h2 id="triple-introduction">Triple Introduction</h2> |
| <p>For the format and principle of the <code>Triple</code> protocol, please refer to <a href="https://dubbo.apache.org/zh-cn/docs/concepts/rpc-protocol/">RPC Communication Protocol</a></p> |
| <p>According to the goals of Triple design, the <code>Triple</code> protocol has the following advantages:</p> |
| <ul> |
| <li>Capable of cross-language interaction. Both the traditional multi-language and multi-SDK mode and the Mesh cross-language mode require a more general and scalable data transmission protocol.</li> |
| <li>Provide a more complete request model. In addition to supporting the traditional Request/Response model (Unary one-way communication), it also supports Stream (streaming communication) and Bidirectional (two-way communication).</li> |
| <li>Easy to expand, high penetration, including but not limited to Tracing / Monitoring and other support, should also be recognized by devices at all levels, gateway facilities, etc. can identify data packets, friendly to Service Mesh deployment, and reduce the difficulty of understanding for users.</li> |
| <li>Fully compatible with grpc, the client/server can communicate with the native grpc client.</li> |
| <li>Components in the existing grpc ecosystem can be reused to meet cross-language, cross-environment, and cross-platform intercommunication requirements in cloud-native scenarios.</li> |
| </ul> |
| <p>For Dubbo users currently using other protocols, the framework provides migration capabilities compatible with existing serialization methods. Without affecting existing online businesses, the cost of migrating protocols is almost zero.</p> |
| <p>Dubbo users who need to add new connection to Grpc service can directly use the Triple protocol to achieve the connection, and do not need to introduce the grpc client separately to complete it. Not only can the existing Dubbo ease of use be retained, but also the complexity of the program and the development and maintenance can be reduced. Cost, it can be connected to the existing ecology without additional adaptation and development.</p> |
| <p>For Dubbo users who need gateway access, the Triple protocol provides a more native way to make gateway development or use open source grpc gateway components easier. The gateway can choose not to parse the payload, which greatly improves the performance. When using the Dubbo protocol, the language-related serialization method is a big pain point for the gateway, and the traditional HTTP-to-Dubbo method is almost powerless for cross-language serialization. At the same time, since Triple&rsquo;s protocol metadata is stored in the request header, the gateway can easily implement customized requirements, such as routing and current limiting.</p> |
| <h2 id="dubbo2-protocol-migration-process">Dubbo2 protocol migration process</h2> |
| <p>Dubbo2 users use dubbo protocol + custom serialization, such as hessian2 to complete remote calls.</p> |
| <p>By default, Grpc only supports Protobuf serialization, and it cannot support multi-parameter and method overloading in the Java language.</p> |
| <p>At the beginning of Dubbo3, one goal was to be perfectly compatible with Dubbo2. Therefore, in order to ensure the smooth upgrade of Dubbo2, the Dubbo framework has done a lot of work to ensure that the upgrade is seamless. Currently, the default serialization is consistent with Dubbo2 as <code>hessian2</code>.</p> |
| <p>Therefore, if you decide to upgrade to the <code>Triple</code> protocol of Dubbo3, you only need to modify the protocol name in the configuration to <code>tri</code> (note: not triple).</p> |
| <p>Next we use a [project] (<a href="https://github.com/apache/dubbo-samples/tree/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/">https://github.com/apache/dubbo-samples/tree/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/</a> org/apache/dubbo/sample/tri/migration) as an example, how to upgrade safely step by step.</p> |
| <ol> |
| <li>Only use the <code>dubbo</code> protocol to start <code>provider</code> and <code>consumer</code>, and complete the call.</li> |
| <li>Use <code>dubbo</code> and <code>tri</code> protocols to start <code>provider</code>, use <code>dubbo</code> protocol to start <code>consumer</code>, and complete the call.</li> |
| <li>Start <code>provider</code> and <code>consumer</code> using only <code>tri</code> protocol, and complete the call.</li> |
| </ol> |
| <h3 id="define-the-service">Define the service</h3> |
| <ol> |
| <li>Define the interface</li> |
| </ol> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span><span style="color:#268bd2">public</span> <span style="color:#268bd2">interface</span> <span style="color:#268bd2">IWrapperGreeter</span> { |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#586e75">//...</span> |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#586e75">/** |
| </span></span></span><span style="display:flex;"><span><span style="color:#586e75"> * This is a normal interface, not serialized using pb |
| </span></span></span><span style="display:flex;"><span><span style="color:#586e75"> */</span> |
| </span></span><span style="display:flex;"><span> String <span style="color:#268bd2">sayHello</span>(String request); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><ol start="2"> |
| <li>The implementation class is as follows</li> |
| </ol> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span><span style="color:#268bd2">public</span> <span style="color:#268bd2">class</span> <span style="color:#268bd2">IGreeter2Impl</span> <span style="color:#268bd2">implements</span> IWrapperGreeter { |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> String <span style="color:#268bd2">sayHello</span>(String request) { |
| </span></span><span style="display:flex;"><span> <span style="color:#719e07">return</span> <span style="color:#2aa198">&#34;hello,&#34;</span> <span style="color:#719e07">+</span> request; |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><h3 id="only-use-dubbo-protocol">Only use dubbo protocol</h3> |
| <p>To ensure compatibility, we first upgrade some providers to the <code>dubbo3</code> version and use the <code>dubbo</code> protocol.</p> |
| <p>Start a [<code>Provider</code>] using the <code>dubbo</code> protocol (<a href="https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/org">https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/org</a> /apache/dubbo/sample/tri/migration/ApiMigrationDubboProvider.java) and <a href="https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/org/apache/dubbo/sample/tri/migration/ApiMigrationDubboConsumer.java"><code>Consumer</code></a>, complete the call, the output is as follows: |
| <img src="https://dubbo.apache.org/imgs/v3/migration/tri/dubbo3-tri-migration-dubbo-dubbo-result.png" alt="result"></p> |
| <h3 id="use-dubbo-and-triple-protocol-at-the-same-time">Use dubbo and triple protocol at the same time</h3> |
| <p>For the upgrade of online services, it is impossible to complete the provider and consumer upgrades at the same time. It needs to be operated step by step to ensure business stability. |
| In the second step, the provider provides a dual-protocol way to support dubbo + tri clients at the same time.</p> |
| <p>The structure is shown in the figure: |
| <img src="https://dubbo.apache.org/imgs/v3/migration/tri/migrate-dubbo-tri-strust.png" alt="trust"></p> |
| <blockquote> |
| <p>According to the recommended upgrade steps, the provider already supports the tri protocol, so the consumer of dubbo3 can directly use the tri protocol</p> |
| </blockquote> |
| <p>Start [<code>Provider</code>] using <code>dubbo</code> protocol and <code>triple</code> protocol (<a href="https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main">https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main</a> /java/org/apache/dubbo/sample/tri/migration/ApiMigrationBothProvider.java) and [<code>Consumer</code>](<a href="https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/">https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/</a> dubbo-samples-triple/src/main/java/org/apache/dubbo/sample/tri/migration/ApiMigrationBothConsumer.java), complete the call, the output is as follows:</p> |
| <p><img src="https://dubbo.apache.org/imgs/v3/migration/tri/dubbo3-tri-migration-both-dubbo-tri-result.png" alt="result"></p> |
| <h3 id="only-use-triple-protocol">Only use triple protocol</h3> |
| <p>When all consuemr are upgraded to a version that supports the <code>Triple</code> protocol, the provider can be switched to only use the <code>Triple</code> protocol to start</p> |
| <p>The structure is shown in the figure: |
| <img src="https://dubbo.apache.org/imgs/v3/migration/tri/migrate-only-tri-strust.png" alt="trust"></p> |
| <p>[Provider](<a href="https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/org/apache/dubbo/sample/tri/">https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/org/apache/dubbo/sample/tri/</a> migration/ApiMigrationTriProvider.java) |
| and [Consumer](<a href="https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/org/apache/dubbo/sample/tri">https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/src/main/java/org/apache/dubbo/sample/tri</a> /migration/ApiMigrationTriConsumer.java) to complete the call, the output is as follows:</p> |
| <p><img src="https://dubbo.apache.org/imgs/v3/migration/tri/dubbo3-tri-migration-tri-tri-result.png" alt="result"></p> |
| <h3 id="implementation-principle">Implementation principle</h3> |
| <p>Through the upgrade process described above, we can easily complete the upgrade by modifying the protocol type. How does the framework help us do this?</p> |
| <p>Through the introduction of the <code>Triple</code> protocol, we know that the data type of <code>Triple</code> in Dubbo3 is a <code>protobuf</code> object, so why non-<code>protobuf</code> java objects can also be transmitted normally.</p> |
| <p>Here Dubbo3 uses an ingenious design, first judge whether the parameter type is a <code>protobuf</code> object, if not. Use a <code>protobuf</code> object to wrap <code>request</code> and <code>response</code>, which shields the complexity brought by other serialization. Declare the serialization type inside the <code>wrapper</code> object to support serialization extensions.</p> |
| <p>The IDL of <code>protobuf</code> of wrapper is as follows:</p> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-proto" data-lang="proto"><span style="display:flex;"><span>syntax <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;proto3&#34;</span>; |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span><span style="color:#719e07">package</span> org<span style="color:#719e07">.</span>apache.dubbo.triple; |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span><span style="color:#268bd2">message</span> <span style="color:#268bd2">TripleRequestWrapper</span> { |
| </span></span><span style="display:flex;"><span> <span style="color:#586e75">//hessian4 |
| </span></span></span><span style="display:flex;"><span><span style="color:#586e75"></span> <span style="color:#586e75">// json |
| </span></span></span><span style="display:flex;"><span><span style="color:#586e75"></span> <span style="color:#dc322f">string</span> serializeType <span style="color:#719e07">=</span> <span style="color:#2aa198">1</span>; |
| </span></span><span style="display:flex;"><span> <span style="color:#719e07">repeated</span> <span style="color:#dc322f">bytes</span> args <span style="color:#719e07">=</span> <span style="color:#2aa198">2</span>; |
| </span></span><span style="display:flex;"><span> <span style="color:#719e07">repeated</span> <span style="color:#dc322f">string</span> argTypes <span style="color:#719e07">=</span> <span style="color:#2aa198">3</span>; |
| </span></span><span style="display:flex;"><span>} |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span><span style="color:#268bd2">message</span> <span style="color:#268bd2">TripleResponseWrapper</span> { |
| </span></span><span style="display:flex;"><span> <span style="color:#dc322f">string</span> serializeType <span style="color:#719e07">=</span> <span style="color:#2aa198">1</span>; |
| </span></span><span style="display:flex;"><span> <span style="color:#dc322f">bytes</span> data <span style="color:#719e07">=</span> <span style="color:#2aa198">2</span>; |
| </span></span><span style="display:flex;"><span> <span style="color:#dc322f">string</span> type <span style="color:#719e07">=</span> <span style="color:#2aa198">3</span>; |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><p>For requests, use <code>TripleRequestWrapper</code> for wrapping, and for responses, use <code>TripleResponseWrapper</code> for wrapping.</p> |
| <blockquote> |
| <p>For request parameters, you can see that args is modified by <code>repeated</code>, this is because multiple parameters of the java method need to be supported. Of course, serialization can only be one. The implementation of serialization follows the spi implemented by Dubbo2</p> |
| </blockquote> |
| <h2 id="multilingual-users-using-protobuf">Multilingual users (using Protobuf)</h2> |
| <blockquote> |
| <p>It is recommended that all new services use this method</p> |
| </blockquote> |
| <p>For Dubbo3 and Triple, the main recommendation is to use <code>protobuf</code> serialization, and use <code>IDL</code> defined by <code>proto</code> to generate related interface definitions. Using <code>IDL</code> as a common interface convention in multiple languages, coupled with the natural interoperability of <code>Triple</code> and <code>Grpc</code>, can easily achieve cross-language interaction, such as Go language.</p> |
| <p>Use the <code>dubbo-compiler</code> plug-in to compile the prepared <code>.proto</code> file and write the implementation class to complete the method call:</p> |
| <p><img src="https://dubbo.apache.org/imgs/v3/migration/tri/dubbo3-tri-migration-tri-tri-result.png" alt="result"></p> |
| <p>From the upgrade example above, we can know that the <code>Triple</code> protocol uses <code>protbuf</code> objects to be serialized for transmission, so there is no other logic for methods that are themselves <code>protobuf</code> objects.</p> |
| <p>The interface after compiling with the <code>protobuf</code> plugin is as follows:</p> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span><span style="color:#268bd2">public</span> <span style="color:#268bd2">interface</span> <span style="color:#268bd2">PbGreeter</span> { |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">static</span> <span style="color:#268bd2">final</span> String JAVA_SERVICE_NAME <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;org.apache.dubbo.sample.tri.PbGreeter&#34;</span>; |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">static</span> <span style="color:#268bd2">final</span> String SERVICE_NAME <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;org.apache.dubbo.sample.tri.PbGreeter&#34;</span>; |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">static</span> <span style="color:#268bd2">final</span> <span style="color:#dc322f">boolean</span> inited <span style="color:#719e07">=</span> PbGreeterDubbo.init(); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> org.apache.dubbo.sample.tri.GreeterReply <span style="color:#268bd2">greet</span>(org.apache.dubbo.sample.tri.GreeterRequest request); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#719e07">default</span> CompletableFuture<span style="color:#719e07">&lt;</span>org.apache.dubbo.sample.tri.GreeterReply<span style="color:#719e07">&gt;</span> <span style="color:#268bd2">greetAsync</span>(org.apache.dubbo.sample.tri.GreeterRequest request){ |
| </span></span><span style="display:flex;"><span> <span style="color:#719e07">return</span> CompletableFuture. <span style="color:#268bd2">supplyAsync</span>(() <span style="color:#719e07">-&gt;</span> greet(request)); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">greetServerStream</span>(org.apache.dubbo.sample.tri.GreeterRequest request, org.apache.dubbo.common.stream.StreamObserver<span style="color:#719e07">&lt;</span>org.apache.dubbo.sample.tri.GreeterReply<span style="color:#719e07">&gt;</span> responseObserver); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> org.apache.dubbo.common.stream.StreamObserver<span style="color:#719e07">&lt;</span>org.apache.dubbo.sample.tri.GreeterRequest<span style="color:#719e07">&gt;</span> <span style="color:#268bd2">greetStream</span>(org.apache.dubbo.common.stream.StreamObserver<span style="color:#719e07">&lt;</span>org.apache.dubbo.sample.tri.GreeterReply<span style="color:#719e07">&gt;</span> responseObserver); |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><h2 id="open-the-new-feature-of-triple---stream-stream">Open the new feature of Triple - Stream (stream)</h2> |
| <p>Stream is a new call type provided by Dubbo3. It is recommended to use stream in the following scenarios:</p> |
| <ul> |
| <li>The interface needs to send a large amount of data. These data cannot be placed in an RPC request or response, and need to be sent in batches. However, if the application layer cannot solve the order and performance problems in the traditional multiple RPC method, if the order needs to be guaranteed , it can only be sent serially</li> |
| <li>In streaming scenarios, data needs to be processed in the order they are sent, and the data itself has no definite boundary</li> |
| <li>In push scenarios, multiple messages are sent and processed in the context of the same call</li> |
| </ul> |
| <p>Stream is divided into the following three types:</p> |
| <ul> |
| <li>SERVER_STREAM (server stream) |
| <img src="https://dubbo.apache.org/imgs/v3/migration/tri/migrate-server-stream.png" alt="SERVER_STREAM"></li> |
| <li>CLIENT_STREAM (client stream) |
| <img src="https://dubbo.apache.org/imgs/v3/migration/tri/migrate-client-stream.png" alt="CLIENT_STREAM"></li> |
| <li>BIDIRECTIONAL_STREAM (bidirectional stream) |
| <img src="https://dubbo.apache.org/imgs/v3/migration/tri/migrate-bi-stream.png" alt="BIDIRECTIONAL_STREAM"></li> |
| </ul> |
| <blockquote> |
| <p>Due to the limitations of the <code>java</code> language, the implementation of BIDIRECTIONAL_STREAM and CLIENT_STREAM is the same.</p> |
| </blockquote> |
| <p>In Dubbo3, the stream interface is declared and used as <code>SteamObserver</code>, and users can use and implement this interface to send and handle stream data, exceptions, and end.</p> |
| <blockquote> |
| <p>For Dubbo2 users, they may be unfamiliar with StreamObserver, which is a stream type defined by Dubbo3. There is no Stream type in Dubbo2, so it has no impact on migration scenarios.</p> |
| </blockquote> |
| <p>Stream Semantic Guarantees</p> |
| <ul> |
| <li>Provide message boundaries, which can easily process messages separately</li> |
| <li>Strictly ordered, the order of the sender is consistent with the order of the receiver</li> |
| <li>Full duplex, no need to wait for sending</li> |
| <li>Support cancellation and timeout</li> |
| </ul> |
| <h3 id="non-pb-serialized-stream">Non-PB serialized stream</h3> |
| <ol> |
| <li>api</li> |
| </ol> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span><span style="color:#268bd2">public</span> <span style="color:#268bd2">interface</span> <span style="color:#268bd2">IWrapperGreeter</span> { |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span> <span style="color:#268bd2">sayHelloStream</span>(StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span> response); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">sayHelloServerStream</span>(String request, StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span> response); |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><blockquote> |
| <p>The method input parameters and return values of the Stream method are strictly agreed. In order to prevent problems caused by writing errors, the Dubbo3 framework side checks the parameters, and throws an exception if there is an error. |
| For <code>BIDIRECTIONAL_STREAM</code>, it should be noted that <code>StreamObserver</code> in the parameter is the response stream, and <code>StreamObserver</code> in the return parameter is the request stream.</p> |
| </blockquote> |
| <ol start="2"> |
| <li>Implementation class</li> |
| </ol> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span><span style="color:#268bd2">public</span> <span style="color:#268bd2">class</span> <span style="color:#268bd2">WrapGreeterImpl</span> <span style="color:#268bd2">implements</span> WrapGreeter { |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#586e75">//...</span> |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span> <span style="color:#268bd2">sayHelloStream</span>(StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span> response) { |
| </span></span><span style="display:flex;"><span> <span style="color:#719e07">return</span> <span style="color:#719e07">new</span> StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span>() { |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onNext</span>(String data) { |
| </span></span><span style="display:flex;"><span> System.out.println(data); |
| </span></span><span style="display:flex;"><span> response.onNext(<span style="color:#2aa198">&#34;hello,&#34;</span><span style="color:#719e07">+</span>data); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onError</span>(Throwable throwable) { |
| </span></span><span style="display:flex;"><span> throwable. <span style="color:#268bd2">printStackTrace</span>(); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onCompleted</span>() { |
| </span></span><span style="display:flex;"><span> System.out.println(<span style="color:#2aa198">&#34;onCompleted&#34;</span>); |
| </span></span><span style="display:flex;"><span> response.onCompleted(); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> }; |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">sayHelloServerStream</span>(String request, StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span> response) { |
| </span></span><span style="display:flex;"><span> <span style="color:#719e07">for</span> (<span style="color:#dc322f">int</span> i <span style="color:#719e07">=</span> 0; i <span style="color:#719e07">&lt;</span> 10; i<span style="color:#719e07">++</span>) { |
| </span></span><span style="display:flex;"><span> response.onNext(<span style="color:#2aa198">&#34;hello,&#34;</span> <span style="color:#719e07">+</span> request); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> response.onCompleted(); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><ol start="3"> |
| <li>Call method</li> |
| </ol> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span>delegate.sayHelloServerStream(<span style="color:#2aa198">&#34;server stream&#34;</span>, <span style="color:#719e07">new</span> StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span>() { |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onNext</span>(String data) { |
| </span></span><span style="display:flex;"><span> System.out.println(data); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onError</span>(Throwable throwable) { |
| </span></span><span style="display:flex;"><span> throwable. <span style="color:#268bd2">printStackTrace</span>(); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onCompleted</span>() { |
| </span></span><span style="display:flex;"><span> System.out.println(<span style="color:#2aa198">&#34;onCompleted&#34;</span>); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span>}); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span>StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span> request <span style="color:#719e07">=</span> delegate.sayHelloStream(<span style="color:#719e07">new</span> StreamObserver<span style="color:#719e07">&lt;</span>String<span style="color:#719e07">&gt;</span>() { |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onNext</span>(String data) { |
| </span></span><span style="display:flex;"><span> System.out.println(data); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onError</span>(Throwable throwable) { |
| </span></span><span style="display:flex;"><span> throwable. <span style="color:#268bd2">printStackTrace</span>(); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">@Override</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">public</span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">onCompleted</span>() { |
| </span></span><span style="display:flex;"><span> System.out.println(<span style="color:#2aa198">&#34;onCompleted&#34;</span>); |
| </span></span><span style="display:flex;"><span> } |
| </span></span><span style="display:flex;"><span>}); |
| </span></span><span style="display:flex;"><span><span style="color:#719e07">for</span> (<span style="color:#dc322f">int</span> i <span style="color:#719e07">=</span> 0; i <span style="color:#719e07">&lt;</span> n; i<span style="color:#719e07">++</span>) { |
| </span></span><span style="display:flex;"><span> request.onNext(<span style="color:#2aa198">&#34;stream request&#34;</span> <span style="color:#719e07">+</span> i); |
| </span></span><span style="display:flex;"><span>} |
| </span></span><span style="display:flex;"><span>request.onCompleted(); |
| </span></span></code></pre></div><h2 id="serialized-stream-using-protobuf">Serialized stream using Protobuf</h2> |
| <p>For the <code>Protobuf</code> serialization method, it is recommended to write <code>IDL</code> and use the <code>compiler</code> plugin to compile and generate. The generated code is roughly as follows:</p> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span><span style="color:#268bd2">public</span> <span style="color:#268bd2">interface</span> <span style="color:#268bd2">PbGreeter</span> { |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">static</span> <span style="color:#268bd2">final</span> String JAVA_SERVICE_NAME <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;org.apache.dubbo.sample.tri.PbGreeter&#34;</span>; |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">static</span> <span style="color:#268bd2">final</span> String SERVICE_NAME <span style="color:#719e07">=</span> <span style="color:#2aa198">&#34;org.apache.dubbo.sample.tri.PbGreeter&#34;</span>; |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">static</span> <span style="color:#268bd2">final</span> <span style="color:#dc322f">boolean</span> inited <span style="color:#719e07">=</span> PbGreeterDubbo.init(); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#586e75">//...</span> |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> <span style="color:#dc322f">void</span> <span style="color:#268bd2">greetServerStream</span>(org.apache.dubbo.sample.tri.GreeterRequest request, org.apache.dubbo.common.stream.StreamObserver<span style="color:#719e07">&lt;</span>org.apache.dubbo.sample.tri.GreeterReply<span style="color:#719e07">&gt;</span> responseObserver); |
| </span></span><span style="display:flex;"><span> |
| </span></span><span style="display:flex;"><span> org.apache.dubbo.common.stream.StreamObserver<span style="color:#719e07">&lt;</span>org.apache.dubbo.sample.tri.GreeterRequest<span style="color:#719e07">&gt;</span> <span style="color:#268bd2">greetStream</span>(org.apache.dubbo.common.stream.StreamObserver<span style="color:#719e07">&lt;</span>org.apache.dubbo.sample.tri.GreeterReply<span style="color:#719e07">&gt;</span> responseObserver); |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><h3 id="implementation-principle-of-stream">Implementation principle of stream</h3> |
| <p>How does the streaming mode of the <code>Triple</code> protocol support it?</p> |
| <ul> |
| <li> |
| <p>From the perspective of the protocol layer, <code>Triple</code> is built on the basis of <code>HTTP2</code>, so it directly has all the capabilities of <code>HTTP2</code>, so it has the ability to split <code>stream</code> and full-duplex.</p> |
| </li> |
| <li> |
| <p>In terms of the framework layer, <code>StreamObserver</code> is provided to users as a stream interface to provide stream processing for input and output parameters. The framework makes corresponding interface calls when sending and receiving stream data, so as to ensure the integrity of the life cycle of the stream.</p> |
| </li> |
| </ul> |
| <h2 id="triple-and-application-level-registration-discovery">Triple and application-level registration discovery</h2> |
| <p>The application-level service registration and discovery of the Triple protocol is consistent with other languages, and you can learn more about it through the following content.</p> |
| <ul> |
| <li><a href="https://dubbo.apache.org/zh-cn/docs/concepts/service-discovery/">Service Discovery</a></li> |
| <li><a href="https://dubbo.apache.org/zh-cn/docs/migration/migration-service-discovery/">Application-level address discovery migration guide</a></li> |
| </ul> |
| <h2 id="intercommunicate-with-grpc">Intercommunicate with GRPC</h2> |
| <p>Through the introduction of the protocol, we know that the <code>Triple</code> protocol is based on <code>HTTP2</code> and compatible with <code>GRPC</code>. In order to ensure and verify the interoperability with <code>GRPC</code>, Dubbo3 has also written various tests in slave scenarios. For details, you can learn more through <a href="https://github.com/apache/dubbo-samples/blob/master/3-extensions/protocol/dubbo-samples-triple/README.MD">here</a>.</p> |
| <h2 id="future-everything-on-stub">Future: Everything on Stub</h2> |
| <p>Students who have used <code>Grpc</code> should be familiar with <code>Stub</code>. |
| Grpc uses <code>compiler</code> to compile the written <code>proto</code> file into related protobuf objects and related rpc interfaces. By default several different <code>stubs</code> will be generated at the same time</p> |
| <p>-blockingStub</p> |
| <ul> |
| <li>futureStub |
| -reactorStub |
| -&hellip;</li> |
| </ul> |
| <p><code>stub</code> helps us shield the details of different calling methods in a unified way. However, currently <code>Dubbo3</code> only supports the traditional way of defining and calling interfaces.</p> |
| <p>In the near future, <code>Triple</code> will also implement various commonly used <code>Stub</code>, allowing users to write a <code>proto</code> file, which can be conveniently used in any scene through <code>comipler</code>, please wait and see.</p></description></item><item><title>Docs3-V2: 3.1 upgrade to 3.2</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/3.1-to-3.2-compatibility-guide/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/3.1-to-3.2-compatibility-guide/</guid><description> |
| <p>For the vast majority of users, upgrading to Dubbo 3.2.0 is completely smooth, and only needs to modify the version of the dependent package.</p> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-xml" data-lang="xml"><span style="display:flex;"><span><span style="color:#268bd2">&lt;dependency&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;groupId&gt;</span>org.apache.dubbo<span style="color:#268bd2">&lt;/groupId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;artifactId&gt;</span>dubbo<span style="color:#268bd2">&lt;/artifactId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;version&gt;</span>3.2.0<span style="color:#268bd2">&lt;/version&gt;</span> |
| </span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;/dependency&gt;</span> |
| </span></span></code></pre></div><p>or</p> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-xml" data-lang="xml"><span style="display:flex;"><span><span style="color:#268bd2">&lt;dependency&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;groupId&gt;</span>org.apache.dubbo<span style="color:#268bd2">&lt;/groupId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;artifactId&gt;</span>dubbo-spring-boot-starter<span style="color:#268bd2">&lt;/artifactId&gt;</span> |
| </span></span><span style="display:flex;"><span> <span style="color:#268bd2">&lt;version&gt;</span>3.2.0<span style="color:#268bd2">&lt;/version&gt;</span> |
| </span></span><span style="display:flex;"><span><span style="color:#268bd2">&lt;/dependency&gt;</span> |
| </span></span></code></pre></div><h1 id="compatibility-checklist">Compatibility CheckList</h1> |
| <h2 id="1-serialization-check-mode-important">1. Serialization check mode (important!!!)</h2> |
| <p>In Dubbo 3.2.0 version, Dubbo will enable the strong verification of the serialized whitelist by default to improve the security of Dubbo and avoid the problem of remote command execution. |
| For some users who use generics and may have incomplete scanning or <strong>large service scale</strong>, we recommend that you add <code>-Ddubbo.application.serialize-check-status=WARN</code> configuration. |
| After observing for a period of time (via logs and QoS commands), if no security alarm is triggered, you can configure the strong check mode.</p> |
| <p>For the configuration of the custom whitelist, please refer to <a href="https://dubbo.apache.org/en/docs3-v2/java-sdk/advanced-features-and-usage/security/class-check/">Documentation/SDK Manual/Java SDK/Advanced Features and Usage/Improve Security/Class Inspection Mechanism</a> article to configure.</p> |
| <h4 id="q1-why-do-you-need-to-enable-strong-verification-of-the-serialization-whitelist">Q1: Why do you need to enable strong verification of the serialization whitelist?</h4> |
| <p>Due to the problem of Java&rsquo;s own mechanism, the non-IDL serialization supported by Dubbo naturally allows access to arbitrary classes, which may lead to remote command execution (RCE) risks.</p> |
| <h4 id="q2-what-are-the-best-practices-for-upgrading-to-32">Q2: What are the best practices for upgrading to 3.2?</h4> |
| <p>We recommend <strong>all users</strong> to add <code>-Ddubbo.application.serialize-check-status=WARN</code> configuration before upgrading Dubbo 3.2.0 to ensure the best compatibility. Otherwise, it may lead to abnormal online data!</p> |
| <hr> |
| <h2 id="2-default-serialization-switch">2. Default serialization switch</h2> |
| <p>Starting from Dubbo version 3.2.0, the default serialization method is switched from <code>hessian2</code> to <code>fastjson2</code>. For applications upgraded to 3.2.0, Dubbo will automatically try to use <code>fastjson2</code> for serialization.</p> |
| <h4 id="q1-will-it-affect-the-intercommunication-with-lower-versions-of-dubbo">Q1: Will it affect the intercommunication with lower versions of Dubbo?</h4> |
| <p>Won&rsquo;t. Interoperability with lower versions still uses <code>hessian-lite</code>. For the principle, please refer to <a href="https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/serialization-upgrade/">Serialization Protocol Upgrade Guide</a>.</p> |
| <h4 id="q2-why-switch-the-default-serialization-method">Q2: Why switch the default serialization method?</h4> |
| <p><code>fastjson2</code> is a high-performance serialization framework with better performance than <code>hessian2</code>, natively supports JDK17, Native, etc., and is fully forward compatible with all functions of <code>hessian2</code>. |
| Since <code>hessian-lite</code> will become more and more difficult to maintain in the future, we decided to switch the default serialization method from <code>hessian2</code> to <code>fastjson2</code>.</p> |
| <h4 id="q3-what-is-the-relationship-with-native-json">Q3: What is the relationship with native JSON?</h4> |
| <p>Dubbo uses the JSONB format of <code>fastjson2</code> instead of the native JSON format. The JSONB format corresponds to the JSON format, can fully represent JSON, and is a binary format. |
| For the specific protocol format, please refer to: <a href="https://github.com/alibaba/fastjson2/wiki/jsonb_format_cn">JSONB format</a></p> |
| <h4 id="q4-what-if-i-dont-want-to-use-fastjson2">Q4: What if I don&rsquo;t want to use <code>fastjson2</code>?</h4> |
| <p>If you don&rsquo;t want to use <code>fastjson2</code>, you can configure <code>prefer-serialization</code> to override the default configuration for <code>hessian2</code>. (such as <code>dubbo.provider.prefer-serialization=fastjson2,hessian2</code>) If there is no special requirement, we do not recommend continuing to use <code>hessian2</code>.</p> |
| <hr> |
| <h2 id="3-push-short-protection-is-disabled-by-default">3. Push short protection is disabled by default</h2> |
| <p>Since version 3.2.0 of Dubbo, the push protection is turned off by default. Even if the registration center pushes an empty address, Dubbo will not keep the last batch of provider information. |
| If you need to enable empty protection, you can configure <code>dubbo.application.enable-empty-protection</code> to <code>true</code>.</p> |
| <h4 id="q1-how-does-disabling-push-short-protection-affect-me">Q1: How does disabling push short protection affect me?</h4> |
| <p>In most scenarios it has no effect. |
| The purpose of push empty protection is that when the registration center fails and actively pushes empty addresses, Dubbo keeps the last batch of provider information to ensure service availability. |
| However, when most registration centers fail, the registration center will not push empty addresses, only in some special cases. |
| However, if the push short protection is turned on, it will have a greater impact on Dubbo&rsquo;s Fallback logic, heartbeat logic, etc., and bring troubles to the development and use of Dubbo.</p> |
| <h4 id="q2-i-want-to-enable-short-push-protection-what-should-i-do">Q2: I want to enable short push protection, what should I do?</h4> |
| <p>If you need to enable push empty protection for high availability in production, you can configure <code>dubbo.application.enable-empty-protection</code> to <code>true</code>. |
| At present, it is known that turning on the push-out protection will cause the server-side application to upgrade from `2.6. In this scenario, the service call will fail. |
| In addition, after the push-to-empty protection is turned on, when the server address is really empty, there will be more heartbeat exceptions and log exceptions.</p> |
| <hr> |
| <h2 id="4-transitive-dependency-changes">4. Transitive dependency changes</h2> |
| <ul> |
| <li>Dubbo version 3.2.0 no longer shade <code>hessian-lite</code> code in <code>dubbo-all</code> by default, but use transitive dependency transfer instead. If you don&rsquo;t need to use <code>hessian-lite</code> in your application, you can remove <code>hessian-lite</code> from dependencies.</li> |
| <li>From version 3.2.0 of Dubbo, <code>gson</code>, <code>fastjson</code> dependencies are no longer passed in <code>dubbo-all</code>, if you need to use <code>gson</code>, <code>fastjson</code> in your application, please manually install <code>gson</code>, <code>fastjson</code> ` Dependencies are added to the application.</li> |
| <li>Dubbo 3.2.0 version passes <code>fastjson2</code> dependency in <code>dubbo-all</code>.</li> |
| </ul> |
| <hr> |
| <h2 id="5-default-internal-serialization-tool-switch">5. Default internal serialization tool switch</h2> |
| <p>Since version 3.2.0 of Dubbo, the default <strong>internal</strong> serialization tool is switched from <code>fastjson</code> to <code>fastjson2</code>.</p> |
| <h4 id="q1-will-it-affect-the-rpc-request-traffic">Q1: Will it affect the RPC request traffic?</h4> |
| <p>Won&rsquo;t. The internal serialization tool is used when Dubbo internally parses parameters, not the RPC transmission serialization protocol.</p> |
| <h4 id="q2-why-switch-the-default-internal-serialization-tool">Q2: Why switch the default internal serialization tool?</h4> |
| <p>From version 3.2.0 of Dubbo, the default transitive dependencies no longer pass <code>fastjson</code> and <code>gson</code>. For compatibility reasons, the default internal serialization tool is switched to <code>fastjson2</code>.</p> |
| <h4 id="q3-what-if-there-is-no-fastjson2-in-my-environment">Q3: What if there is no <code>fastjson2</code> in my environment?</h4> |
| <p>Dubbo supports automatic switching of various serialization frameworks. If there is no <code>fastjson2</code> in your environment, Dubbo will automatically try to switch to <code>fastsjon</code> or <code>gson</code>.</p> |
| <h4 id="q4-i-want-to-specify-the-internal-serialization-tool-of-dubbo-what-should-i-do">Q4: I want to specify the internal serialization tool of Dubbo, what should I do?</h4> |
| <p>You can configure <code>dubbo.json-framework.prefer</code> parameters, such as <code>-Ddubbo.json-framework.prefer=gson</code>.</p> |
| <hr> |
| <h2 id="6-triple-protocol-supports-passing-custom-exceptions">6. Triple protocol supports passing custom exceptions</h2> |
| <p>Starting from Dubbo version 3.2.0, the Triple protocol supports returning custom exceptions instead of only returning <code>RpcException</code>. If the service interface throws an exception, after Dubbo 3.2.0, the custom exception object will be returned by default according to the Dubbo protocol.</p> |
| <hr> |
| <h2 id="7-triple-protocol-version-number-alignment">7. Triple protocol version number alignment</h2> |
| <p>Starting from Dubbo version 3.2.0, the communication of the Triple protocol requires the version number and grouping of the client and server to be consistent, otherwise the service will not be found. When interoperating with the native gRPC SDK, the Dubbo side cannot configure groups and version numbers.</p> |
| <h4 id="q1-how-was-dubbo-before-320">Q1: How was Dubbo before 3.2.0?</h4> |
| <ol> |
| <li>Triple will think that the empty version number is consistent with the 1.0.0 version number. If your server and client version numbers are inconsistent, but they are both empty version numbers or 1.0.0 version numbers, they can communicate normally.</li> |
| <li>For a service that does not match a version number, Triple will try to match a service with any version number. If it matches a service with any version number, it can also communicate normally.</li> |
| </ol> |
| <h4 id="q2-how-to-ensure-that-it-is-aligned-with-the-original-behavior">Q2: How to ensure that it is aligned with the original behavior?</h4> |
| <p>By configuring <code>-Ddubbo.rpc.tri.ignore-1.0.0-version=true -Ddubbo.rpc.tri.resolve-fallback-to-default=true</code>, the previous behavior of Dubbo 3.2.0 can be achieved.</p></description></item><item><title>Docs3-V2: Application Level Service Discovery</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/service-discovery/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/service-discovery/</guid><description/></item><item><title>Docs3-V2: Serialization Protocol Upgrade Guide</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/serialization-upgrade/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/serialization-upgrade/</guid><description> |
| <p>In version 3.1.0, the serialization protocol supported by Dubbo by default adds support for Fastjson2. Some users may consider upgrading the serialization protocol in the existing system, but the difference between the server and client versions may cause the client to not support the serialization protocol of the server. In version 3.2.0, Dubbo&rsquo;s server introduces a new configuration <code>prefer-serialization</code>, which can perfectly solve the possible risks in the server-side serialization upgrade process.</p> |
| <h3 id="best-practices">Best Practices</h3> |
| <p>Serialization protocol upgrade needs to be done in two steps:</p> |
| <ul> |
| <li>**First, it is necessary to promote the serialization protocol upgrade of the server, and at the same time, the <code>prefer-serialization</code> configuration needs to be added to the exposed configuration of the server. For example: the serialization protocol before the upgrade is hessian2, and the serialization protocol after the upgrade is Fastjson2, then the configuration shown below should be added to the exposed configuration of the server **</li> |
| </ul> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yaml" data-lang="yaml"><span style="display:flex;"><span>dubbo.provider.prefer-serialization=fastjson2,hessian2 |
| </span></span><span style="display:flex;"><span>dubbo.provider.serialization=hessian2 |
| </span></span></code></pre></div><ul> |
| <li><strong>Secondly, the client needs to be upgraded to the same version as the server</strong></li> |
| </ul> |
| <h3 id="implementation-principle">Implementation principle</h3> |
| <p>The dubbo client serialization protocol is selected according to the registration configuration of the server (that is, the <code>serialization</code> configuration of the server). In the request phase, dubbo will assemble the serialization protocol of the client into the request header, and the server will determine the deserialization protocol according to the request header when performing deserialization.</p> |
| <ul> |
| <li>**So, if the versions of the server and the client are inconsistent, the client may not be able to serialize. ** In order to solve this situation, 3.2.0 will use the protocol configured by <code>prefer-serialization</code> first when serializing the client. If the protocol related to <code>prefer-serialization</code> is not supported, the protocol configured by <code>serialization</code> will be used . (You can think of <code>serialization</code> as a bottom-up configuration)</li> |
| </ul></description></item><item><title>Docs3-V2: Comparison of Protobuf and Interface</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/protobufinterface/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/protobufinterface/</guid><description> |
| <h2 id="1-data-type">1. Data type</h2> |
| <h3 id="11-basic-types">1.1. Basic types</h3> |
| <table> |
| <thead> |
| <tr> |
| <th>ptoto type</th> |
| <th>java type</th> |
| </tr> |
| </thead> |
| <tbody> |
| <tr> |
| <td>double</td> |
| <td>double</td> |
| </tr> |
| <tr> |
| <td>float</td> |
| <td>float</td> |
| </tr> |
| <tr> |
| <td>int32</td> |
| <td>int</td> |
| </tr> |
| <tr> |
| <td>int64</td> |
| <td>long</td> |
| </tr> |
| <tr> |
| <td>uint32</td> |
| <td>int[Note]</td> |
| </tr> |
| <tr> |
| <td>uint64</td> |
| <td>long[Note]</td> |
| </tr> |
| <tr> |
| <td>sint32</td> |
| <td>int</td> |
| </tr> |
| <tr> |
| <td>sint64</td> |
| <td>long</td> |
| </tr> |
| <tr> |
| <td>fixed32</td> |
| <td>int[Note]</td> |
| </tr> |
| <tr> |
| <td>fixed64</td> |
| <td>long[Note]</td> |
| </tr> |
| <tr> |
| <td>sfixed32</td> |
| <td>int</td> |
| </tr> |
| <tr> |
| <td>sfixed64</td> |
| <td>long</td> |
| </tr> |
| <tr> |
| <td>bool</td> |
| <td>boolean</td> |
| </tr> |
| <tr> |
| <td>string</td> |
| <td>String</td> |
| </tr> |
| <tr> |
| <td>bytes</td> |
| <td>ByteString</td> |
| </tr> |
| </tbody> |
| </table> |
| <blockquote> |
| <p>[Note] In Java, unsigned 32-bit and 64-bit integers are represented using their signed logarithms, with the top bit only stored in the sign bit.</p> |
| </blockquote> |
| <h2 id="2-composite-types">2. Composite types</h2> |
| <h3 id="21-enumeration">2.1. Enumeration</h3> |
| <ul> |
| <li>Original pb code</li> |
| </ul> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-gdscript3" data-lang="gdscript3"><span style="display:flex;"><span><span style="color:#719e07">enum</span> TrafficLightColor { |
| </span></span><span style="display:flex;"><span> TRAFFIC_LIGHT_COLOR_INVALID <span style="color:#719e07">=</span> <span style="color:#2aa198">0</span>; |
| </span></span><span style="display:flex;"><span> TRAFFIC_LIGHT_COLOR_UNSET <span style="color:#719e07">=</span> <span style="color:#2aa198">1</span>; |
| </span></span><span style="display:flex;"><span> TRAFFIC_LIGHT_COLOR_GREEN <span style="color:#719e07">=</span> <span style="color:#2aa198">2</span>; |
| </span></span><span style="display:flex;"><span> TRAFFIC_LIGHT_COLOR_YELLOW <span style="color:#719e07">=</span> <span style="color:#2aa198">3</span>; |
| </span></span><span style="display:flex;"><span> TRAFFIC_LIGHT_COLOR_RED <span style="color:#719e07">=</span> <span style="color:#2aa198">4</span>; |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><ul> |
| <li>Generated java code</li> |
| </ul> |
| <p><img src="https://dubbo.apache.org/imgs/docs/advanced/protobufinterface/124234531-b96c2c80-db46-11eb-8155-a77dbe059f07.png" alt="image"></p> |
| <blockquote> |
| <p>Enumerations are constants, so use uppercase</p> |
| </blockquote> |
| <h3 id="22-arrays">2.2. Arrays</h3> |
| <ul> |
| <li>Original pb code</li> |
| </ul> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span>message VipIDToRidReq { |
| </span></span><span style="display:flex;"><span> repeated uint32 vipID <span style="color:#719e07">=</span> 1; |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><ul> |
| <li>Generated java code</li> |
| </ul> |
| <p><img src="https://dubbo.apache.org/imgs/docs/advanced/protobufinterface/124234564-c4bf5800-db46-11eb-94fc-a056af6089cb.png" alt="image"></p> |
| <blockquote> |
| <p>The bottom layer is actually an ArrayList</p> |
| </blockquote> |
| <h3 id="23-collections">2.3. Collections</h3> |
| <p>PB does not support unordered and non-repeating collections, and can only <code>borrow arrays to implement</code>, and needs to <code>remove duplicates by itself</code>.</p> |
| <h3 id="24-dictionaries">2.4. Dictionaries</h3> |
| <ul> |
| <li>Original pb code</li> |
| </ul> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span>message BatchOnlineRes { |
| </span></span><span style="display:flex;"><span> map<span style="color:#719e07">&lt;</span>uint32, uint32<span style="color:#719e07">&gt;</span> onlineMap <span style="color:#719e07">=</span> 1;<span style="color:#586e75">//online status</span> |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><ul> |
| <li>Generated java code</li> |
| </ul> |
| <p><img src="https://dubbo.apache.org/imgs/docs/advanced/protobufinterface/124234654-e4568080-db46-11eb-9700-b30022ebee21.png" alt="image"></p> |
| <h3 id="25-nesting">2.5. Nesting</h3> |
| <ul> |
| <li>Original pb code</li> |
| </ul> |
| <div class="highlight"><pre tabindex="0" style="color:#93a1a1;background-color:#002b36;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-java" data-lang="java"><span style="display:flex;"><span>message BatchAnchorInfoRes { |
| </span></span><span style="display:flex;"><span> map<span style="color:#719e07">&lt;</span>uint32, AnchorInfo<span style="color:#719e07">&gt;</span> list <span style="color:#719e07">=</span> 1; <span style="color:#586e75">//user information map list</span> |
| </span></span><span style="display:flex;"><span>} |
| </span></span><span style="display:flex;"><span><span style="color:#586e75">/* |
| </span></span></span><span style="display:flex;"><span><span style="color:#586e75">* The function of the corresponding interface: get user information in batches or individually |
| </span></span></span><span style="display:flex;"><span><span style="color:#586e75">*/</span> |
| </span></span><span style="display:flex;"><span>message AnchorInfo { |
| </span></span><span style="display:flex;"><span> uint32 ownerUid <span style="color:#719e07">=</span> 1 <span style="color:#719e07">[</span>json_name<span style="color:#719e07">=</span><span style="color:#2aa198">&#34;uid&#34;</span><span style="color:#719e07">]</span>; <span style="color:#586e75">//user id</span> |
| </span></span><span style="display:flex;"><span> string nickName <span style="color:#719e07">=</span> 2 <span style="color:#719e07">[</span>json_name<span style="color:#719e07">=</span><span style="color:#2aa198">&#34;nn&#34;</span><span style="color:#719e07">]</span>; <span style="color:#586e75">//User nickname</span> |
| </span></span><span style="display:flex;"><span> string smallAvatar <span style="color:#719e07">=</span> 3 <span style="color:#719e07">[</span>json_name<span style="color:#719e07">=</span><span style="color:#2aa198">&#34;savt&#34;</span><span style="color:#719e07">]</span>; <span style="color:#586e75">//full path of user avatar - small</span> |
| </span></span><span style="display:flex;"><span> string middleAvatar <span style="color:#719e07">=</span> 4 <span style="color:#719e07">[</span>json_name<span style="color:#719e07">=</span><span style="color:#2aa198">&#34;mavt&#34;</span><span style="color:#719e07">]</span>; <span style="color:#586e75">//Full path of user avatar - middle</span> |
| </span></span><span style="display:flex;"><span> string bigAvatar <span style="color:#719e07">=</span> 5 <span style="color:#719e07">[</span>json_name<span style="color:#719e07">=</span><span style="color:#2aa198">&#34;bavt&#34;</span><span style="color:#719e07">]</span>; <span style="color:#586e75">//Full path of user avatar - big</span> |
| </span></span><span style="display:flex;"><span> string avatar <span style="color:#719e07">=</span> 6 <span style="color:#719e07">[</span>json_name<span style="color:#719e07">=</span><span style="color:#2aa198">&#34;avt&#34;</span><span style="color:#719e07">]</span>; <span style="color:#586e75">//User avatar</span> |
| </span></span><span style="display:flex;"><span>} |
| </span></span></code></pre></div><ul> |
| <li>Generated java code</li> |
| </ul> |
| <p><img src="https://dubbo.apache.org/imgs/docs/advanced/protobufinterface/124234723-f89a7d80-db46-11eb-82d0-a8aee5322098.png" alt="image"></p> |
| <h2 id="3-field-default-value">3. Field default value</h2> |
| <ul> |
| <li>For strings, the default is the empty string.</li> |
| <li>For bytes, the default is the null byte.</li> |
| <li>For bools, the default is false.</li> |
| <li>For numeric types, the default value is zero.</li> |
| <li>For enums, the default is the first defined enum value, which must be 0.</li> |
| <li>For the message field, the field is not set. Its exact value is language dependent. See the generated code guide for details.</li> |
| </ul> |
| <h2 id="4-overall-structure">4. Overall structure</h2> |
| <table> |
| <thead> |
| <tr> |
| <th>Feature</th> |
| <th>Java Interface</th> |
| <th>Protobuf</th> |
| <th>Remarks</th> |
| </tr> |
| </thead> |
| <tbody> |
| <tr> |
| <td>Method Overloading</td> |
| <td>√</td> |
| <td>×</td> |
| <td></td> |
| </tr> |
| <tr> |
| <td>Generic/templated</td> |
| <td>√</td> |
| <td>×</td> |
| <td></td> |
| </tr> |
| <tr> |
| <td>method inheritance</td> |
| <td>√</td> |
| <td>×</td> |
| <td></td> |
| </tr> |
| <tr> |
| <td>Nested definition</td> |
| <td>√</td> |
| <td>Partial support</td> |
| <td>PB only supports message and enum nesting</td> |
| </tr> |
| <tr> |
| <td>import file</td> |
| <td>√</td> |
| <td>√</td> |
| <td></td> |
| </tr> |
| <tr> |
| <td>field is null</td> |
| <td>√</td> |
| <td>×</td> |
| <td></td> |
| </tr> |
| <tr> |
| <td>Multiple input parameters</td> |
| <td>√</td> |
| <td>×</td> |
| <td>PB only supports single input parameters</td> |
| </tr> |
| <tr> |
| <td>0 input parameters</td> |
| <td>√</td> |
| <td>×</td> |
| <td>PB must have input parameters</td> |
| </tr> |
| <tr> |
| <td>0 output parameters</td> |
| <td>√</td> |
| <td>×</td> |
| <td>PB must have output parameters</td> |
| </tr> |
| <tr> |
| <td>The input/output parameters are abstract classes</td> |
| <td>√</td> |
| <td>×</td> |
| <td>The input/output parameters of PB must be concrete classes</td> |
| </tr> |
| <tr> |
| <td>The input/output parameters are interfaces</td> |
| <td>√</td> |
| <td>×</td> |
| <td>The input/output parameters of PB must be concrete</td> |
| </tr> |
| <tr> |
| <td>The input parameter/output parameter is the basic type</td> |
| <td>√</td> |
| <td>×</td> |
| <td>The input parameter/output parameter of PB must be a structure</td> |
| </tr> |
| </tbody> |
| </table> |
| <h2 id="5-community-profile">5. Community profile</h2> |
| <ul> |
| <li>Community homepage address: <a href="https://developers.google.cn/protocol-buffers/">https://developers.google.cn/protocol-buffers/</a></li> |
| <li>Community open source address: <a href="https://github.com/google/protobuf">https://github.com/google/protobuf</a></li> |
| <li>Maven of related jars: <a href="https://search.maven.org/search?q=com.google.protobuf">https://search.maven.org/search?q=com.google.protobuf</a></li> |
| </ul></description></item><item><title>Docs3-V2: 3.0 to 3.1 Operation Guide</title><link>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/3.0-to-3.1-compatibility-guide/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://dubbo.apache.org/en/docs3-v2/java-sdk/upgrades-and-compatibility/3.0-to-3.1-compatibility-guide/</guid><description> |
| <h2 id="function-modification-points">Function modification points</h2> |
| <h3 id="1-nacos-group-alignment-application-level-service-discovery">1. Nacos Group alignment (application-level service discovery)</h3> |
| <p>In Dubbo 2.7.x, the group value configured on the Nacos Registry URL is aligned with the group group in the Nacos Registry. (group can be regarded as a soft isolation similar to namespace)</p> |
| <p>In Dubbo 3.0.x, the group configured on the Nacos Registry URL is not used by default, and all use DEFAULT_GROUP. (group no longer provides isolation)</p> |
| <p>In Dubbo 3.1.x, the group value configured on the Nacos Registry URL will realign the group grouping in the Nacos Registry.</p> |
| <p>Precautions:</p> |
| <ol> |
| <li>Please check whether the group attribute has been configured on the URL of the registration center. If so, check whether the group of the server and the consumer are consistent. If not, please modify it to be consistent.</li> |
| <li>If you do not want the group to be realigned to the group grouping in the Nacos registry, you can configure the <code>dubbo.nacos-service-discovery.use-default-group=false</code> global property value to ignore this function</li> |
| </ol></description></item></channel></rss> |
