dubbo 超时设置和源码分析

源码分析Dubbo网络通信篇NettyClient,从思路到不断优化 前言 今天这篇文章是比较偏“教程”一点的文章。但也由浅入深,认真地分析了源码,并且介绍了一些在使用Spring Cache中常见的问题和解决方案,肯定是比简单的入门文档更有深度一些的,相信大家看了之后会有一定的收获。 4、private final boolean send_reconnect 消息发送时,如果当前客户端未连接,是否发起重连操作。 5、private final AtomicInteger reconnect_count = new AtomicInteger(0) 记录重连的次数。 6、p 阅读详情

本文 dubbo 2.6.2

在工作中碰到一个业务接口时间比较长,需要修改超时时间,不知道原理,在网上搜索,看到有人说如果你觉得自己了解了dubbo的超时机制,那么问问自己以下问题:

  • 超时是针对消费端还是服务端?
  • 超时在哪设置?
  • 超时设置的优先级是什么?
  • 超时的实现原理是什么?
  • 超时解决的是什么问题 ?

如果连这些都回答不上了,那只能说明还没有完全掌握 dubbo的超时机制。

于是索性就自己本地搭了个环境,研究了一下源码。 先来说一说结论:

1、超时是针对消费端的,消费端会抛出TimeoutException 而服务器端仅仅是一个 warn日志
2、超时在消费端、服务器端设置,dubbo会合并这两个设置
3、consumer方法级别 > provider 方法级别 > consumer 接口级别 > provider 接口级别 > consumer 全局级别 > provider 全局级别。如果都没配置,那么就是dubbo默认的1秒
4、见下面分析
5、最主要是宝贵的线程,客户端的用户线程不能因为服务端超时而一直类似wait, 导致无法正常响应其他业务。

一、超时时间设置

全局超时配置

<dubbo:consumer timeout="5000" />

指定接口以及特定方法超时配置

    <dubbo:service interface="me.kimi.samples.dubbo.facade.QuestionFacade" ref="questionFacade" timeout="6000">
        <dubbo:method name="getQuestionById" timeout="7000"/>
    </dubbo:service>

观察控制台打印的注册URL:

consumer://172.16.71.30/me.kimi.samples.dubbo.facade.QuestionFacade?application=demo-consumer&category=providers,configurators,routers&check=false&default.proxy=jdk&default.timeout=5000&dubbo=2.6.2&getQuestionById.timeout=7000&interface=me.kimi.samples.dubbo.facade.QuestionFacade&logger=log4j&methods=getQuestionById&pid=13884&side=consumer&timeout=6000&timestamp=1536630294523

可以看到:

  • default.timeout=5000
  • timeout=6000
  • getQuestionById.timeout=7000

分别对应了全局、类级别、方法级别的超时设置。

省略一部分调用链,最终会来到这里 DubboInvoker,读取超时时间:

