Dubbo学习之ServiceBean

已于 2022-05-16 16:59:42 修改
阅读量987 收藏 1
点赞数
分类专栏： Dubbo 文章标签： dubbo
于 2022-05-12 09:47:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xing_hung/article/details/124724688
版权

相关阅读

简介

本文基于Spring Boot 2.6.6，dubbo-spring-boot-starter 3.0.6环境。

由上文Dubbo学习之DubboService可知，标注了注解DubboService的Bean最终会被注册为ServiceBean；本文主要分析ServiceBean的实例化过程，以及Dubbo Service的创建过程；

Demo

核心依赖：

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

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-registry-zookeeper</artifactId>
    <version>3.0.6</version>
</dependency>

生产者核心配置参数：

server:
  port: 8080
dubbo:
  application:
    id: dubbo-provider
    name: dubbo-provider
  registry:
    address: zookeeper://127.0.0.1:2181
  protocol:
    port: 20880
  scan:
    base-packages: demo.dubbo.producer.config

生产者Dubbo Service配置代码：

package demo.dubbo.producer.config;

@Configuration
public class ServiceConfig {

    @Bean
    @DubboService
    public DemoService demoServiceImpl() {
        return new DemoServiceImpl();
    }
}

ServiceBean实例化

初始化

ServiceBean实现了InitializingBean接口，故在被创建后进行初始化时，会调用其afterPropertiesSet方法，代码如下：

public void afterPropertiesSet() throws Exception {
    if (StringUtils.isEmpty(getPath())) {
        if (StringUtils.isNotEmpty(getInterface())) {
            setPath(getInterface());
        }
    }
    
    ModuleModel moduleModel = DubboBeanUtils.getModuleModel(applicationContext);
    // 添加Service
    moduleModel.getConfigManager().addService(this);
    // 设置状态为PENDING
    moduleModel.getDeployer().setPending();
}

在afterPropertiesSet方法中将自身添加到ModuleConfigManager中，代码如下：

public void addService(ServiceConfigBase<?> serviceConfig) {
    addConfig(serviceConfig);
}

public final <T extends AbstractConfig> T addConfig(AbstractConfig config) {
    if (config == null) {
        return null;
    }
    // 此处会忽视MethodConfig
    if (!isSupportConfigType(config.getClass())) {
        throw new IllegalArgumentException("Unsupported config type: " + config);
    }

    if (config.getScopeModel() != scopeModel) {
        config.setScopeModel(scopeModel);
    }

    Map<String, AbstractConfig> configsMap = configsCache.computeIfAbsent(getTagName(config.getClass()), type -> new ConcurrentHashMap<>());

    if (!(config instanceof ReferenceConfigBase || config instanceof ServiceConfigBase)) {
        for (AbstractConfig value : configsMap.values()) {
            if (value.equals(config)) {
                return (T) value;
            }
        }
    }

    synchronized (configsMap) {
        return (T) addIfAbsent(config, configsMap);
    }
}

private <C extends AbstractConfig> C addIfAbsent(C config, Map<String, C> configsMap)
    throws IllegalStateException {

    if (config == null || configsMap == null) {
        return config;
    }

    Optional<C> prevConfig = findDuplicatedConfig(configsMap, config);
    if (prevConfig.isPresent()) {
        // 如果已存在，则直接返回
        return prevConfig.get();
    }

    String key = config.getId();
    if (key == null) {
        do {
            // 构造Key直至configsMap中不存在该Key
            key = generateConfigId(config);
        } while (configsMap.containsKey(key));
    }

    // 校验是否已存在Config
    C existedConfig = configsMap.get(key);
    if (existedConfig != null && !isEquals(existedConfig, config)) {
        String type = config.getClass().getSimpleName();
        logger.warn(String.format("Duplicate %s found, there already has one default %s or more than two %ss have the same id, " +
                "you can try to give each %s a different id, override previous config with later config. id: %s, prev: %s, later: %s",
            type, type, type, type, key, existedConfig, config));
    }

    // 保存当前Config
    configsMap.put(key, config);
    return config;
}

核心便是构建ReferenceConfig（用于后续创建Dubbo Reference），该动作由ReferenceCreator.build()完成，代码如下：

public final ReferenceConfig build() throws Exception {
    ReferenceConfig configBean = new ReferenceConfig();

    // 配置ReferenceConfig
    configureBean(configBean);

    if (logger.isInfoEnabled()) {
        logger.info("The configBean[type:" + configBean.getClass().getSimpleName() + "] has been built.");
    }

    return configBean;
}

