经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring » 查看文章
SpringCloud微服务集成Dubbo
来源：cnblogs　　作者：sowler　　时间：2024/3/29 8:47:43　　对本文有异议

1、Dubbo介绍

Apache Dubbo 是一款易用、高性能的 WEB 和 RPC 框架，同时为构建企业级微服务提供服务发现、流量治理、可观测、认证鉴权等能力、工具与最佳实践。用于解决微服务架构下的服务治理与通信问题，官方提供了 Java、Golang 等多语言 SDK 实现。使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力， 利用 Dubbo 提供的丰富服务治理特性，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。Dubbo 被设计为高度可扩展，用户可以方便的实现流量拦截、选址的各种定制逻辑。
Dubbo官网：https://cn.dubbo.apache.org/zh-cn/
Dubbo文档：https://cn.dubbo.apache.org/zh-cn/overview/quickstart/
Dubbo GitHub地址：https://github.com/apache/dubbo
Dubbo 使用版本对应关系：https://github.com/alibaba/spring-cloud-alibaba/wiki/版本说明#2021x-分支 选择和项目相互对应的版本进行使用。这里我使用的是Dubbo 2.7.8

2、Dubbo连接注册中心

Dubbo推荐使用Zookeeper作为注册中心，Zookeeper是Apacahe Hadoop的子项目，是一个树型的目录服务，支持变更推送，适合作为 Dubbo 服务的注册中心，工业强度较高，可用于生产环境。除此之外Dubbo还可以使用阿里巴巴的nacos做注册中心。Nacos作为注册中心Dubbo使用与ZooKeeper基本相同，在使用上，不同的地方只有以下两点：

  • 1、导入的依赖，配置不同；
  • 2、注解不同，ZooKeeper使用@Service、@Reference注解，Nacos使用@DubboService、@DubboReference注解；

3、Dubbo负载均衡

  • RandomLoadBalance：加权随机，默认算法，默认权重相同；
  • RoundRobinLoadBalance：加权轮询，默认权重相同；
  • LeastActiveLoadBalance：最少活跃优先+加权随机，能者多劳；
  • ConsistentHashLoadBalance：一致性Hash，确定入参，确定提供者，适用于有状态的请求；

4、Dubbo Admin下载与使用

官网地址：https://github.com/apache/dubbo-admin
Dubbo和Dubbo Admin版本说明：https://cn.dubbo.apache.org/zh-cn/blog/2019/01/07/新版-dubbo-admin-介绍/

4.1、修改配置文件

进入dubbo-admin-server的resources目录，修改application.properties文件修改配置中心。默认为zookeeper：

  1. admin.registry.address注册中心 
  2. admin.config-center 配置中心 
  3. admin.metadata-report.address元数据中心

由于我使用nacos，修改注册中心为nacos。 nacos注册中心有 GROUP 和 namespace:

  1. admin.registry.address=nacos://127.0.0.1:8848?group=DEFAULT_GROUP&namespace=public&username=nacos&password=nacos
  2. admin.config-center=nacos://127.0.0.1:8848?group=dubbo&username=nacos&password=nacos
  3. admin.metadata-report.address=nacos://127.0.0.1:8848?group=dubbo&username=nacos&password=nacos
  4. //改为自己的注册中心：
  5. admin.registry.address=nacos://localhost:8848?group=DEFAULT_GROUP&namespace=23857f22-27ac-4947-988a-1b88d4eeb807&username=nacos&password=nacos
  6. admin.config-center=nacos://localhost:8848?group=DEFAULT_GROUP&namespace=23857f22-27ac-4947-988a-1b88d4eeb807&username=nacos&password=nacos
  7. admin.metadata-report.address=nacos://localhost:8848?group=DEFAULT_GROUP&namespace=23857f22-27ac-4947-988a-1b88d4eeb807&username=nacos&password=nacos
4.2、Dubbo Admin项目打包

在项目根目录进行打包，跳过测试:

mvn clean package -Dmaven.test.skip=true

进入dubbo-admin-0.6.0/dubbo-admin-distribution/target 进行启动后端：

java -jar dubbo-admin-0.6.0.jar

dubbo-admin-ui 目录下执行命令启动前端：

npm run dev

这是官方项目开发环境说明，打开项目就能看到：

4.3 访问dubbo admin

浏览器输入地址进行访问,之前的dubbo-admin老版本用的是Tomcat启动的，后端端口是8080（可能会冲突），前端端口是8081

http://localhost:8081

新版的dubbo-admin用的是Netty，默认配置端口是38080，前端端口38082

