dubbo多实现接口注册方案思路

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量792 收藏 2
点赞数
分类专栏： # dubbo 文章标签： java rpc zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25215821/article/details/113192248
版权

dubbo多接口实现注册方案

目录（注意点和总结很重要）

背景介绍
在前后端分离情况下服务端被调用项目也分为web端app端等，但是由于项目前期接口量少，不适合做过多的项目拆分，所以才有了这一套的过渡方案，方便日后项目拆分

实现方案

dubbo默认会使用实现类的第一个接口注册成bean并集成到可远程调用接口集，所以我们要做的就是在dubbo注册bean之后集成到可远程调用接口集之前手动将该实现类的其他接口都注册成bean即可

核心方法（在后面的 DubboConfig 类里有全代码）

	@Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        DubboClassPathBeanDefinitionScanner scanner = new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
        scanner.setBeanNameGenerator(new AnnotationBeanNameGenerator());
        scanner.addIncludeFilter(new AnnotationTypeFilter(DubboService.class));
        packagesToScan.stream().peek(scanner::scan).map(scanner::findCandidateComponents).flatMap(Set::stream).forEach(this::registerServiceBean);
    }

    private void registerServiceBean(BeanDefinition beanDefinition) {
        Class<?> beanClass = ClassUtils.resolveClassName(beanDefinition.getBeanClassName(), classLoader);
        Class<?>[] interfaceClasses = ClassUtils.getAllInterfacesForClass(beanClass);

        String beanName = generateServiceBeanName(interfaceClasses[0]);
        BeanDefinition bean = registry.getBeanDefinition(beanName);

        for (int i = 1; i < interfaceClasses.length; i++) {
            // ServiceBean Bean name
            registerBeanDefinition(interfaceClasses[i], bean);
        }
    }

    private String generateServiceBeanName(Class<?> interfaceClass) {
        return ServiceBeanNameBuilder.create(interfaceClass, environment).build();
    }

    private void registerBeanDefinition(Class<?> interfaceClass, BeanDefinition bean) {
        String replaceParamName = "interface";
        AbstractBeanDefinition newBeanDefinition = BeanDefinitionBuilder.rootBeanDefinition(ServiceBean.class).getBeanDefinition();
        bean.getPropertyValues().forEach(newBeanDefinition.getPropertyValues()::addPropertyValue);
        newBeanDefinition.getPropertyValues().removePropertyValue(replaceParamName);
        newBeanDefinition.getPropertyValues().add(replaceParamName, interfaceClass.getName());
        registry.registerBeanDefinition(generateServiceBeanName(interfaceClass), newBeanDefinition);
    }

代码全套

  1. 创建 @EnableMyDubbo 注解用于替换 @EnableDubbo 注解
    import org.apache.dubbo.config.spring.context.annotation.EnableDubboConfig;
import org.springframework.core.annotation.AliasFor;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@EnableDubboConfig
@MyDubboComponentScan
public @interface EnableMyDubbo {

    @AliasFor(annotation = MyDubboComponentScan.class, attribute = "basePackages")
    String[] scanBasePackages() default {};

    @AliasFor(annotation = MyDubboComponentScan.class, attribute = "basePackageClasses")
    Class<?>[] scanBasePackageClasses() default {};

    @AliasFor(annotation = EnableDubboConfig.class, attribute = "multiple")
    boolean multipleConfig() default true;
}
  2. 创建 @MyDubboComponentScan 注解用于替换 @DubboComponentScan 注解
    import org.apache.dubbo.config.spring.context.annotation.DubboComponentScan;
import org.springframework.context.annotation.Import;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@DubboComponentScan
@Import(MyDubboComponentScanRegistrar.class)
public @interface MyDubboComponentScan {

    String[] value() default {};

    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};
}
  3. 创建我们自己的dubbo扫描类 MyDubboComponentScanRegistrar
    import org.apache.dubbo.config.annotation.Service;
import org.apache.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor;
import org.apache.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor;
import org.apache.dubbo.config.spring.context.annotation.DubboComponentScan;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.ClassUtils;