protected void configureBean(ReferenceConfig configBean) throws Exception {
    // 填充属性
    populateBean(configBean);

    // deprecate application reference
    //configureApplicationConfig(configBean);

    // 配置Monitor
    configureMonitorConfig(configBean);
    // 配置Module
    configureModuleConfig(configBean);
    // 配置Consumer
    configureConsumerConfig(configBean);
}

至此，ServiceBean的实例化流程就结束了，ServiceBean继承自ServiceConfig，后续会被用于创建Dubbo Reference；

Dubbo Service创建

当AbstractApplicationContext完成fresh后，就会发布事件ContextRefreshedEvent，Dubbo中DubboDeployApplicationListener会关注该事件，并做相关处理，代码如下：

public void onApplicationEvent(ApplicationContextEvent event) {
    if (nullSafeEquals(applicationContext, event.getSource())) {
        if (event instanceof ContextRefreshedEvent) {
            onContextRefreshedEvent((ContextRefreshedEvent) event);
        } else if (event instanceof ContextClosedEvent) {
            onContextClosedEvent((ContextClosedEvent) event);
        }
    }
}

private void onContextRefreshedEvent(ContextRefreshedEvent event) {
    ModuleDeployer deployer = moduleModel.getDeployer();
    Assert.notNull(deployer, "Module deployer is null");
    // 启动Module
    Future future = deployer.start();

    if (!deployer.isBackground()) {
        try {
            // 同步等待Module启动完成
            future.get();
        } catch (InterruptedException e) {
            logger.warn("Interrupted while waiting for dubbo module start: " + e.getMessage());
        } catch (Exception e) {
            logger.warn("An error occurred while waiting for dubbo module start: " + e.getMessage(), e);
        }
    }
}

当Dubbo监听到ContextRefreshedEvent，便启动ModuleModel，代码如下：

public synchronized Future start() throws IllegalStateException {
    if (isStopping() || isStopped() || isFailed()) {
        throw new IllegalStateException(getIdentifier() + " is stopping or stopped, can not start again");
    }

    try {
        if (isStarting() || isStarted()) {
            // 正在启动或启动完成，则直接返回
            return startFuture;
        }

        // 设置STARTING状态
        onModuleStarting();

        applicationDeployer.initialize();
        initialize();

        // 暴露Service
        // 即处理@DubboService产生的ServiceBean
        exportServices();

    // 先启动内部ModuleModel若两者不一致的话
    if (moduleModel != moduleModel.getApplicationModel().getInternalModule()) {
        applicationDeployer.prepareInternalModule();
    }

        // 引用Service
        // 生产者端无处理
        referServices();

        if (asyncExportingFutures.isEmpty() && asyncReferringFutures.isEmpty()) {
            // 直接设置STARTED状态
            onModuleStarted();
        } else {
            executorRepository.getSharedExecutor().submit(() -> {
                try {
                    // 等待暴露Service完成
                    waitExportFinish();
                    // 等待引用Service完成
                    waitReferFinish();
                } catch (Throwable e) {
                    logger.warn("wait for export/refer services occurred an exception", e);
                } finally {
                    // 最后设置STARTED状态
                    onModuleStarted();
                }
            });
        }
    } catch (Throwable e) {
        onModuleFailed(getIdentifier() + " start failed: " + e, e);
        throw e;
    }
    return startFuture;
}

private void exportServices() {
    // 遍历所有的ServiceConfig进行暴露
    for (ServiceConfigBase sc : configManager.getServices()) {
        exportServiceInternal(sc);
    }
}

private void exportServiceInternal(ServiceConfigBase sc) {
    ServiceConfig<?> serviceConfig = (ServiceConfig<?>) sc;
    if (!serviceConfig.isRefreshed()) {
        // 还没刷新则刷新ServiceConfig的属性若需要的话
        serviceConfig.refresh();
    }
    if (sc.isExported()) {
        // 已暴露则直接退出
        return;
    }
    if (exportAsync || sc.shouldExportAsync()) {
        // 异步方式
        ExecutorService executor = executorRepository.getServiceExportExecutor();
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                if (!sc.isExported()) {
                    sc.export();
                    exportedServices.add(sc);
                }
            } catch (Throwable t) {
                logger.error(getIdentifier() + " export async catch error : " + t.getMessage(), t);
            }
        }, executor);

        asyncExportingFutures.add(future);
    } else {
        // 同步方式
        if (!sc.isExported()) {
            // 暴露服务
            sc.export();
            // 缓存已暴露的服务
            exportedServices.add(sc);
        }
    }
}