http://localhost:38082 或 http://localhost:38080

用户名密码都是root
登录成功：

5、SpringCloud集成Dubbo

在SpringBoot模块中引入maven依赖：

  1. <!-- Dubbo Spring Cloud Starter -->
  2.         <dependency>
  3.             <groupId>com.alibaba.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-dubbo</artifactId>
  5.         </dependency>

这里使用用户模块和订单模块模拟微服务使用Dubbo RPC的调用。在提供者模块中加入Dubbo依赖，在配置文件中设置dubbo连接注册中心和配置中心：

  1. dubbo:
  2.   application:
  3.     name: user-service-model-provider
  4.   protocol:
  5.     name: dubbo
  6.     port: -1
  7.   provider:
  8.     group: DEFAULT_GROUP
  9.     version: 2.0
  10.   #port: 20881
  11.   registry:
  12.     address: nacos://${nacos.address:127.0.0.1}:8848?username=nacos&password=nacos
  13.     #配置nacos自定义命名空间
  14.     parameters:
  15.       namespace: 23857f22-27ac-4947-988a-1b88d4eeb807
  16.     group: DEFAULT_GROUP
  17. #  registry:
  18. #    address: zookeeper://${zookeeper.address:127.0.0.1}:2181
  19.   metadata-report:
  20.     address: nacos://${nacos.address:127.0.0.1}:8848?username=nacos&password=nacos
  21.     #配置nacos自定义命名空间
  22.     parameters:
  23.       namespace: 23857f22-27ac-4947-988a-1b88d4eeb807

配置添加成功后，在业务模块service层，新建一个对外提供的dubbo实现类UserExternalServiceImpl，需要使用@DubboService注解，@Service注解尽量不要使用，可以使用@Componet代替。代码如下：

  1. //@Service
  2. @Component
  3. @DubboService(timeout = 1000 * 10,group = "userGroup",version = "2.0")
  4. public class UserExternalServiceImpl implements IUserExternalService {
  6.     @Autowired
  7.     private IUserService userService;
  10.     @Override
  11.     public Response selectUserAll() {
  12. //        try {
  13. //            TimeUnit.MILLISECONDS.sleep(1000*5);
  14. //        } catch (InterruptedException e) {
  15. //            e.printStackTrace();
  16. //        }
  17.         return Response.success(userService.selectUserAll());
  18.     }
  20.     @Override
  21.     public Response insert(UserExternal userExternal) {
  22. //        boolean flag = true;
  23. //        if (flag == true){
  24. //            throw new ParamException(500,"用户模块出现错误，需要回滚");
  25. //        }
  26. //        try {
  27. //            TimeUnit.MILLISECONDS.sleep(20000);
  28. //        } catch (InterruptedException e) {
  29. //            e.printStackTrace();
  30. //        }
  31.         User user=new User();
  32.         BeanUtils.copyProperties(userExternal,user);
  33.         boolean save = userService.save(user);
  34.         if (save){
  35.             return Response.success();
  36.         }else {
  37.             return Response.fail();
  38.         }
  39.     }
  40. }

然后还需要在新建一个专门存dubbo的对外接口服务模块用interface-module名称，在该模块中新建一个IUserExternalService接口，该接口实现在用户模块中的UserExternalServiceImpl实现类：

  1. public interface IUserExternalService {
  3.     Response<List<UserExternal>> selectUserAll();
  5.     Response insert(UserExternal user);
  6. }

现在我们的接口提供方已经编写完成了，接下来开始编写接口使用方也就是消费者。在订单模块中引入dubbo依赖，在配置文件中将dubbo连接注册中心和配置中心：

  1. dubbo:
  2.   application:
  3.     name: order-service-model-consumer
  4.   consumer:
  5.     group: DEFAULT_GROUP
  6.     version: 2.0
  7.   protocol:
  8.     name: dubbo
  9.     port: -1
  10.   registry:
  11.     address: nacos://${nacos.address:127.0.0.1}:8848?username=nacos&password=nacos
  12.     #配置nacos自定义命名空间
  13.     parameters:
  14.       namespace: 23857f22-27ac-4947-988a-1b88d4eeb807
  15. #  registry:
  16. #    address: zookeeper://${zookeeper.address:127.0.0.1}:2181
  17.   cloud:
  18.     subscribed-services: user-service-model-provider
  19.   metadata-report:
  20.     address: nacos://${nacos.address:127.0.0.1}:8848?username=nacos&password=nacos
  21.     #配置nacos自定义命名空间
  22.     parameters:
  23.       namespace: 23857f22-27ac-4947-988a-1b88d4eeb807

