Dubbo3.0入门-Java版

已于 2022-11-21 16:42:56 修改
阅读量4.5k 收藏 3
点赞数 1
分类专栏： Dubbo 文章标签： java dubbo
于 2022-11-21 15:27:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_cpp_/article/details/127964434
版权

Dubbo 简介

​ Apache Dubbo 是一款 RPC 服务开发框架，用于解决微服务架构下的服务治理与通信问题，官方提供了 Java、Golang 等多语言 SDK 实现。使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力， 利用 Dubbo 提供的丰富服务治理特性，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。Dubbo 被设计为高度可扩展，用户可以方便的实现流量拦截、选址的各种定制逻辑。

​ Dubbo3 定义为面向云原生的下一代 RPC 服务框架。3.0 基于 Dubbo 2.x 演进而来，在保持原有核心功能特性的同时， Dubbo3 在易用性、超大规模微服务实践、云原生基础设施适配、安全性等几大方向上进行了全面升级。

Dobbo的基本工作流程

在这里插入图片描述
由上图可知要使用dubbo完成一次RPC调用，需要定义三类对象：

  1. 服务接口
  2. 生产者：实现具体的服务接口
  3. 消费者：生成服务代理对象，实现在本地调用远程服务

下面开始dubbo的入门案例

总览项目框架

在这里插入图片描述

创建maven作为父项目

父项目设置为dubbo-study，并在父项目中配置dubbo依赖

<properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.3.16.RELEASE</spring.version>
        <dubbo.version>3.0.7</dubbo.version>
        <junit.version>4.13.1</junit.version>
        <slf4j-log4j12.version>1.7.25</slf4j-log4j12.version>
        <spring-boot.version>2.3.1.RELEASE</spring-boot.version>
        <spring-boot-maven-plugin.version>2.1.4.RELEASE</spring-boot-maven-plugin.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-bom</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-dependencies-zookeeper</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
            </dependency>

            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j-log4j12.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

编写服务接口

项目名：dubbo-springboot-interface
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>dubbo-study</artifactId>
        <groupId>com.mxf</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-springboot-interface</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

服务接口
在这里插入图片描述

编写服务生产者

项目名：dubbo-springboot-provider
项目结构
在这里插入图片描述

导入依赖：

<properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.mxf</groupId>
            <artifactId>dubbo-springboot-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!-- dubbo -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper</artifactId>
            <type>pom</type>
        </dependency>

        <!-- dubbo starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>

        <!-- spring starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

    </dependencies>

实现具体服务：

import com.mxf.service.HelloService;
import org.apache.dubbo.config.annotation.DubboService;
import org.apache.dubbo.rpc.RpcContext;

/**
 * 用 @DubboService 注解标记，就可以实现 Dubbo 的服务暴露
 * 如果要设置服务参数，@DubboService 也提供了常用参数的设置方式。如果有更复杂的参数设置需求，则可以考虑使用其他设置方式
 * @DubboService(version = "1.0.0", group = "dev", timeout = 5000)
 */
@DubboService
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        System.out.println("Hello " + name + ", request from consumer: " + RpcContext.getContext().getRemoteAddress());
        return "Hello " + name;
    }
}

参考官网的内嵌ZooKeeper类

package com.mxf.config;

import org.apache.zookeeper.server.ServerConfig;
import org.apache.zookeeper.server.ZooKeeperServerMain;
import org.apache.zookeeper.server.quorum.QuorumPeerConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.SmartLifecycle;
import org.springframework.util.ErrorHandler;
import org.springframework.util.SocketUtils;

import java.io.File;
import java.lang.reflect.Method;
import java.util.Properties;
import java.util.UUID;

/**
 * from: https://github.com/spring-projects/spring-xd/blob/v1.3.1.RELEASE/spring-xd-dirt/src/main/java/org/springframework/xd/dirt/zookeeper/ZooKeeperUtils.java
 * <p>
 * Helper class to start an embedded instance of standalone (non clustered) ZooKeeper.
 * <p>
 * NOTE: at least an external standalone server (if not an ensemble) are recommended, even for
 * {@link org.springframework.xd.dirt.server.singlenode.SingleNodeApplication}
 *
 * @author Patrick Peralta
 * @author Mark Fisher
 * @author David Turanski
 */
public class EmbeddedZooKeeper implements SmartLifecycle {

    /**
     * Logger.
     */
    private static final Logger logger = LoggerFactory.getLogger(EmbeddedZooKeeper.class);

    /**
     * ZooKeeper client port. This will be determined dynamically upon startup.
     */
    private final int clientPort;

    /**
     * Whether to auto-start. Default is true.
     */
    private boolean autoStartup = true;