继续分析ServiceConfig.export()方法，代码如下：

public void export() {
    if (this.exported) {
        // 如果已暴露，则直接退出
        return;
    }

    // 确保Module启动
    getScopeModel().getDeployer().start();

    synchronized (this) {
        // DCL
        if (this.exported) {
            return;
        }

        if (!this.isRefreshed()) {
            this.refresh();
        }
        if (this.shouldExport()) {
            // 暴露前的准备动作
            // 设置serviceMetadata相关属性
            this.init();

            if (shouldDelay()) {
                // 延迟暴露
                doDelayExport();
            } else {
                // 执行暴露
                doExport();
            }
        }
    }
}

protected void doDelayExport() {
    // 延迟执行doExport
    getScopeModel().getDefaultExtension(ExecutorRepository.class).getServiceExportExecutor()
        .schedule(() -> {
            try {
                doExport();
            } catch (Exception e) {
                logger.error("Failed to export service config: " + interfaceName, e);
            }
        }, getDelay(), TimeUnit.MILLISECONDS);
}

protected synchronized void doExport() {
    if (unexported) {
        // 如果执行过unexport，此时却进行export，则抛出异常
        throw new IllegalStateException("The service " + interfaceClass.getName() + " has already unexported!");
    }
    if (exported) {
        // 如果已暴露，则直接退出
        return;
    }

    if (StringUtils.isEmpty(path)) {
        path = interfaceName;
    }
    doExportUrls();
    exported();
}

private void doExportUrls() {
    ModuleServiceRepository repository = getScopeModel().getServiceRepository();
    // 注册Service
    ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());
    providerModel = new ProviderModel(getUniqueServiceName(),
        ref,
        serviceDescriptor,
        this,
        getScopeModel(),
        serviceMetadata);

    // 注册Provider
    repository.registerProvider(providerModel);

    List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);

    for (ProtocolConfig protocolConfig : protocols) {
        String pathKey = URL.buildKey(getContextPath(protocolConfig)
                .map(p -> p + "/" + path)
                .orElse(path), group, version);
        // 如果用户指定了path，则将注册的Service映射到该path
        repository.registerService(pathKey, interfaceClass);
        // 向registryURLs暴露服务
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

doExportUrlsFor1Protocol方法中根据ProtocolConfig构建出服务的URL，然后通过exportUrl将服务暴露出去，exportUrl代码如下：

private void exportUrl(URL url, List<URL> registryURLs) {
    String scope = url.getParameter(SCOPE_KEY);
    // 未指定必须是NONE，则执行
    if (!SCOPE_NONE.equalsIgnoreCase(scope)) {

        // 未指定必须是REMOTE，则执行
        if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
            // 暴露到INJVM
            exportLocal(url);
        }

        // 未指定必须是LOCAL，则执行
        if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
            url = exportRemote(url, registryURLs);
            if (!isGeneric(generic) && !getScopeModel().isInternal()) {
                MetadataUtils.publishServiceDefinition(url, providerModel.getServiceModel(), getApplicationModel());
            }
        }
    }
    this.urls.add(url);
}

exportLocal和exportRemote中，构建出最终的URL后，执行doExportUrl，相关代码如下：

private void exportLocal(URL url) {
    ...
    doExportUrl(local, false);
    ...
}

private URL exportRemote(URL url, List<URL> registryURLs) {
    ...
    doExportUrl(registryURL.putAttribute(EXPORT_KEY, url), true);
    ...
}

private void doExportUrl(URL url, boolean withMetaData) {
    Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);
    if (withMetaData) {
        // 需要ServiceConfig，则使用包装器
        invoker = new DelegateProviderMetaDataInvoker(invoker, this);
    }
    // 借助SPI机制，根据URL的协议名称调用对应Protocol方法
    Exporter<?> exporter = protocolSPI.export(invoker);
    exporters.add(exporter);
}