下面我们需要引入刚刚新建存dubbo接口模块的依赖包，然后就可以使用该接口了。首先建一个IDubboUserService的接口实现DubboUserServiceImpl类，意思是这个类是专门存放通过dubbo接口调用用户模块的业务类，后续在订单模块中处理用户模块信息都可以在该业务类中进行处理。
IDubboUserService类代码：

  1. public interface IDubboUserService {
  3.     List<UserExternal> selectUserAll();
  5. }

DubboUserServiceImpl业务类代码,需要在该类中使用@DubboReference(group = "userGroup",version = "2.0")注解注入IUserExternalService接口信息，通过Dubbo RPC实现远程调用，注意group 和version 需要和提供方相互对应，不然会注入失败：

  1. @Service
  2. @Slf4j
  3. public class DubboUserServiceImpl implements IDubboUserService {
  5.     @DubboReference(group = "userGroup",version = "2.0")
  6.     private IUserExternalService userExternalService;
  8.     @Override
  9.     public List<UserExternal> selectUserAll() {
  10.         //添加blog
  11.         Blog blog = new Blog();
  12.         blog.setUid(UUID.randomUUID().toString());
  13.         blog.setTitle("dubbo测试Test");
  14.         blog.setContent("啊");
  15.         blog.setSummary("12");
  16.         blog.setTagUid("3c16b9093e9b1bfddbdfcb599b23d835");
  17.         blogService.insert(blog);
  18.         //处理相关逻辑
  19.         Response<List<UserExternal>> response = userExternalService.selectUserAll();
  20.         UserExternal user = new UserExternal();
  21.         user.setUserName("dubbo测试Test");
  22.         user.setAccount("system");
  23.         user.setEmail("dubbo@gemail.com");
  24.         Response insert = userExternalService.insert(user);
  25.         System.out.println(insert);
  26.         return response.getModel();
  27.     }
  28. }

通过上面的代码，就可以实现服务模块与模块之间的远程调用了。使用Dubbo在订单模块调用用户模块就和调用其他业务类代码一样通过依赖注入就可以了，是不是非常方便。

5、dubbo使用Sentinel进行限流和异常兜底

需要引入Maven依赖：

  1.         <!-- 在dubbo中使用 Sentinel 需要添加下面依赖 -->
  2.         <dependency>
  3.             <groupId>com.alibaba.csp</groupId>
  4.             <artifactId>sentinel-apache-dubbo-adapter</artifactId>
  5.         </dependency>

由于限流和兜底是消费方要处理的事情，所以我们只需要在订单模块中引入上面依赖即可。在DubboUserServiceImpl中，通过@SentinelResource注解处理，代码如下：

  1. @Service
  2. @Slf4j
  3. public class DubboUserServiceImpl implements IDubboUserService {
  5.     @DubboReference(group = "userGroup",version = "2.0")
  6.     private IUserExternalService userExternalService;
  8.     @Autowired
  9.     private IBlogService blogService;
  11. //    @PostConstruct
  12. //    private void initFlowRules(){
  13. //        System.out.println("Sentinel initFlowRules start===");
  14. //        List<FlowRule> rules = new ArrayList<>();
  15. //        FlowRule rule = new FlowRule();
  16. //        rule.setResource(IDubboUserService.class.getName());
  17. //        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
  18. //        // Set limit QPS to 20.
  19. //        rule.setCount(20);
  20. //        rules.add(rule);
  21. //        FlowRuleManager.loadRules(rules);
  22. //        System.out.println("Sentinel initFlowRules end====");
  23. //    }
  26.     @Override
  27.     @SentinelResource(value = "com.itmy.user.service.IUserExternalService:selectUserAll()", //当前方法的路径
  28.             blockHandler = "selectUserAll",
  29.             blockHandlerClass = CustomerBlockHandler.class, //触发限流 走该类的blockHandler = "selectUserAll"方法
  30.             fallback = "selectUserAllFallback",
  31.             fallbackClass = UserFallback.class, //dubbo调用接口异常，走该类的  fallback = "selectUserAllFallback"方法
  32.             exceptionsToIgnore = {IllegalArgumentException.class})
  33.     //fallback 负责业务异常 blockHandler限流方法 exceptionsToIgnore 报该异常fallback不处理
  34.     @GlobalTransactional(rollbackFor = Exception.class,timeoutMills = 30000,name = "order_tx_group")  //seata事务注解，目前没有使用后面会在seata博客中介绍。
  35.     public List<UserExternal> selectUserAll() {
  36.         //添加blog
  37.         Blog blog = new Blog();
  38.         blog.setUid(UUID.randomUUID().toString());
  39.         blog.setTitle("dubbo事务测试Test");
  40.         blog.setContent("dubbo事务测试Test啊的服务器打");
  41.         blog.setSummary("12");
  42.         blog.setTagUid("3c16b9093e9b1bfddbdfcb599b23d835");
  43.         blogService.insert(blog);
  44.         //处理相关逻辑
  45.         Response<List<UserExternal>> response = userExternalService.selectUserAll();
  46. //        boolean flag = true;
  47. //        if (flag == true){
  48. //            throw new ParamException(500,"用户模块出现错误，需要回滚");
  49. //        }
  50.         UserExternal user = new UserExternal();
  51.         user.setUserName("dubbo事务");
  52.         user.setAccount("system");
  53.         user.setEmail("dubbo@gemail.com");
  54.         Response insert = userExternalService.insert(user);
  55.         System.out.println(insert);
  56.         return response.getModel();
  57.     }
  58. }