import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.stream.Stream;

import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;


public class MyDubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
        registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
    }

	private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(MyDubboComponentScan.class.getName()));
        String[] basePackages = attributes.getStringArray("basePackages");
        Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
        String[] value = attributes.getStringArray("value");
        // Appends value array attributes
        Set<String> packagesToScan = new LinkedHashSet<>(Arrays.asList(value));
        packagesToScan.addAll(Arrays.asList(basePackages));
        Stream.of(basePackageClasses).map(ClassUtils::getPackageName).forEach(packagesToScan::add);
        return packagesToScan.isEmpty() ? Collections.singleton(ClassUtils.getPackageName(metadata.getClassName())) : packagesToScan;
    }

    private void registerServiceAnnotationBeanPostProcessor(Set<String> packagesToScan, BeanDefinitionRegistry registry) {
        BeanDefinitionBuilder builder = rootBeanDefinition(DubboConfig.class);
        builder.addConstructorArgValue(packagesToScan);
        builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);
    }
}
  4. 再自定义一个多实现接口标识注解 @DubboService
    import org.apache.dubbo.config.annotation.Service;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Inherited
@Service
public @interface DubboService {

}
  5. 核心，注册实现 DubboConfig
    import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.spring.ServiceBean;
import org.apache.dubbo.config.spring.beans.factory.annotation.ServiceBeanNameBuilder;
import org.apache.dubbo.config.spring.context.annotation.DubboClassPathBeanDefinitionScanner;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.AnnotationBeanNameGenerator;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.ClassUtils;

import java.util.Set;

@Slf4j
public class DubboConfig implements BeanDefinitionRegistryPostProcessor, EnvironmentAware, ResourceLoaderAware, BeanClassLoaderAware {

    private Environment environment;

    private ResourceLoader resourceLoader;

    private ClassLoader classLoader;

    private BeanDefinitionRegistry registry;

    private Set<String> packagesToScan;

    public DubboConfig(Set<String> packagesToScan) {
        this.packagesToScan = packagesToScan;
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        this.registry = registry;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        DubboClassPathBeanDefinitionScanner scanner = new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
        scanner.setBeanNameGenerator(new AnnotationBeanNameGenerator());
        scanner.addIncludeFilter(new AnnotationTypeFilter(DubboService.class));
        packagesToScan.stream().peek(scanner::scan).map(scanner::findCandidateComponents).flatMap(Set::stream).forEach(this::registerServiceBean);
    }

    private void registerServiceBean(BeanDefinition beanDefinition) {
        Class<?> beanClass = ClassUtils.resolveClassName(beanDefinition.getBeanClassName(), classLoader);
        Class<?>[] interfaceClasses = ClassUtils.getAllInterfacesForClass(beanClass);

        String beanName = generateServiceBeanName(interfaceClasses[0]);
        BeanDefinition bean = registry.getBeanDefinition(beanName);

        for (int i = 1; i < interfaceClasses.length; i++) {
            // ServiceBean Bean name
            registerBeanDefinition(interfaceClasses[i], bean);
        }
    }

    private String generateServiceBeanName(Class<?> interfaceClass) {
        return ServiceBeanNameBuilder.create(interfaceClass, environment).build();
    }

    private void registerBeanDefinition(Class<?> interfaceClass, BeanDefinition bean) {
        String replaceParamName = "interface";
        AbstractBeanDefinition newBeanDefinition = BeanDefinitionBuilder.rootBeanDefinition(ServiceBean.class).getBeanDefinition();
        bean.getPropertyValues().forEach(newBeanDefinition.getPropertyValues()::addPropertyValue);
        newBeanDefinition.getPropertyValues().removePropertyValue(replaceParamName);
        newBeanDefinition.getPropertyValues().add(replaceParamName, interfaceClass.getName());
        registry.registerBeanDefinition(generateServiceBeanName(interfaceClass), newBeanDefinition);
    }
}