exportRemote方法中URL的协议名称为：registry，则调用RegistryProtocol.export方法，代码如下：

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    URL registryUrl = getRegistryUrl(originInvoker);
    // url to export locally
    URL providerUrl = getProviderUrl(originInvoker);

    // Subscribe the override data
    // FIXME When the provider subscribes, it will affect the scene : a certain JVM exposes the service and call
    //  the same service. Because the subscribed is cached key with the name of the service, it causes the
    //  subscription information to cover.
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
    Map<URL, NotifyListener> overrideListeners = getProviderConfigurationListener(providerUrl).getOverrideListeners();
    overrideListeners.put(registryUrl, overrideSubscribeListener);

    providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
    // 暴露Invoker
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);

    // url to registry
    final Registry registry = getRegistry(registryUrl);
    final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);

    boolean register = providerUrl.getParameter(REGISTER_KEY, true) && registryUrl.getParameter(REGISTER_KEY, true);
    if (register) {
        register(registry, registeredProviderUrl);
    }

    registerStatedUrl(registryUrl, registeredProviderUrl, register);

    exporter.setRegisterUrl(registeredProviderUrl);
    exporter.setSubscribeUrl(overrideSubscribeUrl);

    if (!registry.isServiceDiscovery()) {
        // Deprecated! Subscribe to override rules in 2.6.x or before.
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
    }

    notifyExport(exporter);
    //Ensure that a new exporter instance is returned every time export
    return new DestroyableExporter<>(exporter);
}

private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
    // 获取Service URL
    String key = getCacheKey(originInvoker);

    return (ExporterChangeableWrapper<T>) bounds.computeIfAbsent(key, s -> {
        Invoker<?> invokerDelegate = new InvokerDelegate<>(originInvoker, providerUrl);
        // 启动Service
        // 借助SPI机制，根据URL的协议名称调用对应Protocol方法
        return new ExporterChangeableWrapper<>((Exporter<T>) protocol.export(invokerDelegate), originInvoker);
    });
}

本例采用Dubbo协议，故会调用DubboProtocol.export方法，代码如下：

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    checkDestroyed();
    // 获取Service URL
    URL url = invoker.getUrl();

    String key = serviceKey(url);
    DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);

    Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);
    Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);
    if (isStubSupportEvent && !isCallbackservice) {
        String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);
        if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
            if (logger.isWarnEnabled()) {
                logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) +
                        "], has set stubproxy support event ,but no stub methods founded."));
            }

        }
    }

    // 启动服务
    openServer(url);
    optimizeSerialization(url);

    return exporter;
}

private void openServer(URL url) {
    checkDestroyed();
    String key = url.getAddress();
    boolean isServer = url.getParameter(IS_SERVER_KEY, true);
    if (isServer) {
        ProtocolServer server = serverMap.get(key);
        if (server == null) {
            synchronized (this) {
                server = serverMap.get(key);
                if (server == null) {
                    // 服务不存在，则创建服务
                    serverMap.put(key, createServer(url));
                }else {
                    // 服务存在，则重置服务
                    server.reset(url);
                }
            }
        } else {
            // 服务存在，则重置服务
            // 同一个Dubbo服务，可以存在多个Service URL，这些Service共用同一个地址：IP:PORT
            server.reset(url);
        }
    }
}

private ProtocolServer createServer(URL url) {
    url = URLBuilder.from(url)
            .addParameterIfAbsent(CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString())
            // 心跳默认60s
            .addParameterIfAbsent(HEARTBEAT_KEY, String.valueOf(DEFAULT_HEARTBEAT))
            .addParameter(CODEC_KEY, DubboCodec.NAME)
            .build();
    // 默认为netty
    String str = url.getParameter(SERVER_KEY, DEFAULT_REMOTING_SERVER);

    if (StringUtils.isNotEmpty(str) && !url.getOrDefaultFrameworkModel().getExtensionLoader(Transporter.class).hasExtension(str)) {
        throw new RpcException("Unsupported server type: " + str + ", url: " + url);
    }

    ExchangeServer server;
    try {
        // 根据Service URL和requestHandler构建ExchangeServer
        // 最终创建NettyServer，并封装为HeaderExchangeServer
        server = Exchangers.bind(url, requestHandler);
    } catch (RemotingException e) {
        throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
    }

    str = url.getParameter(CLIENT_KEY);
    if (StringUtils.isNotEmpty(str)) {
        Set<String> supportedTypes = url.getOrDefaultFrameworkModel().getExtensionLoader(Transporter.class).getSupportedExtensions();
        if (!supportedTypes.contains(str)) {
            throw new RpcException("Unsupported client type: " + str);
        }
    }

    // 包装为DubboProtocolServer
    DubboProtocolServer protocolServer = new DubboProtocolServer(server);
    loadServerProperties(protocolServer);
    return protocolServer;
}