com.alibaba.dubbo.rpc.protocol.dubbo.DubboInvoker

    @Override
    protected Result doInvoke(final Invocation invocation) throws Throwable {
        RpcInvocation inv = (RpcInvocation) invocation;
        final String methodName = RpcUtils.getMethodName(invocation);
        inv.setAttachment(Constants.PATH_KEY, getUrl().getPath());
        inv.setAttachment(Constants.VERSION_KEY, version);

        ExchangeClient currentClient;
        if (clients.length == 1) {
            currentClient = clients[0];
        } else {
            currentClient = clients[index.getAndIncrement() % clients.length];
        }
        try {
            boolean isAsync = RpcUtils.isAsync(getUrl(), invocation);
            boolean isOneway = RpcUtils.isOneway(getUrl(), invocation);
            // 读取超时时间,这里dubbo已经把服务端的timeout参数和消费端的timeout参数合并
            int timeout = getUrl().getMethodParameter(methodName, Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
            if (isOneway) {
                boolean isSent = getUrl().getMethodParameter(methodName, Constants.SENT_KEY, false);
                currentClient.send(inv, isSent);
                RpcContext.getContext().setFuture(null);
                return new RpcResult();
            } else if (isAsync) {
                ResponseFuture future = currentClient.request(inv, timeout);
                RpcContext.getContext().setFuture(new FutureAdapter<Object>(future));
                return new RpcResult();
            } else {
                RpcContext.getContext().setFuture(null);
                // 返回 DefaultFuture
                // get()在没返回值之前会 阻塞 await
                return (Result) currentClient.request(inv, timeout).get();
            }
        } catch (TimeoutException e) {
            throw new RpcException(RpcException.TIMEOUT_EXCEPTION, "Invoke remote method timeout. method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);
        } catch (RemotingException e) {
            throw new RpcException(RpcException.NETWORK_EXCEPTION, "Failed to invoke remote method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }

看一下参数获取的方法:

public int getMethodParameter(String method, String key, int defaultValue) {
    // 首先查 getQuestionById.timeout
    String methodKey = method + "." + key;
    // 从数字缓存中先获取,不需要每次都 parseInt
    Number n = getNumbers().get(methodKey);
    if (n != null) {
        return n.intValue();
    }
    // 没得话,去取字符串值
    String value = getMethodParameter(method, key);
    if (value == null || value.length() == 0) {
        // 三个地方都没配置,返回默认值,默认是1秒
        return defaultValue;
    }
    // 放入缓存中
    int i = Integer.parseInt(value);
    getNumbers().put(methodKey, i);
    return i;
}
public String getMethodParameter(String method, String key) {
    // 首先查 getQuestionById.timeout
    String value = parameters.get(method + "." + key);
    if (value == null || value.length() == 0) {
        // 没有设定方法级别的,去查接口级别或全局的
        return getParameter(key);
    }
    return value;
}
public String getParameter(String key) {
    // 接口级别去查 timeout 
    String value = parameters.get(key);
    if (value == null || value.length() == 0) {
        // 没的话查询全局级别 default.timeout
        value = parameters.get(Constants.DEFAULT_KEY_PREFIX + key);
    }
    return value;
}

从代码中可以看出超时时间的设置:方法级别 > 接口级别 > 全局级别。

这里要特殊提一点,就是dubbo会合并服务端客户端的设置。

修改客户端配置, 只留下全局设置:

<dubbo:consumer timeout="2000" proxy="jdk"/>
    <dubbo:service interface="me.kimi.samples.dubbo.facade.QuestionFacade" ref="questionFacade"/>

服务端配置如下:

    <dubbo:provider timeout="10000" accepts="500"/>
    <!-- service implementation, as same as regular local bean -->
    <bean id="questionFacade" class="me.kimi.samples.dubbo.provider.service.QuestionFacadeImpl"/>
    <!-- declare the service interface to be exported -->
    <dubbo:service interface="me.kimi.samples.dubbo.facade.QuestionFacade" ref="questionFacade" timeout="9000"/>

最后在客户端调用的时候,发现timeout是9000ms, debug发现客户端合并了url, 合并结果如下:

dubbo://172.16.71.30:20880/me.kimi.samples.dubbo.facade.QuestionFacade?anyhost=true&application=demo-provider&default.accepts=500&default.timeout=10000&dubbo=2.6.2&generic=false&interface=me.kimi.samples.dubbo.facade.QuestionFacade&logger=log4j&methods=getQuestionById&pid=17508&side=provider&timeout=9000&timestamp=1536660132286

查看源码 com.alibaba.dubbo.registry.integration.RegistryDirectory#mergeUrl:

private URL mergeUrl(URL providerUrl) {
    providerUrl = ClusterUtils.mergeUrl(providerUrl, queryMap); // Merge the consumer side parameters

    List<Configurator> localConfigurators = this.configurators; // local reference
    if (localConfigurators != null && !localConfigurators.isEmpty()) {
        for (Configurator configurator : localConfigurators) {
            providerUrl = configurator.configure(providerUrl);
        }
    }

    providerUrl = providerUrl.addParameter(Constants.CHECK_KEY, String.valueOf(false)); // Do not check whether the connection is successful or not, always create Invoker!

    // 这里就是合并服务器端的参数,所以除了timeout参数,其他很多参数也是这样的
    // 即已客户端优先
    this.overrideDirectoryUrl = this.overrideDirectoryUrl.addParametersIfAbsent(providerUrl.getParameters()); 

    if ((providerUrl.getPath() == null || providerUrl.getPath().length() == 0)
            && "dubbo".equals(providerUrl.getProtocol())) { // Compatible version 1.0
        //fix by tony.chenl DUBBO-44
        String path = directoryUrl.getParameter(Constants.INTERFACE_KEY);
        if (path != null) {
            int i = path.indexOf('/');
            if (i >= 0) {
                path = path.substring(i + 1);
            }
            i = path.lastIndexOf(':');
            if (i >= 0) {
                path = path.substring(0, i);
            }
            providerUrl = providerUrl.setPath(path);
        }
    }
    return providerUrl;
}

所以综合,超时时间的优先级为:

consumer方法级别 > provider 方法级别 > consumer 接口级别 > provider 接口级别 > consumer 全局级别 > provider 全局级别。

二、超时实现

有了超时时间,那么dubbo是怎么实现超时的呢?

再看上面的DubboInvoker,对于一般的有返回值的调用,最终调用:

return (Result) currentClient.request(inv, timeout).get();

先看一下request方法,来到
com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchangeChannel的Request方法:

    @Override
    public ResponseFuture request(Object request, int timeout) throws RemotingException {
        if (closed) {
            throw new RemotingException(this.getLocalAddress(), null, "Failed to send request " + request + ", cause: The channel " + this + " is closed!");
        }
        // create request.
        Request req = new Request();
        req.setVersion("2.0.0");
        req.setTwoWay(true);
        req.setData(request);
       
        DefaultFuture future = new DefaultFuture(channel, req, timeout);
        try {
            channel.send(req);
        } catch (RemotingException e) {
            future.cancel();
            throw e;
        }
        return future;
    }

重点是 DefaultFuture:

static {
    Thread th = new Thread(new RemotingInvocationTimeoutScan(), "DubboResponseTimeoutScanTimer");
    th.setDaemon(true);
    th.start();
}

类加载的时候会启动一个超时扫描线程:

public DefaultFuture(Channel channel, Request request, int timeout) {
    this.channel = channel;
    this.request = request;
    this.id = request.getId();
    this.timeout = timeout > 0 ? timeout : channel.getUrl().getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
    // 每个 DefaultFuture 都有一个 id, 对应当前请求id, 然后被放到 静态Map中。
    FUTURES.put(id, this);
    // id 对应的 Channel 也存起来,后续超时需要处理
    CHANNELS.put(id, channel);
}

再看下get方法:

@Override
public Object get() throws RemotingException {
    return get(timeout);
}

@Override
public Object get(int timeout) throws RemotingException {
    if (timeout <= 0) {
        timeout = Constants.DEFAULT_TIMEOUT;
    }
    if (!isDone()) {
        long start = System.currentTimeMillis();
        lock.lock();
        try {
            while (!isDone()) {
                // 这里可以看到在调用的时候需要等待
                done.await(timeout, TimeUnit.MILLISECONDS);
                if (isDone() || System.currentTimeMillis() - start > timeout) {
                    break;
                }
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
        
        if (!isDone()) {
            throw new TimeoutException(sent > 0, channel, getTimeoutMessage(false));
        }
    }
    // 处理返回值
    // 线程扫描超时,正常返回都在这里
    return returnFromResponse();
}

从上面代码上可以看到,get方法,会使当前线程挂起等待。那么什么时候会被恢复呢,可以想到两类情况:

1、超时
2、服务端正常返回

那么回过头来看看超时扫描线程,看一下扫描线程做了什么事情:

private static class RemotingInvocationTimeoutScan implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    // 就是去扫描DefaultFuture列表
                    for (DefaultFuture future : FUTURES.values()) {
                        if (future == null || future.isDone()) {
                            continue;
                        }
                        // 如果future未完成,且超时
                        if (System.currentTimeMillis() - future.getStartTimestamp() > future.getTimeout()) {
                            // 创建一个异常的Response
                            Response timeoutResponse = new Response(future.getId());
                            // set timeout status.
                            timeoutResponse.setStatus(future.isSent() ? Response.SERVER_TIMEOUT : Response.CLIENT_TIMEOUT);
                            timeoutResponse.setErrorMessage(future.getTimeoutMessage(true));
                            // 处理异常
                            DefaultFuture.received(future.getChannel(), timeoutResponse);
                        }
                    }
                    Thread.sleep(30);
                } catch (Throwable e) {
                    logger.error("Exception when scan the timeout invocation of remoting.", e);
                }
            }
        }
    }

看下 received方法

public static void received(Channel channel, Response response) {
    try {
        DefaultFuture future = FUTURES.remove(response.getId());
        if (future != null) {
            future.doReceived(response);
        } else {
            logger.warn("The timeout response finally returned at "
                    + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()))
                    + ", response " + response
                    + (channel == null ? "" : ", channel: " + channel.getLocalAddress()
                    + " -> " + channel.getRemoteAddress()));
        }
    } finally {
        CHANNELS.remove(response.getId());
    }
}
private void doReceived(Response res) {
    lock.lock();
    try {
        // 设置响应
        // 这样isDone就是true了
        response = res;
        if (done != null) {
            // 恢复挂起的线程 
            done.signal();
        }
    } finally {
        lock.unlock();
    }
    if (callback != null) {
        invokeCallback(callback);
    }
}

显然这里扫描线程把用户请求线程恢复了。 恢复以后,顺着刚才的 DefaultFuture 的get方法,来到 returnFromResponse方法:

private Object returnFromResponse() throws RemotingException {
    Response res = response;
    if (res == null) {
        throw new IllegalStateException("response cannot be null");
    }
    // 正常返回,返回 Result 对象
    if (res.getStatus() == Response.OK) {
        return res.getResult();
    }
    // 超时处理
    if (res.getStatus() == Response.CLIENT_TIMEOUT || res.getStatus() == Response.SERVER_TIMEOUT) {
        // 重新抛出异常
        throw new TimeoutException(res.getStatus() == Response.SERVER_TIMEOUT, channel, res.getErrorMessage());
    }
    throw new RemotingException(channel, res.getErrorMessage());
}

超时扫描线程,构建了一个 超时 Response, 在这里抛出 超时异常。

超时抛异常是看见了,那么正常返回是怎么处理的呢,因为 done还 await在那里。 这里暂时不细说dubbo其他组件的原理,只要知道在网络事件完成(即服务器端在规定时间内正常返回)的时候,会有个回调,在整个回调过程中,最终会回调到
com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchangeHandler 的 received 方法,看下代码:

@Override
public void received(Channel channel, Object message) throws RemotingException {
    channel.setAttribute(KEY_READ_TIMESTAMP, System.currentTimeMillis());
    ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
    try {
        if (message instanceof Request) {
            // handle request.
            Request request = (Request) message;
            if (request.isEvent()) {
                handlerEvent(channel, request);
            } else {
                if (request.isTwoWay()) {
                    Response response = handleRequest(exchangeChannel, request);
                    channel.send(response);
                } else {
                    handler.received(exchangeChannel, request.getData());
                }
            }
        } else if (message instanceof Response) {
            // 请求会回调到这里
            handleResponse(channel, (Response) message);
        } else if (message instanceof String) {
            if (isClientSide(channel)) {
                Exception e = new Exception("Dubbo client can not supported string message: " + message + " in channel: " + channel + ", url: " + channel.getUrl());
                logger.error(e.getMessage(), e);
            } else {
                String echo = handler.telnet(channel, (String) message);
                if (echo != null && echo.length() > 0) {
                    channel.send(echo);
                }
            }
        } else {
            handler.received(exchangeChannel, message);
        }
    } finally {
        HeaderExchangeChannel.removeChannelIfDisconnected(channel);
    }
}

处理响应:

static void handleResponse(Channel channel, Response response) throws RemotingException {
    // 不是心跳包,是正常的业务返回
    if (response != null && !response.isHeartbeat()) {
        DefaultFuture.received(channel, response);
    }
}

这里看到,最终调用也是 DefaultFuture.received 的方法,和超时扫描的入口一样, 最终会恢复用户请求线程。唯一有区别的就是,这里是一个ok的Response, 而那边是timeout的response.

作者:我叫董先森
文章来源:https://my.oschina.net/u/206123/blog/2051019
推荐阅读:https://www.roncoo.com/course/list.html?courseName=Dubbo

Dubbo服务注册源码分析 本代码版本基于Dubbo2.7.8版本进行源码分析 注册概览 扫描所有@DubboService注解, 加载配置文件, 装载注解中的所有属性, 把每个服务都封装成一个ServiceBean, 注入到Spring容器 容器启动之后刷新上下文时, 触发事件监听, 调用DubboBootstrap.start()方法进行dubbo服务注册与发布 拿到所有服务, 遍历注册中心, 遍历所有协议, 拼接URL 对于注册中心进行注册, 然后对于不同协议的服务进行发布 针对不同的Protocol执行export 阅读详情

相关推荐

【Zotero】《纯操作讲解,GPT配置,Zotero标注可视化》- 知识点目录

Temperature分布在。之间,越低输出越稳定;

墨门 3396

dubbo3 RPC超时

Timeout 获取超时时间 dubbo RPC 调用的超时时间在provider端或者consumer端设置都可以,consumer在调用时,会去获取超时时间,超时时间的获取顺序: consumer 引用配置的超时时间(ReferenceConfig.timeout) > provider 服务暴露的超时时间(ServiceConfig.timeout) > 默认超时时间(1000ms) 调用栈: consumer/provider 优先级顺序的逻辑在InstanceAddressURL中,

Mr_rain的专栏 2680

2.6 SST的核心性能指标体系

本文构建了固态变压器(SST)的核心性能指标体系,涵盖电气性能、可靠性、经济性和环境适配性四大类指标。电气性能指标包括运行效率(≥97%)、功率密度(≥900kVA/m³)、谐波畸变率(≤3%)等关键参数;可靠性指标设定MTBF≥43800h、年均故障率≤1.2次/年等标准;经济性指标对比分析了初始购置成本(45-55万元)和全生命周期成本(48-55万元);环境适配性指标则明确了温度、海拔等工况要求。该体系采用量化公式和国标限值,为SST的性能测试、选型和优化提供了统一标准。

技术工作者 607

RpcInvocation-dubbo源码解析

RpcInvocation-dubbo源码解析

jyyy410的博客 580

解决Windows 10安装语言包时遇到的0x800F0954错误

在安装Windows 10操作系统的语言包时,如果遇到错误代码0x800F0954的提示,这无疑会让许多用户感到困惑和无助。这个错误通常意味着在安装过程中遇到了一些阻碍,导致无法正常完成语言包的安装。本文将为大家详细解析这个错误代码0x800F0954,并提供一系列有效的解决方法,帮助大家顺利安装所需的语言包。

nntxthml的博客 3795

手把手教你用TBtools+MCScanX完成玉米基因家族共线性分析(附完整代码)

本文提供了一套完整的玉米基因家族共线性分析实战流程,详细讲解了如何从数据准备、格式处理开始,利用DIAMOND进行快速比对,再结合MCScanX进行核心共线性区块鉴定,最后通过TBtools实现从全基因组圈图到特定基因家族微共线性图的可视化。教程包含可直接运行的代码与常见问题解决方案,帮助研究者高效完成从命令行计算到图形化展示的全过程。

tech5的博客 592

Dubbo超时配置

超时机制 Dubbo是阿里开源的分布式远程调用方案(RPC),由于网络或服务端不可靠,会导致调用出现一种不确定的中间状态(超时)。为了避免超时导致客户端资源(线程)挂起耗尽,必须设置超时时间。 Provider可以配置的Consumer端主要属性有timeout、retries、loadbalance、actives和cluster。Provider上应尽量多配置些Consumer端的属性,让...

dabiaoge33的博客 1504

Lenovo 拯救者15ISK硬件升级实战:从内存到固态硬盘的全面优化

本文详细介绍了为联想拯救者15ISK笔记本电脑进行硬件升级的完整实战指南。通过评估升级可行性,指导如何挑选兼容的内存条与NVMe固态硬盘,并提供详细的拆机安装步骤与系统安装避坑技巧。升级后,笔记本的开机速度、软件加载及多任务处理能力获得飞跃式提升,让老旧设备重获新生。

weixin_29310631的博客 558

dubbo调用超时回滚_如何处理Dubbo调用超时?

原创:Java派(微信公众号:Java派),欢迎分享,转载请保留出处。前言Dubbo是阿里开源的RPC框架,因为他基于接口开发支持负载均衡、集群容错、版本控制等特性,因此现在有很多互联网公司都在使用Dubbo。本文主要解决使用超时设置以及处理进行分析,Dubbo有三个级别的超时设置分别为:针对方法设置超时时间在服务方设置超时时间在调用方设置超时时间具体设置方法可参考Dubbo的官方文档。Dubbo...

weixin_39853968的博客 989

RISC-V内核移植实战:从零开始手把手实现RT-Thread上下文切换(附GD32VF103代码解析)

本文详细解析了在RISC-V架构上移植RT-Thread实时操作系统的核心步骤,重点聚焦于上下文切换机制的实现。通过对比ARM Cortex-M与RISC-V在中断处理和寄存器管理上的关键差异,并以GD32VF103开发板为例,手把手指导开发者完成libcpu抽象层适配、线程栈初始化以及三种上下文切换方式的代码编写与调试,为嵌入式开发者从ARM转向RISC-V平台提供了实战指南。

fern8的博客 740

洛达开发--AB1585 PC 工具介绍

洛达常用的PC开发工具包括三款:1)IOT_Flash_Tool是固件烧写工具,支持USB/UART接口下载,需通过断电重启完成烧录;2)EPT是图形化PinMux配置工具,适用于MT25x3/MT768x等芯片的引脚复用设置;3)ATK是综合开发套件,包含日志工具、配置工具、OTA工具和实验室测试工具等组件。这三款工具分别针对固件烧录、硬件配置和系统调试等不同开发环节,形成完整的开发工具链。