    /**
     * Lifecycle phase. Default is 0.
     */
    private int phase = 0;

    /**
     * Thread for running the ZooKeeper server.
     */
    private volatile Thread zkServerThread;

    /**
     * ZooKeeper server.
     */
    private volatile ZooKeeperServerMain zkServer;

    /**
     * {@link ErrorHandler} to be invoked if an Exception is thrown from the ZooKeeper server thread.
     */
    private ErrorHandler errorHandler;

    private boolean daemon = true;

    /**
     * Construct an EmbeddedZooKeeper with a random port.
     */
    public EmbeddedZooKeeper() {
        clientPort = SocketUtils.findAvailableTcpPort();
    }

    /**
     * Construct an EmbeddedZooKeeper with the provided port.
     *
     * @param clientPort port for ZooKeeper server to bind to
     */
    public EmbeddedZooKeeper(int clientPort, boolean daemon) {
        this.clientPort = clientPort;
        this.daemon = daemon;
    }

    /**
     * Returns the port that clients should use to connect to this embedded server.
     *
     * @return dynamically determined client port
     */
    public int getClientPort() {
        return this.clientPort;
    }

    /**
     * Specify whether to start automatically. Default is true.
     *
     * @param autoStartup whether to start automatically
     */
    public void setAutoStartup(boolean autoStartup) {
        this.autoStartup = autoStartup;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isAutoStartup() {
        return this.autoStartup;
    }

    /**
     * Specify the lifecycle phase for the embedded server.
     *
     * @param phase the lifecycle phase
     */
    public void setPhase(int phase) {
        this.phase = phase;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getPhase() {
        return this.phase;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isRunning() {
        return (zkServerThread != null);
    }

    /**
     * Start the ZooKeeper server in a background thread.
     * <p>
     * Register an error handler via {@link #setErrorHandler} in order to handle
     * any exceptions thrown during startup or execution.
     */
    @Override
    public synchronized void start() {
        if (zkServerThread == null) {
            zkServerThread = new Thread(new ServerRunnable(), "ZooKeeper Server Starter");
            zkServerThread.setDaemon(daemon);
            zkServerThread.start();
        }
    }

    /**
     * Shutdown the ZooKeeper server.
     */
    @Override
    public synchronized void stop() {
        if (zkServerThread != null) {
            // The shutdown method is protected...thus this hack to invoke it.
            // This will log an exception on shutdown; see
            // https://issues.apache.org/jira/browse/ZOOKEEPER-1873 for details.
            try {
                Method shutdown = ZooKeeperServerMain.class.getDeclaredMethod("shutdown");
                shutdown.setAccessible(true);
                shutdown.invoke(zkServer);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }

            // It is expected that the thread will exit after
            // the server is shutdown; this will block until
            // the shutdown is complete.
            try {
                zkServerThread.join(5000);
                zkServerThread = null;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                logger.warn("Interrupted while waiting for embedded ZooKeeper to exit");
                // abandoning zk thread
                zkServerThread = null;
            }
        }
    }

    /**
     * Stop the server if running and invoke the callback when complete.
     */
    @Override
    public void stop(Runnable callback) {
        stop();
        callback.run();
    }

    /**
     * Provide an {@link ErrorHandler} to be invoked if an Exception is thrown from the ZooKeeper server thread. If none
     * is provided, only error-level logging will occur.
     *
     * @param errorHandler the {@link ErrorHandler} to be invoked
     */
    public void setErrorHandler(ErrorHandler errorHandler) {
        this.errorHandler = errorHandler;
    }

    /**
     * Runnable implementation that starts the ZooKeeper server.
     */
    private class ServerRunnable implements Runnable {

        @Override
        public void run() {
            try {
                Properties properties = new Properties();
                File file = new File(System.getProperty("java.io.tmpdir")
                        + File.separator + UUID.randomUUID());
                file.deleteOnExit();
                properties.setProperty("dataDir", file.getAbsolutePath());
                properties.setProperty("clientPort", String.valueOf(clientPort));

                QuorumPeerConfig quorumPeerConfig = new QuorumPeerConfig();
                quorumPeerConfig.parseProperties(properties);

                zkServer = new ZooKeeperServerMain();
                ServerConfig configuration = new ServerConfig();
                configuration.readFrom(quorumPeerConfig);

                zkServer.runFromConfig(configuration);
            } catch (Exception e) {
                if (errorHandler != null) {
                    errorHandler.handleError(e);
                } else {
                    logger.error("Exception running embedded ZooKeeper", e);
                }
            }
        }
    }

}

启动类

import com.mxf.config.EmbeddedZooKeeper;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubbo    // @EnableDubbo 注解必须配置，否则将无法加载 Dubbo 注解定义的服务，@EnableDubbo 可以定义在主类上
public class ProviderApplication {
    public static void main(String[] args) {
        new EmbeddedZooKeeper(2181, false).start();

        SpringApplication.run(ProviderApplication.class, args);
        System.out.println("dubbo service started");
//        new CountDownLatch(1).await();
    }
}

对应的配置文件：

dubbo:
  application:
    name: dubbo-springboot-provider
  protocol:
    name: dubbo
    port: -1
  registry:
    id: zk-registry
    address: zookeeper://127.0.0.1:2181
  config-center:
    address: zookeeper://127.0.0.1:2181
  metadata-report:
    address: zookeeper://127.0.0.1:2181

服务消费者

项目名：dubbo-springboot-consumer
项目结构：
在这里插入图片描述

依赖：

 <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <slf4j-log4j12.version>1.7.25</slf4j-log4j12.version>
        <spring-boot.version>2.3.1.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.mxf</groupId>
            <artifactId>dubbo-springboot-interface</artifactId>
            <version>${project.parent.version}</version>
        </dependency>

        <!-- dubbo -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper</artifactId>
            <type>pom</type>
        </dependency>

        <!-- dubbo starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>

        <!-- spring starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

    </dependencies>

在本地实现调用远程服务

@SpringBootApplication
@Service
@EnableDubbo
public class ConsumerApplication {

    /**
     * @Reference 注解从 3.0 版本开始就已经废弃，改用 @DubboReference，以区别于 Spring 的 @Reference 注解
     * @DubboReference 注解将自动注入为 Dubbo 服务代理实例，使用 helloService 即可发起远程服务调用
     */
    @DubboReference
    private HelloService helloService;

    public String doSayHello(String name) {
        return helloService.sayHello(name);
    }

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ConsumerApplication.class, args);
        ConsumerApplication application = context.getBean(ConsumerApplication.class);
        String result = application.doSayHello("world");
        System.out.println("result: " + result);
    }
}

运行演示

首先启动dubbo-springboot-provider远程服务提供者
在这里插入图片描述
然后启动dubbo-springboot-consumer服务消费者
先看到服务提供者，打印接收到请求的日志：
在这里插入图片描述
消费者获取到服务提供者的处理结果
在这里插入图片描述

总结

step1: 编写远程服务接口
step2: 编写服务提供者
1. 实现远程服务接口
2. 使用@DubboService将服务暴露
step3: 编写服务消费者
1. 使用@DubboReference获取特定的服务实现类
2. 通过获取到的服务实现类来发起远程调用

JavaWizard-M
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dubbo2和dubbo3 入门简介
qq_37432174的博客
12-15 727
补上个人学习记录
dubbo3.0-admin
08-03
dubbo-admin 3.0
Dubbo3.0系列（3）- Dubbo3.0使用Nacos2.0注册中心入门案例
记录知识、锤炼自我
09-07 7015
环境搭建 1. 安装Nacos2.0 参考文档 2. 创建基础工程 创建一个父工程，三个子工程： 服务提供方 服务提供方接口 服务消费方 引入依赖 说明 本想想用dubbo集成Spring boot包，发现最新版本停在了2.7.9版本。。。 3.0X分支虽然有，但是一直也没看到提交代码，所以不知道什么时候会出3.0。。。 然后去alibaba看了下spring-cloud-starter-dubbo，发现最新版dubbo版本也停留在2.7系列，看来只能直接使用dubbo3.0核心包了，后面clou
分布式之dubbo3
励志成为一名优秀的全能型软件开发工程师。
06-12 976
Triple 是 Dubbo3 提出的基于 HTTP2 的开放协议，旨在解决 Dubbo2 私有协议带来的互通性问题。另外，Google公司开发的gRPC，也基于的HTTP2，目前gRPC是云原生事实上协议标准，包括k8s/etcd等都支持gRPC协议。
Dubbo3.0入门教程与新特性介绍 包括改装为dubbo以及跨语言调用
weixin_44030143的博客
04-15 857
⾃此，Dubbo的改造就完成了，总结⼀下：1. 添加pom依赖2. 配置dubbo应⽤名、协议、注册中⼼3. 定义服务接⼝和实现类4. 使⽤@DubboService来定义⼀个Dubbo服务5. 使⽤@DubboReference来使⽤⼀个Dubbo服务6. 使⽤@EnableDubbo开启Dubbo注册模型的改变在服务注册领域，市⾯上有两种模型，⼀种是应⽤级注册，⼀种是接⼝级注册，在Spring Cloud中，⼀个应⽤是⼀个微服务，⽽在Dubbo2.7中，⼀个接⼝是⼀个微服务。
java dubbo swagger_Dubbo 版 Swagger 来啦！Dubbo-Api-Docs 发布
weixin_28732953的博客
02-24 170
作者 |柯然(邪影)来源|阿里巴巴云原生公众号背景Swagger 是一个规范和完整的前端框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。Swagger 规范也逐渐发展成为了 OpenAPI 规范。Springfox 是一个集成了 Swagger，基于 Sring MVC/Spring Webflux 实现的一个 Swagger 描述文件生成框架，通过使用它定义的一些描述...
Dubbo 版 Swagger 来啦！Dubbo-Api-Docs 发布
阿里巴巴云原生的博客
01-12 2117
作者 | 柯然（邪影） 来源|阿里巴巴云原生公众号 背景 Swagger 是一个规范和完整的前端框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。Swagger 规范也逐渐发展成为了 OpenAPI 规范。 Springfox 是一个集成了 Swagger，基于 Sring MVC/Spring Webflux 实现的一个 Swagger 描述文件生成框架，通过使用它定义的一些描述接口的注解自动生成 Swagger 的描述文件，使 Swagger 能够展示并调用接口。 相.
Dubbo 3 Dubbo 快速入门 3.2 Dubbo 快速入门 3.2.2 服务提供者
谢谢你们的关注
12-17 220
Dubbo 3 Dubbo 快速入门 3.2 Dubbo 快速入门 3.2.2 服务提供者
RPC框架-Dubbo入门
搬运工007
09-27 732
dubbo学习入门
Java基础之《dubbo（1）—dubbo基础入门》
csj50的专栏
03-08 529
dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。（3）自动发现：基于注册中心目录服务，使服务消费方能动态的查找服务提供方，支持平滑减少或增加机器。（2）集群容错：软负载均衡，失败容错，地址路由，动态配置等集群支持。将独立的业务抽取出来，形成独立的服务（商品，订单，交易）（3）发展一年半，技术人员80个，服务越来越多，SOA。描述：服务提供方的一些服务治理、性能调优的一些配置。描述：服务消费方的一些服务治理、性能调优的一些配置。
dubbo不同版本调用模型变更和spirng cloud alibaba dubbo入门实例
澎湖Java架构师的博客
04-01 912
1. 前言 本文基于Spring Cloud Version:Spring Cloud Hoxton.SR8，Spring Boot Version：2.3.2.RELEASE，Nacos Version:1.3.3，Dubbo Version:2.7.8 本文是对自己最近学习Spring Cloud alibaba dubbo的一个总结，方便以后查阅。 参考文档：《一文聊透 Dubbo 元数据中心》《浅说 Dubbo 服务自省》《Dubbo 3.0 - 开启下一代云原生微服务》 2. dubbo更新的
dubbo-java-3.1.5
02-27
本文将对dubbo-java-3.1.5进行深入探讨，包括其核心特性、设计理念、以及如何使用和配置。 一、Dubbo的核心特性 1. 高性能：Dubbo基于NIO非阻塞I/O模型，实现了高并发处理能力，有效降低了系统资源的占用。 2. ...
jmeter-plugins-dubbo-2.7.8-jar-with-dependencies.jar
06-22
jmeter的dubbo插件，jmeter-plugins-dubbo-2.7.8-jar-with-dependencies.jar，适用于JMeter5.4.1版本，将解压后的文件jmeter-plugins-dubbo-2.7.8-jar-with-dependencies放在Jmeter安装目录下的\lib\ext文件夹中，...
jmeter-plugins-dubbo-2.7.1-jar-with-dependencies
06-08
本文将深入探讨“jmeter-plugins-dubbo-2.7.1-jar-with-dependencies”这一系统压测工具包，它专门针对基于Java的Dubbo服务进行性能测试。了解并熟练掌握这一工具，能帮助我们更好地优化服务性能，提升系统的稳定性...
Dubbo3.0入门教程与新特性介绍.pdf
08-31
1. 添加 Dubbo 相关依赖，如 dubbo-spring-boot-starter。 2. 配置 provider 的 properties 文件，如 dubbo.application.name、dubbo.protocol.name、dubbo.scan.base-packages 等。 3. 在 UserService 上添加 @...
golang 接口
m0_70982551的博客
07-24 952
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 516
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 647
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Dubbo 3.0入门教程：项目改造与新特性详解
"Dubbo3.0入门教程与新特性介绍涵盖了从基本的SpringBoot应用改造为Dubbo服务提供者和消费者，到新版本的特性如注册模型的变化、新一代RPC协议（UNARY, SERVER_STREAM, CLIENT_STREAM, BI_STREAM）以及跨语言调用的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值