使用方式

  1. 编写app端接口

    public interface AppService {

    String appService();
}

  2. 编写web端接口

    public interface WebService {

    String webService();
}

  3. 启动类上由 替换掉 @ 注解

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableMyDubbo
@SpringBootApplication
public class DubboServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboServiceApplication.class, args);
    }
}

  4. 编写服务提供者

    
@DubboService
public class ServiceImpl implements WebService, AppService {

    @Override
    public String webService() {
        return "webService";
    }

    @Override
    public String appService() {
        return "appService";
    }
}

  5. 编写app端消费者

    import org.apache.dubbo.config.annotation.Reference;

public class AppController {

    @Reference
    private WebService webService;

    public String test() {
        return webService.webService();
    }
}

  6. 编写web端消费者

    import org.apache.dubbo.config.annotation.Reference;

public class WebController {

    @Reference
    private AppService appService;

    public String test() {
        return appService.appService();
    }
}

注意点

  1. 当前使用的dubbo版本是 2.7.4
        <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
        <version>2.7.5</version>
    </dependency>

    遗憾的是并不兼容2.7.4以上版本

    2.7.4版本
    fasdf

    2.7.5版本 EnableDubbo 注解上增加了 @EnableDubboLifecycle 注解
    在这里插入图片描述

    2.7.6版本虽然和2.7.4一样，但是在 EnableDubboConfig 和 DubboComponentScan 注解里的导入配置类都增加了一行 registerCommonBeans(registry); 导致spring会报由 DubboBootstrapApplicationListener 引起的重复bean注册错误
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2.7.7版本直接计划废弃 Service 和 Reference 注解
    在这里插入图片描述

总结

  1. 直至2022年2月现在已经3.0.5版本了，所以仅供参考