Joon2020的博客 672

doubb超时_dubbo 超时设置和源码分析

在工作中碰到一个业务接口时间比较长,需要修改超时时间,不知道原理,在网上搜索,看到有人说如果你觉得自己了解了dubbo的超时机制,那么问问自己以下问题:超时是针对消费端还是服务端?超时在哪设置?超时设置的优先级是什么?超时的实现原理是什么?超时解决的是什么问题 ?如果连这些都回答不上了,那只能说明还没有完全掌握 dubbo的超时机制。于是索性就自己本地搭了个环境,研究了一下源码。 先来说一说结论:...

weixin_39805720的博客 375

【GlobalMapper精品教程】027:路径剖面和和视线工具的使用

路径剖面视线工具允许您使用加载的高程数据集沿用户指定的路径获取垂直剖面。要定义生成3D路径剖面所遵循的路径,只需单击鼠标左键选择路径的点,然后石键单击以结束路径。出现一个带有剖面的对话框,允许您设置视线分析或优化端点。

智慧空间实验室 2053

【DUBBO】dubbo超时处理机制浅析

我们从源码的角度上介绍了Dubbo的超时处理机制,感兴趣可以自己追踪调用链路。对于Dubbo中的超时设置,可以在服务端、消费端,官方建议是设置在服务端,客户端做特殊处理即可,原因是服务端更清楚接口的性能情况。不过实际情况是,它仅将该参数传导到客户端,然后由客户端来控制。