CustomerBlockHandler处理限流的相关代码：

  1. @Slf4j
  2. public class CustomerBlockHandler {
  4.     /**
  5.      * 查询用户热点限流测试
  6.      * @param name
  7.      * @param email
  8.      * @param exception
  9.      * @return
  10.      */
  11.     public static Response selectUserBlockException(@RequestParam(value = "name",required = false) String name,
  12.                                                     @RequestParam(value = "email",required = false) String email,
  13.                                                     BlockException exception){
  14.         log.error("CustomerBlockHandler|selectUserBlockException is fail");
  15.         return Response.fail(FallbackErrorEnum.USER_MODULE_FALL);
  16.     }
  18.     /**
  19.      * 查询限流
  20.      * @return
  21.      */
  22.     public static Response redisFindBlockException(BlockException exception){
  23.         log.error("添加订单 redis|添加用户 redis信息，调用接口被限流。。。。。");
  24.         return Response.fail(FallbackErrorEnum.REDIS_FIND_FALL);
  25.     }
  28.     public static List<UserExternal> selectUserAll(BlockException exception){
  29.         log.error("添加订单|添加用户信息，触发限流控制。。。。。");
  30.         throw new ParamException(600,"添加用户信息异常："+exception.getMessage());
  31.     }
  33. }

UserFallback异常处理：

  1. @Slf4j
  2. public class UserFallback {
  4.     public static List<UserExternal> selectUserAllFallback(Throwable throwable) {
  5.         log.error("添加订单|添加用户信息异常，触发熔断兜底操作。");
  6.         throw new ParamException(600,"添加用户信息异常，触发兜底操作");
  7.     }
  8. }

6、总结

SpringCloud集成Dubbo到目前为止就介绍完毕了，希望本博客对你有所帮助。目前只介绍了如何使用dubbo，dubbo还有需多需要去学习的地方，让我们持续学习新的知识，来应对工作中的各种问题。

原文链接：https://www.cnblogs.com/sowler/p/18099925

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring热门文章

  • 解决springboot+activemq启动报注解错误的问题
  • Springboot整合Rabbitmq之Confirm和Return机制
  • SpringBoot SpringEL表达式的使用
  • SpringBoot自动配置原理,你真的懂吗?(简单易懂)
  • Spring源码：Bean生命周期（终章）
  • Springboot-Management的项目实践
  • 解决springboot 启动找不到主类的问题
  • Spring5路径匹配器PathPattern解析
  • SpringAOP如何获取方法参数上的注解
  • java与es8实战之五：SpringBoot应用中操作es8(带安全检查：https、账号密码、API Key)

    • Spring推荐文章

  • SpringBoot Session共享，配置不生效问题排查 → 你竟然在代码里下毒！
  • 【Spring源码分析】Spring Scope功能中的动态代理 - Scoped Proxy
  • Spring AOP概念及原理
  • SpringBoot2.7还是任性的，就是不支持Logback1.3，你能奈他何
  • SpringBoot+ Sharding Sphere 轻松实现数据库字段加解密
  • Spring MVC 中视图的实现原理，在Spring MVC 中实现重定向和转发，以及访问静态资源 - Rainbow-Sea
  • Spring MVC 中 HttpMessageConverter 转换器 - Rainbow-Sea
  • SpringBoot+mail 轻松实现各类邮件自动推送
  • Spring MVC 获取三个域(request请求域，session 会话域，application 应用域)对象的方式 - Rainbow-Sea
  • SpringBoot3整合SpringDoc实现在线接口文档

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号