总结

接口调用流程如下：

  1. 标注了注解DubboService的Bean最终在Spring容器中是以ServiceBean（targetSource为DubboReferenceLazyInitTargetSource）形式存在；
  2. ServiceBean实例化时，会将自身作为ServiceConfig加入ModuleConfigManager；
  3. DubboDeployApplicationListener监听到ContextRefreshedEvent后，便会启动Module；
  4. Module启动过程中，会暴露ModuleConfigManager中所有的ServiceConfig，从而完成Dubbo Service创建；
我家有猫已长成
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dubbo学习例题代码资源
04-07
dubbo学习例题代码资源
dubbo学习视频
03-15
尚硅谷的dubbo学习视频,有问题可以留言给我,希望能帮到大家,谢谢
Dubbo学习文档
07-27
很详细的一个dubbo学习文档，与大家分享
Dubbo学习资料.zip
07-21
Dubbo快速入门案例相关资源包，其中包含入门教程，入门代码演示，所需软件，能够很轻松的掌握对于dubbo的学习，我的第一个入门案例就是来自于此的学习，希望他能够对你有所帮助
dubbo学习资料
03-30
随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。
Dubbo之ServiceBean
zhanghuyi2022的博客
07-04 1218
dubbo的服务，生成的spring的bean定义类型都是ServiceBean。也就是dubbo的注解@Service和配置文件里的dubbo:service/生成的bean定义类型都是ServiceBean。 举个例子： 接口 实现类 main方法 context.getBean(“ServiceBean:com.mytest.dubbo.DemoService”)获取到的就是dubbo服务的bean。Dubbo服务的bean定义在哪配置，也就是ServiceBean在哪里设置的？首先在配置类上增加注解
一步步解析Dubbo之ServiceBean（一）
longjiang900517的博客
06-30 1523
（个人理解，如果有误，望请指正，谢谢） 看过一些分析dubbo源码的文章，一般都是按模块进行分析的，分析common下面的包，然后是注册中心，过滤器等等，或许我能力有限，感觉零零碎碎的，最后也没有串联起来。所以用我自己的方式去分析代码。我这里看的代码是2.5.x分支的，2.7.x的代码已经略有不同。 其实看代码就像去发现了一个溶洞，需要探险一样，探险出发前需要确定从哪里开始，需要带上装备。一般，先...
Dubbo ServiceBean详解
Mergades
05-30 2379
ServiceBean类图 类继承图 成员变量和方法 服务暴露 服务暴露流程图 我们看几个核心的节点 ServiceConfig#doExport protected synchronized void doExport() 该方法为同步方法，在初始化时同步阻塞。 方法开始时进行一些列的检查，包含对provider，module，application，ref。 if (ref instanceof GenericService) { interfaceCla
Dubbo篇：ServiceBean服务暴露源码分析
走在路上
07-19 476
ServiceBean是Dubbo中很重要的一个类，每个暴露出去的服务都会生成一个ServiceBean。ServiceBean继承自ServiceConfig，ServiceConfig是服务暴露的具体实现类。另外ServiceBean还实现了InitializingBean，DisposableBean，ApplicationContextAware，ApplicationListener，BeanNameAware，ApplicationEventPublisherAware几个接口。
【Dubbo】服务暴露之ServiceBean
薄观约取，厚积薄发
06-02 286
是provider服务暴露的核心组件，也是服务暴露的入口，与spring容器完美整合，真正处理服务暴露的组件是ServiceBean 的父类ServiceConfig。
Dubbo构造ServiceBean过程
HanJuly9569的博客
08-31 984
Dubbo源码分析 1 注册Provider 1.1 构造ServiceBean ServiceBean继承与ServiceConfig，构造完成，并注册后。在触发ServiceBean的onApplicationEvent事件后，进行dubbo意义上的provider注册zookeeper。一个ServiceBean就对应一个@Service的注解，注解的属性其实和在配置文件...
Spring boot 2.1中通过编码的方式获取Dubbo服务
SailLiao
06-20 812
使用Spring boot 2.1 与 dubbo 2.7.1 服务注册 import org.apache.dubbo.common.utils.StringUtils; import org.apache.dubbo.config.ApplicationConfig; import org.apache.dubbo.config.ProtocolConfig; import org.apach...
Dubbo的四种配置，你都知道吗？
anzy/pine的博客
01-20 2003
项目代码地址：https://github.com/SunSmileAZY/dubbo-demo项目目录结构前言dubbo主要有四种配置方式：XML方式、注解方式、API方式、属性配置方...
dubbo系列之ServiceBean介绍（六）
sharedCode源码交流
10-22 2858
前言 前面几篇文章中，我们了解了spring是如何解析@Service，@Reference注解的，今天主要讲的是服务暴露者的一个非常重要的类，ServiceBean , 每个暴露出去的服务都会生成一个ServiceBean. ServiceBean 该类的继承实现关系如下 public class ServiceBean&amp;lt;T&amp;gt; extends ServiceConfig&amp;lt;T&amp;...
Dubbo源码解析（二） 服务代理 ServiceBean
wuhulala的休息室
05-17 1786
我之前看到了用dubbo:service会被解析为一个ServiceBean，那么服务代理和这个有关系吗？猜一猜，有吧？ 想一想Spring中的各个扩展点？ 既然没有看到相关的BeanPostProcessor和BeanFactoryPostProcessor 再想一想，会不会bean的初始化的时候，进行发布呢？ 对了 InitializingBean，这么个东西的afterProper...
Spring @Service生成bean名称的规则
wzw的博客
08-19 2876
今天碰到一个问题，写了一个@Service的bean，类名大致为：BKYInfoServcie.java dubbo export服务的配置： <dubbo:service interface=“com.xxx.XxxService” ref=“bKYInfoServcie” /> 结果启动报错：找不到名为bKYInfoServcie的bean bean的名字不是我预期的"bKYInfoServcie"，临时将bean的名字指定成了bKYInfoServcie来解决的，即：@Service(“b
一步步解析Dubbo之ServiceBean（二）
longjiang900517的博客
07-01 399
（个人理解，如果有误，望请指正，谢谢，配合源码阅读效果更好哟） 上篇我们讲解到即将执行export，那么我们接下来继续来解析剩下的代码： String scope = url.getParameter(Constants.SCOPE_KEY); ​ // don't export when none is configured ​ if (!Constants....
Dubbo服务导出浅析
seolin的博客
03-17 703
基于Spring的Dubbo服务导出。方法入口为ServiceBean.export()，此方法会调用ServiceConfig.export()方法，进行真正的服务导出。 服务导出原理 服务导出的入口为ServiceBean的export()方法，当Spring启动完之后，通过接收SpringContextRefreshedEvent事件来触发export()方法的执行。 一个ServiceBean对象就表示一个Dubbo服务，ServiceBean对象中的参数就表示服务的参数，比如timeout，该对象
Dubbo serviceBean
weixin_34344403的博客
03-22 360
前言 服务暴露是由com.alibaba.dubbo.config.spring.ServiceBean这个类来实现的，这个类是spring通过解析dubbo:service节点创建的单例Bean，每一个dubbo:service都会创建一个ServiceBean 源码解析 从上面类图可以看到实现了InitializingBean和ApplicationListener 所以afterProp...
尚硅谷dubbo学习笔记
最新发布
10-12
抱歉，我无法回答关于尚硅谷dubbo学习笔记的问题，因为我是一个通用型AI语言模型，没有具体的学习笔记。但是，我可以为您提供一些关于Dubbo的基本知识。 Dubbo是一种高性能、轻量级的开源Java RPC框架，由阿里巴巴公司开发并开源。Dubbo提供了三大核心能力：面向接口的远程方法调用、智能负载均衡、服务自动注册和发现。Dubbo支持多种协议和序列化方式，并且提供了丰富的扩展点，可以灵活地扩展和定制。 Dubbo的核心组件包括：Provider（服务提供者）、Consumer（服务消费者）、Registry（服务注册中心）和Monitor（服务监控中心）。Provider将服务发布到Registry中心，Consumer从Registry中心订阅服务并调用Provider提供的服务，Monitor用于监控服务的运行状态。 Dubbo的使用步骤包括：定义接口、实现接口、配置Provider和Consumer、启动Provider和Consumer。Dubbo提供了丰富的配置选项，可以通过XML或注解方式进行配置。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值