qq_40023049的博客 3085

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

Dubbo源码分析:全集整理

文章目录一、前言二、目录1. 源码篇2. 衍生篇 一、前言 本文是Dubbo源码分析目录集整理,方便后续查找。 本文持续更新中。 二、目录 1. 源码篇 2. 衍生篇

猫吻鱼的博客 4903

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Dubbo超时

1、概念  1)服务提供者超时是指远程调用服务的方法执行的超时时间.  2)服务调用者超时是指服务调用者调用远程方法的执行超时时间. 2、超时设置   使用dubbo进行远程调用的过程中,需要设置远程调用的超时间.超时时间分别可以在服务的提供者配置中设置,也可以在服务调用者配置中设置,超时时间的单位是毫秒.   1)全局超时配置 &lt;dubbo:consumer timeout="...

今非昨的专栏 4576

dubbo源码分析之八-dubbo的spi机制

本片博文以spi机制为切入点,首先了解spi机制,介绍了java自己的SPI实现方式和源码分析,并通过其缺点引出了Dubbo的SPI机制,通过对其使用示例、流程、源码分析等详细分析了其相关流程,其中对ExtensionLoader、@Adaptive,@Activate,@SPI注解进行使用介绍。希望这边文章能让读者很好的了解java SPI和Dubbo的SPI机制。