工与绩不过兴与兴
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dubbo服务接口如何mock_基于动态代理 Mock dubbo 服务的实现方案
weixin_39832829的博客
12-22 508
序言背景概述公司目前 Java 项目提供服务都是基于 Dubbo 框架的，而且 Dubbo 框架已经成为大部分国内互联网公司选择的一个基础组件。在日常项目协作过程中，其实会碰到服务不稳定、不满足需求场景等情况，很多开发都会通过在本地使用 Mocktio 等单测工具作为自测辅助。那么，在联调、测试等协作过程中怎么处理？其实，Dubbo 开发者估计也是遇到了这样的问题，所以提供了一个提供泛化服务注册的...
Dubbo实现不同分支不同测试环境
Danny_idea的博客
01-01 601
在对于dubbo的路由机制和注册机制有所了解之后，我们来分析一下如何实现dubbo服务的不同环境隔离。 这一用法的大致思路为： 正常的测试环境中存在着api-consumer调用user-provider的这么一个调用关系，这里我们暂时称之为default版本。 假设某一天，业务方突然有一个a需求需要开发改动这个两个模块，此时就应该有这么一个关系链路出现，这里我们暂且称之为 version-a 版本。 但是由于version-a版本还是待完善阶段，可能还有一些影响主流程的bug存在，直接发布到测试环境替
springBoot,Dubbo,group实现接口多实现
L-李俊漩的博客
08-17 397
A服务提供接口,A服务调用B服务的方法,B服务实现A服务Dubbo接口.
Dubbo实现方案总览
贝克街的流浪猫
03-30 211
引言 从这篇文章开始，我们就开始深入到 Dubbo 的实现细节中，本文旨在一个较高的层面上总览 Dubbo 的实现方案。 总览 首先，我们简单的介绍一下各个功能点的实现，然后再深入代码中，详细分析每个功能点的细节。 解析服务 基于 dubbo.jar 内的 META-INF/spring.handlers 配置，Spring 在遇到 dubbo 名称空间时，会回调 DubboNamespaceHandler。 所有 dubbo 的标签，都统一用 DubboBeanDefinitionParser 进行解析，
升级dubbo3方案
Brucelwl的博客
07-22 910
dubbo3升级方案
解决dubbo多版本并存的一个思路
weixin_33834137的博客
04-10 3357
2019独角兽企业重金招聘Python工程师标准>>> ...
当Dubbo遇到高并发：探究流量控制解决方案
热门推荐
战斧的博客
07-27 1万+
在当今互联网时代，随着用户量的不断增长和业务复杂性的提升，高并发成为了很多系统面临的挑战。Dubbo作为一种优秀的分布式服务框架，在大规模高并发场景下也面临着一系列的挑战，其中最突出的，就是大量调用带来的流量问题。这次我就和大家一起探讨下Dubbo在高并发情况下的问题，并针对性地介绍流量控制解决方案，帮助大家更好地应对高并发场景下的挑战
关于动态注册dubbo的思路,做法
故意养只喵叫顺儿的博客
08-18 2671
技术： springboot，maven，dubbo，zookeeper 背景： 项目的功能类似一个中转路由，通过页面可以发送请求，请求到别的项目的接口，大家都知道dubbo接口的服务提供方需要把服务注册到zookeeper上，然后服务消费方获得服务提供方提供的facade包（也就是jar包），可以作为消费者去请求提供方的服务。 这里就有一个问题，dubbo接口的服务，无论是服务提供者还...
Dubbo 如何实现分布式事务
mnhpo_Q的博客
03-31 1098
2019独角兽企业重金招聘Python工程师标准>>> 分布式事务模型 TCC 模型：TCC-Transaction、HmilyXA 模型：Sharding Sphere、MyCAT2PC 模型：raincat、lcnMQ 模型：RocketMQBED 模型：Sharding SphereSaga 模型：ServiceComb Saga TCC TCC事务解决...
dubbo项目实现
03-24
代码实现则涵盖了服务接口、服务实现、以及服务暴露和引用的部分，这部分内容将展示如何通过Java API或XML配置来完成Dubbo的服务注册与调用。Word文档可能包含了项目背景、设计思路、操作指南等内容，帮助开发者理解...
dubbo相关文件
10-19
Dubbo的核心设计理念是面向接口编程，通过服务暴露和服务引用，实现服务间的远程调用（RPC）。在分布式系统中，Dubbo作为一个服务治理中间件，扮演着关键角色。 1. **服务提供者（Provider）**：服务提供者是指实现...
Dubbo视频教程--基础篇--第01节--使用Dubbo对传统工程进行服务化改造的思路介绍.rar
05-29
- **服务治理**：需要处理服务的生命周期管理，如服务注册、发现、上下线等，Dubbo提供了一套完善的解决方案。 - **通信协议选择**：Dubbo支持多种通信协议，如HTTP、RMI、Hessian等，根据实际需求选择合适协议。 ...
Distributed-Seckill:基于Spring+SpringMVC+Hibernate+Dubbo分布式开发系统架构，提供高并发、分布式秒杀系统解决方案，项目中除了实现秒杀功能外，还特别针对分布式事务提供了两种解决方案TCC和可靠消息服务
05-28
秒杀环节分别采用队列、乐观锁、分布式锁实现，分布式事务采用TCC、可靠消息服务两种方式，尽可能展示在高并发、分布式事务环境中的解决思路。 功能结构 jecp ├── jecp-common-core -- SSH框架公共模块 ├── ...
2小时学会微信第三方支付技术项目实战
06-18
学完SSM框架的同学就可以学习,能让你切身感受到企业级开发环境目标1：掌握二维码生成插件qrious的使用目标2：能够说出微信支付开发的整体思路目标3：能够调用微信支付接口（统一下单）生成支付二维码目标4：
配置Java开发环境
Broken_x的博客
07-10 1621
Java开发环境配置
java集合工具类
最新发布
药的博客
07-12 486
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 582
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 314
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
java实现dubbo接口mock
06-13
好的，实现dubbo接口mock一般有两种方式，分别是手动mock和使用dubbo-easy-mock工具。 手动mock需要开发者自己编写Mock类，实现dubbo接口，并在测试代码中使用Mock类替换掉真正的dubbo服务，这样在测试时就可以正常...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值