• springboot 集成dubbo

    上一篇我们一起认识了Dubbo与RPC，今天我们就来一起学习如何使用Dubbo，并将Dubbo集成到Spring Boot的项目中。我们来看下今天要使用到的软件及版本：

    软件

    版本

    说明

    Java

    11

    Spring Boot

    2.7.13

    Spring Boot 3.0版本开始，最低支持到Java 17

    Dubbo

    3.2.2

    Zookeeper

    3.8.1

    作为Dubbo的注册中心

    注册中心的选择没有什么强制要求，我们这里以Zookeeper为例来做示范。

    TIps：今天我们只处理Spring Boot，Dubbo与Zookeeper的集成，不会涉及到其他框架的集成。

    部署Zookeeper

    我们先来部署一个Zookeeper，这里我提供Windows和Linux的部署教程，如果你已经部署成功，可以跳过这部分内容。

    首先是下载Zookeeper，这里我们选择Zookeeper-3.8.1版本。

    Linux下可以使用wget命令下载：

    wget https://archive.apache.org/dist/zookeeper/zookeeper-3.8.1/apache-zookeeper-3.8.1-bin.tar.gz

    Tips：注意，这里我们下载的是apache-zookeeper-3.8.1-bin.tar.gz这个文件。

    Linux部署Zookeeper

    解压Zookeeper：

    tar -zxvf apache-zookeeper-3.8.1-bin.tar.gz

    Zookeeper的配置文件，配置文件位于../Zookeeper/conf目录下，复制zoo_sample.cfg文件，并命名为zoo.cfg：

    cp zoo_sample.cfg zoo.cfg

    在Dubbo的学习中，我们使用Zookeeper的默认配置即可，所以此处我们不需要再修改zoo.cfg。

    修改profile文件：

    vim /etc/profile

    将Zookeeper的配置添加到profile文件中：

    1. export ZOOKEEPER_HOME=/opt/opt/apache-zookeeper-3.8.1-bin
    2. export PATH=$ZOOKEEPER_HOME/bin:$PATH
    3. export PATH

    刷新profile文件：

    source profile

    启动Zookeeper：

    zkServer.sh start

    正常情况下会输出日志：

    1. ZooKeeper JMX enabled by default
    2. Using config: /opt/apache-zookeeper-3.8.1-bin/bin/../conf/zoo.cfg
    3. Starting zookeeper ... STARTED

    可以使用命令来查看Zookeeper的状态：

    zkServer.sh status

    单机状态输出如下日志：

    1. ZooKeeper JMX enabled by default
    2. Using config: /opt/apache-zookeeper-3.8.1-bin/bin/../conf/zoo.cfg
    3. Client port found: 2181. Client address: localhost. Client SSL: false.
    4. Mode: standalone

    到这里我们就在Linux服务器上成功的部署了一个简单可用的单机版Zookeeper了。

    Windows部署Zookeeper

    参照Linux上部署Zookeeper的步骤来到修改配置文件的部分，Windows上我们要修改dataDir的路径，并新增dataLogDir的路径：

    1. tickTime=2000
    2. initLimit=10
    3. syncLimit=5
    4. dataDir=D:\Apache\Apache Zookeeper 3.8.1\data
    5. dataLogDir=D:\Apache\Apache Zookeeper 3.8.1\logs
    6. clientPort=2181

    如果系统中没有配置环境变量JAVA_HOME，我们要修改zkEnv.cmd中的JAVA_HOME配置，该文件位于../Apache Zookeeper/bin目录下：

    1. @echo off
    2. REM Licensed to the Apache Software Foundation (ASF) under one or more
    3. REM contributor license agreements.  See the NOTICE file distributed with
    4. REM this work for additional information regarding copyright ownership.
    5. REM The ASF licenses this file to You under the Apache License, Version 2.0
    6. REM (the "License"); you may not use this file except in compliance with
    7. REM the License.  You may obtain a copy of the License at
    8. REM
    9. REM     http://www.apache.org/licenses/LICENSE-2.0
    10. REM
    11. REM Unless required by applicable law or agreed to in writing, software
    12. REM distributed under the License is distributed on an "AS IS" BASIS,
    13. REM WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14. REM See the License for the specific language governing permissions and
    15. REM limitations under the License.
    16.  
    17. set ZOOCFGDIR=%~dp0%..\conf
    18. set ZOO_LOG_DIR=%~dp0%..\logs
    19.  
    20. REM for sanity sake assume Java 1.6
    21. REM see: http://java.sun.com/javase/6/docs/technotes/tools/windows/java.html
    22.  
    23. REM add the zoocfg dir to classpath
    24. set CLASSPATH=%ZOOCFGDIR%
    25.  
    26. REM make it work in the release
    27. SET CLASSPATH=%~dp0..\*;%~dp0..\lib\*;%CLASSPATH%
    28.  
    29. REM make it work for developers
    30. SET CLASSPATH=%~dp0..\build\classes;%~dp0..\build\lib\*;%CLASSPATH%
    31.  
    32. set ZOOCFG=%ZOOCFGDIR%\zoo.cfg
    33.  
    34. @REM setup java environment variables
    35.  
    36. if not defined JAVA_HOME (
    37. echo Error: JAVA_HOME is not set.
    38. goto :eof
    39. )
    40.  
    41. set JAVA_HOME=%JAVA_HOME%
    42.  
    43. if not exist "%JAVA_HOME%"\bin\java.exe (
    44. echo Error: JAVA_HOME is incorrectly set: %JAVA_HOME%
    45. echo Expected to find java.exe here: %JAVA_HOME%\bin\java.exe
    46. goto :eof
    47. )
    48.  
    49. REM strip off trailing \ from JAVA_HOME or java does not start
    50. if "%JAVA_HOME:~-1%" EQU "\" set "JAVA_HOME=%JAVA_HOME:~0,-1%"
    51.  
    52. set JAVA="%JAVA_HOME%"\bin\java

    我们将第41行的set JAVA_HOME=%JAVA_HOME%提前到第36行前，在在判断环境变量中是否存在JAVA_HOME前进行设置，并使用完整的路径，如：set JAVA_HOME=D:\Java\jdk11.0.18。

    上述内容修改完成后直接双击执行zkServer.cmd就可以启动Zookeeper了。注意，Windows下启动可能出现各种各样的错误，最常见的如启动闪退，这时可以在PowerShell中启动zkServer.cmd，来查看日志解决问题：

    1. cd D:
    2. PS D:\> cd '.\Apache\Apache Zookeeper 3.8.1\bin\'
    3. PS D:\Apache\Apache Zookeeper 3.8.1\bin> .\zkServer.cmd

    好了，到这里你应该已经完成了Zookeeper的部署工作了，接下来我们在Spring Boot应用中集成Dubbo。

    Dubbo的XML形式集成

    首先我们准备两个工程，DubboProviderXML和DubboConsumerXML，模仿服务提供方和服务使用方，创建工程的部分我们就直接跳过了，相信这一步大家都没问题。

    另外Dubbo官方提供了Dubbo Initializer项目脚手架，方便大家快速构建Dubbo项目：

    使用方式类似于Spring Initializr：

    Tips：

    • 当然你也可以在同一个工程中模拟提供方和使用方；
    • Spring Initializr严格意义上是一个错别字，但大家也都接受了这种方式，V2EX上有关于名字的讨论。

    DubboProviderXML工程

    在DubboProviderXML项目下创建了两个子工程：

    • provider-api，声明RPC接口
    • provider-service，核心业务逻辑的实现

    此时工程结构如下：

    现在修改DubboProviderXML工程的POM文件：

    1. <modelVersion>4.0.0</modelVersion>
    2. <groupId>com.wyz</groupId>
    3. <artifactId>DubboProviderXML</artifactId>
    4. <version>0.0.1-SNAPSHOT</version>
    5. <packaging>pom</packaging>
    6. <name>DubboProviderXML</name>
    7. <description>DubboProviderXML</description>
    8.  
    9. <properties>
    10.   <maven.compiler.source>11</maven.compiler.source>
    11.   <maven.compiler.target>11</maven.compiler.target>
    12.   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    13. </properties>
    14.  
    15. <modules>
    16.   <module>provider-api</module>
    17.   <module>provider-service</module>
    18. </modules>

    通常我会在DubboProviderXML工程中添加所有子项目都会用到的依赖，例如：lombok，commons-lang3等，在此我们忽略这部分内容。

    配置provider-api

    接着处理子工程provider-api中的POM文件：

    1. <modelVersion>4.0.0</modelVersion>
    2. <parent>
    3.   <groupId>com.wyz</groupId>
    4.   <artifactId>DubboProviderXML</artifactId>
    5.   <version>0.0.1-SNAPSHOT</version>
    6. </parent>
    7. <artifactId>provider-api</artifactId>
    8. <version>0.0.1-SNAPSHOT</version>
    9. <name>provider-api</name>
    10. <packaging>jar</packaging>
    11. <description>provider-api</description>

    然后在provider-api中声明RPC接口：

    1. package com.wyz.api;
    2.  
    3. /**
    4. * @author wyz
    5. * @version 1.0
    6. * @date 2023/6/28
    7. */
    8. public interface DubboDemoXMLService {
    9. 	String say(String message);
    10. }

    这样provider-api就配置完成了，DubboProviderXML就有了对外提供RPC服务的入口。

    Tips：需要将provider-api打包成jar，以便DubboConsumerXML使用。

    配置provider-service

    下面我们配置子工程provider-service的POM文件：

    1. <modelVersion>4.0.0</modelVersion>
    2. <parent>
    3.   <groupId>com.wyz</groupId>
    4.   <artifactId>DubboProviderXML</artifactId>
    5.   <version>0.0.1-SNAPSHOT</version>
    6. </parent>
    7. <artifactId>provider-service</artifactId>
    8. <version>0.0.1-SNAPSHOT</version>
    9. <name>provider-service</name>
    10. <description>provider-service</description>
    11.  
    12. <properties>
    13.   <spring.boot.version>2.7.13</spring.boot.version>
    14.   <dubbo.version>3.2.2</dubbo.version>
    15.   <zookeeper.version>3.8.1</zookeeper.version>
    16. </properties>
    17.  
    18. <dependencies>
    19.   <dependency>
    20.     <groupId>org.springframework.boot</groupId>
    21.     <artifactId>spring-boot-starter</artifactId>
    22.     <version>${spring.boot.version}</version>
    23.   </dependency>
    24.  
    25.   <!-- dubbo-spring-boot-starter引入了dubbo -->
    26.   <dependency>
    27.     <groupId>org.apache.dubbo</groupId>
    28.     <artifactId>dubbo-spring-boot-starter</artifactId>
    29.     <version>${dubbo.version}</version>
    30.   </dependency>
    31.  
    32.   <!-- DUbbo与Zookeeper的连接器 -->
    33.   <!-- curator5自身引入了Zookeeper的依赖，因此无需额外引入 -->
    34.   <dependency>
    35.     <groupId>org.apache.dubbo</groupId>
    36.     <artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
    37.     <version>${dubbo.version}</version>
    38.     <type>pom</type>
    39.   </dependency>
    40.  
    41.   <dependency>
    42.     <groupId>com.wyz</groupId>
    43.     <artifactId>provider-api</artifactId>
    44.     <version>0.0.1-SNAPSHOT</version>
    45.   </dependency>
    46. </dependencies>

    接下来我们在provider-service中实现这个接口：

    1. package com.wyz.service.impl;
    2.  
    3. import com.wyz.DubboDemoXMLService;
    4.  
    5. /**
    6. * @author wyz
    7. * @version 1.0
    8. * @date 2023/7/3
    9. */
    10. public class DubboDemoXMLServiceImpl implements DubboDemoXMLService {
    11.  
    12. 	@Override
    13. 	public String say(String message) {
    14. 		return "XML Provider say : " + message;
    15. 	}
    16. }

    现在，我们有了接口，也有了接口的实现，只需要配置成Dubbo的服务即可，新增dubbo-provider.xml文件：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.   xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
    5.   xsi:schemaLocation="http://www.springframework.org/schema/beans
    6.   http://www.springframework.org/schema/beans/spring-beans.xsd
    7.   http://dubbo.apache.org/schema/dubbo
    8.   http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    9.  
    10.   <!-- Dubbo的基本配置-->
    11.   <dubbo:application name="DubboProviderXML" qos-port="2222"/>
    12.   <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    13.   <dubbo:protocol name="dubbo"/>
    14.  
    15.   <!-- 配置提供的服务dubboDemoXMLServiceImpl -->
    16.   <bean id="dubboDemoXMLServiceImpl" class="com.wyz.service.impl.DubboDemoXMLServiceImpl"/>
    17.   <dubbo:service interface="com.wyz.api.DubboDemoXMLService" ref="dubboDemoXMLServiceImpl"/>
    18. </beans>

    所有配置完成后，我们导入dubbo-provider.xml文件：

    1. package com.wyz.service;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.context.annotation.ImportResource;
    6.  
    7. /**
    8. * @author wyz
    9. * @version 1.0
    10. * @date 2023/7/3
    11. */
    12. @SpringBootApplication
    13. @ImportResource(locations = "classpath:dubbo-provider.xml")
    14. public class ProviderServiceApplication {
    15.  
    16. 	public static void main(String[] args) {
    17. 		SpringApplication.run(ProviderServiceApplication.class, args);
    18. 	}
    19. }

    到这里我们的DubboProviderXML工程就配置完了，此时工程的结构如下：

    DubboConsumerXML工程

    我们继续配置服务使用方DubboConsumerXML工程，整体流程和DubboProviderXML的配置基本一致，我们直接快进到consumer-service中的配置部分。

    配置consumer-service

    consumer-service的POM文件与DubboProviderXML工程的子工程provider-service完全一致，我们也直接跳过这部分内容。

    接下来实现对DubboDemoXMLService#say的调用：

    1. package com.wyz.service.impl;
    2.  
    3. import com.wyz.DubboDemoXMLService;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.CommandLineRunner;
    6. import org.springframework.stereotype.Component;
    7.  
    8. /**
    9. * @author wyz
    10. * @version 1.0
    11. * @date 2023/7/3
    12. */
    13. @Component
    14. public class DubboConsumerXMLService implements CommandLineRunner {
    15.  
    16. 	@Autowired
    17. 	DubboDemoXMLService dubboDemoXMLServiceImpl;
    18.  
    19. 	@Override
    20. 	public void run(String... args) {
    21. 		String message = dubboDemoXMLServiceImpl.say("wyz");
    22. 		System.out.println(message);
    23. 	}
    24. }

    接着我们新增dubbo-consumer.xml文件，配置使用方要调用的服务：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.   xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
    5.   xsi:schemaLocation="http://www.springframework.org/schema/beans
    6.   http://www.springframework.org/schema/beans/spring-beans.xsd
    7.   http://dubbo.apache.org/schema/dubbo
    8.   http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
    9.  
    10.   <!-- Dubbo的基本配置-->
    11.   <dubbo:application name="DubboConsumerXML" qos-port="2223"/>
    12.   <dubbo:registry address="zookeeper://106.75.33.232:2181"/>
    13.   <dubbo:protocol name="dubbo"/>
    14.  
    15.   <!-- 配置需要调用的服务 -->
    16.   <dubbo:reference id="DubboDemoXMLService" interface="com.wyz.api.DubboDemoXMLService"/>
    17. </beans>

    同样的，我们导入dubbo-consumer.xml文件：

    1. package com.wyz.service;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.context.annotation.ImportResource;
    6.  
    7. /**
    8. * @author wyz
    9. * @version 1.0
    10. * @date 2023/7/3
    11. */
    12. @SpringBootApplication
    13. @ImportResource(locations = "classpath:dubbo-consumer.xml")
    14. public class ConsumerServiceApplication {
    15.  
    16. 	public static void main(String[] args) {
    17. 		SpringApplication.run(ConsumerServiceApplication.class, args);
    18. 	}
    19. }

    最后，我们启动程序，控制台应该输出如下日志：

    此时DubboConsumerXML的工程结构如下：

    Dubbo的注解形式集成

    除了使用XML外，我们还可以使用注解的方式配置Dubbo（毕竟有很多人不喜欢XML）。同样的我们需要先创建两个工程DubboProviderAnnotation和DubboConsumerAnnotation。

    DubboProviderAnnotation工程

    DubboProviderAnnotation工程与DubboProviderXML的配置步骤基本一致，我们快进到接口的实现部分，这次我们需要使用@DubboService注解声明这是一个Dubbo服务：

    1. package com.wyz.service.impl;
    2.  
    3. import com.wyz.api.DubboProviderAnnotationService;
    4. import org.apache.dubbo.config.annotation.DubboService;
    5.  
    6. /**
    7. * @author wyz
    8. * @version 1.0
    9. * @date 2023/7/3
    10. */
    11. @DubboService
    12. public class DubboProviderAnnotationServiceImpl implements DubboProviderAnnotationService {
    13.  
    14. 	@Override
    15. 	public String say(String message) {
    16. 		return "DubboProviderAnnotationService say : " + message;
    17. 	}
    18. }

    接口有了，实现也有了，我们来配置Dubbo的相关内容，这次我们使用YAML配置：

    1. dubbo:
    2.   application:
    3.     name: DubboProviderAnnotation
    4.     qos-port: 2222
    5.   protocol:
    6.     name: dubbo
    7.   registry:
    8.     address: zookeeper://${zookeeper.address:127.0.0.1}:2181

    接着，我们在启动类上添加@EnableDubbo注解，开启Dubbo的自动注入：

    1. package com.wyz.service;
    2.  
    3. import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6.  
    7. /**
    8. * @author wyz
    9. * @version 1.0
    10. * @date 2023/7/3
    11. */
    12. @SpringBootApplication
    13. @EnableDubbo
    14. public class ProviderServiceApplication {
    15. 	public static void main(String[] args) {
    16. 		SpringApplication.run(ProviderServiceApplication.class, args);
    17. 	}
    18. }

    此时DubboProviderAnnotation的结构如下：

    最后我们就可以正常启动DubboProviderAnnotation项目了。

    DubboConsumerAnnotation工程

    有了前面的基础，相信你一定可以想到DubboConsumerAnnotation该如何配置，我们先来写调用DubboDemoAnnotationService#say的调用逻辑，此时通过@DubboReference注入接口：

    1. package com.wyz.service.impl;
    2.  
    3. import com.wyz.api.DubboProviderAnnotationService;
    4. import org.apache.dubbo.config.annotation.DubboReference;
    5. import org.springframework.boot.CommandLineRunner;
    6. import org.springframework.stereotype.Component;
    7.  
    8. /**
    9. * @author wyz
    10. * @version 1.0
    11. * @date 2023/7/3
    12. */
    13. @Component
    14. public class DubboConsumerAnnotationService implements CommandLineRunner {
    15.  
    16. 	@DubboReference
    17. 	DubboProviderAnnotationService dubboProviderAnnotationService;
    18.  
    19. 	@Override
    20. 	public void run(String... args) {
    21. 		String message = dubboProviderAnnotationService.say("wyz");
    22. 		System.out.println(message);
    23. 	}
    24. }

    接着来配置YAML文件：

    1. dubbo:
    2.   application:
    3.     name: DubboConsumerAnnotation
    4.     qos-port: 2223
    5.   protocol:
    6.     name: dubbo
    7.   registry:
    8.     address: zookeeper://${zookeeper.address:127.0.0.1}:2181

    同样的，我们需要在服务使用方添加@EnableDubbo注解，开启Dubbo的自动注入：

    1. package com.wyz.service;
    2.  
    3. import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6.  
    7. /**
    8. * @author wyz
    9. * @version 1.0
    10. * @date 2023/7/3
    11. */
    12. @SpringBootApplication
    13. @EnableDubbo
    14. public class ConsumerServiceApplication {
    15. 	public static void main(String[] args) {
    16. 		SpringApplication.run(ConsumerServiceApplication.class, args);
    17. 	}
    18. }

    此时DubboConsumerAnnotation的结构如下：

    最后我们就可以正常启动DubboConsumerAnnotation项目了。

    结语

    到这里我们就完成了两种形式在Spring Boot中集成Dubbo 3.X。通常来说我会选择使用XML的形式来配置Dubbo提供的服务，但会选择将Dubbo的基本信息，如：协议类型，注册中心地址等配置到YAML文件中，这是为了统一管理对外提供的服务和使用的服务，可以一目了然的看到项目提供了哪些能力，和依赖了哪些外部接口。

    如果本文对你有帮助的话，还请多多点赞支持。如果文章中出现任何错误，还请批评指正。最后欢迎大家关注分享硬核Java技术的金融摸鱼侠王有志，我们下次再见！

  • 相关阅读:
    Softing工业将亮相2022年阿赫玛展会
    回溯专题——day35
    剑指offer015 三数之和
    多分辨率展开
    【C语言入门数据结构】顺序表
    查看和分析 IIS 日志文件以增强 Web 服务器安全性
    小白零基础学数学建模系列-Day2-数学建模工具介绍与案例实践
    【Vue基础-数字大屏】自定义主题
    【Golang】来用GoLand开发第一个Go程序
    JVM的垃圾收集算法
  • 原文地址：https://blog.csdn.net/m0_74433188/article/details/132661811