liushangzaibeijing的博客 5万+

【Dubbo源码分析】Dubbo SPI

1、简介 SPI 全称为 Service Provider Interface,是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中,并由服务加载器读取配置文件,加载实现类。这样可以在运行时,动态为接口替换实现类。正因此特性,我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用,比如 Dubbo 就是通过 SPI 机制加载所有的组件。...

通往神秘的道路的专栏 2780

dubbo xml配置解析入口源码分析

首先,dubbo是依赖于spring进行配置的,那么,配置dubbo的其中一种方式就是通过spring的applicationContext.xml文件。不过问题是,spring容器启动时,一般只会解析applicationContext.xml中spring自己认识的元素,如bean元素,并将其注册为beanDefinition,那么spring是如何识别dubbo元素的呢?如dubbo:service。

学无止境! 1458

apache dubbo核心源码分析

dubbo版本:2.7.5 dubbo源码下载地址 自适应扩展点: 指定名称扩展点: 激活扩展点: Java spi实现 Service Provider Interface jdk内置的一种服务提供发现机制 作用:服务的扩展实现 例如:数据库连接 jdk提供了java.sql.Driver接口 这个驱动类在jdk中没有实现,由不同数据库厂商实现 约定: 所有扩展点必须放在resources/META-INF/services目录下 SPI机制会扫描这个路径下的属性文件以完成加载没有使用JDK内置的SPI机

bennettzhou404的博客 1092

【Dubbo源码分析】注解配置原理

1、配置Dubbo 1.1、使用API 配置 服务提供者 import org.apache.dubbo.rpc.config.ApplicationConfig; import org.apache.dubbo.rpc.config.RegistryConfig; import org.apache.dubbo.rpc.config.ProviderConfig; import org....

通往神秘的道路的专栏 4431

Dubbo源码分析

什么是Dubbo? Dubbo一开始是由阿里巴巴开发,后面贡献给了Apache,所以后面我们称之为Apache Dubbo或者直接叫Dubbo。 Dubbo 是一款高性能、轻量级的开源服务框架 。 先纠正读法: 错误读法:diubo、dubo 正确读法:|ˈdʌbəʊ| Dubbo的六大核心能力 面向接口代理的高性能RPC调用 智能容错和负载均衡 服务自动注册和发现 高度可扩展能力 运行期流量调度 可视化的服务治理与运维。 开发中,我们都喜欢把Dubbo简称为RPC开源框架。 什么是R

qfzhaohan的博客 3128

源码分析Dubbo系列文章

本系列文章主要针对Dubbo2.6.2(dubbox2.8.4)版本,从源码的角度分析Dubbo内部的实现细节,加深对Dubbo的各配置参数底层实现原理的理解,更好的指导Dubbo实践,其目录如下: 1、源码分析Dubbo前置篇-寻找注册中心、服务提供者、服务消费者功能入口 2、源码分析Dubbo服务提供者启动流程-上篇 3、源码分析Dubbo服务提供者启动流程-下篇 4、源码分析Dubb...

中间件兴趣圈 2万+
上一篇: java 区块链中设计合理的难度系数
下一篇: 分布式锁与实现--基于ZooKeeper实现
java_66666
博客等级 码龄10年 339粉丝 42原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值