dubbo源码学习（五）dubbo暴露服务的过程

最新推荐文章于 2024-09-26 19:41:48 发布
最新推荐文章于 2024-09-26 19:41:48 发布
阅读量2w 收藏 20
点赞数 7
分类专栏： dubbo源码学习 文章标签： dubbo 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jycwl/article/details/51481914
版权

初学dubbo的源码，只做尝试性的去学习，做为自己学习的一个记录，各位看官如果觉得写的有错误或理解的不对，请在留言区告诉我，互相学习。本人能力有限，有大神进入 时请指点。

dubbo采用的nio异步的通信，通信协议默认为 netty,当然也可以选择 mina,grizzy。在服务端（provider）在启动时主要是开启netty监听，在zookeeper上注册服务节点，处理消费者请求，返回处理后的消息给消费者，消费者使用服务时主要是订阅服务的节点，监听zookeeper节点目录，服务端的变化时zookeeper会推送给消费者，消费者重新缓存服务地址等。服务者、消费者、zookeeper三者之间都是长连接。

下面看dubbo源码来看服务暴露的过程，服务暴露的入口为：com.alibaba.dubbo.config.ServiceConfig#export 方法，代码如下：

//是否延时暴露
        if (delay != null && delay > 0) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(delay);
                    } catch (Throwable e) {
                    }
                    doExport();
                }
            });
            thread.setDaemon(true);
            thread.setName("DelayExportServiceThread");
            thread.start();
        } else {
            //不延时暴露，则直接暴露
            doExport();
        }
上在代码无论是延时暴露或直接暴露调用的方法是：doExport（）,doExport会对解析完的配置再做一次检查，核心代码大家可以查看dubbo的源码，下面列出一小部分 

/*
            检查默认设置,如果xml中没有配置<dubbo:provider
            主要是从系统环境变量中寻找是否有相应的provider的配置
         */
        checkDefault();
        //下面设置的内容如果没有配置<dubbo:provider时基本上都是Null
        if (provider != null) {
            if (application == null) {
                application = provider.getApplication();
            }
            if (module == null) {
                module = provider.getModule();
            }
            if (registries == null) {
                registries = provider.getRegistries();
            }
            if (monitor == null) {
                monitor = provider.getMonitor();
            }
            if (protocols == null) {
                protocols = provider.getProtocols();
            }
        }
        if (module != null) {
            //registries一般都会配置
            if (registries == null) {
                registries = module.getRegistries();
            }
            if (monitor == null) {
                monitor = module.getMonitor();
            }
        }
        if (application != null) {
            //application一般也会配置
            if (registries == null) {
                registries = application.getRegistries();
            }
            if (monitor == null) {
                monitor = application.getMonitor();
            }
        }
        //是否泛化调用
        if (ref instanceof GenericService) {
            interfaceClass = GenericService.class;
            if (StringUtils.isEmpty(generic)) {
                generic = Boolean.TRUE.toString();
            }
        } else {
            try {
                interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
                        .getContextClassLoader());
            } catch (ClassNotFoundException e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
            /*
                检查即将暴露的接口的方法配置,检查方法是否在接口中存在
                一般不会配置所以一般情况下methods为null
                <dubbo:service  > <dubbo:method /> </dubbo:serivce>
             */
            checkInterfaceAndMethods(interfaceClass, methods);
            /*
                检查接口的引用不为空,并且必须实现的是要暴露的接口
             */
            checkRef();
            generic = Boolean.FALSE.toString();
        }

所有的检查通过之后，会调用 ：com.alibaba.dubbo.config.ServiceConfig#doExportUrls 方法，因为dubbo支持多通信协议时，都进行暴露，所以在代码中可以看到 

/*
            将注册协议转化成url
            registry://45.119.68.23:2181/com.alibaba.dubbo.registry.RegistryService?
            application=test-dubbo&dubbo=2.5.3&pid=7648&registry=zookeeper×tamp=1462349748801
         */
        List<URL> registryURLs = loadRegistries(true);
        //配置多通信协议时，都进行暴露
        for (ProtocolConfig protocolConfig : protocols) {
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
doExportUrlsFor1Protocol中主要将所有的配置转化成map，然后将map转化成dubbo的统一URL，最终暴露的dubbo服务也就是这个统一的url，这个url也会注册到zookeeper的节点上，部分代码如下： 

/*
	将不为null的配置对象中的属性设置到 map 中
	即将 xml 配置文件中的配置设置的值全转化成为map
	{side=provider, application=alijk-dubbo, accepts=1000,
		dubbo=2.5.3, threads=100, pid=7236, interface=cn.eoncloud.account.sdk.export.AccountService,
		threadpool=fixed, version=1.0.0, timeout=500, anyhost=true, timestamp=1462347843960}
 */
appendParameters(map, application);
appendParameters(map, module);
appendParameters(map, provider, Constants.DEFAULT_KEY);
appendParameters(map, protocolConfig);
appendParameters(map, this);
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
/*
	将配置信息转化成 url ,主要根据之前map里的数据组装成url
	调用 URL#buildString方法
	dubbo://10.6.13.137:9998/cn.eoncloud.account.sdk.export.AccountService
	?accepts=1000&anyhost=true&application=test-dubbo&dubbo=2.5.3
	&interface=cn.eoncloud.account.sdk.export.AccountService
	&methods=getAccountName,getAllTest&pid=7236&revision=1.0.0&side=provider
	&threadpool=fixed&threads=100&timeout=500×tamp=1462347843960&version=1.0.0
 */
URL url = new URL(name, host, port, (contextPath == null || contextPath.length() == 0 ? "" : contextPath + "/") + path, map);

if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
		.hasExtension(url.getProtocol())) {
	url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
			.getExtension(url.getProtocol()).getConfigurator(url).configure(url);
}
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
//com.alibaba.dubbo.registry.integration.RegistryProtocol#export 即将进行暴露
Exporter<?> exporter = protocol.export(invoker);

上面的代码核心暴露的一行代码为：protocol.export(invoker); 这个protocol的值为：RegistryProtocol，也就是暴露会跳到：RegistryProtocol.exprot中去处理，RegistryProtocol.exprot主要做两件事情：1、开启netty服务端  。2、创建zookeeper服务节点。下面来看RegistryProtocol.export 方法，代码如下： 

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
        //export invoker doLocalExport调用dubboProtocol.export开启netty服务监听
        final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
        //registry provider
        final Registry registry = getRegistry(originInvoker);
        final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
        //调用zodoRegister的doRegister 创建zookeeper的服务节点
        registry.register(registedProviderUrl);
        // 订阅override数据
        // FIXME 提供者订阅时，会影响同一JVM即暴露服务，又引用同一服务的的场景，因为subscribed以服务名为缓存的key，导致订阅信息覆盖。
        final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
        final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
        overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
        //订阅
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
        //保证每次export都返回一个新的exporter实例
        return new Exporter<T>() {
            public Invoker<T> getInvoker() {
                return exporter.getInvoker();
            }
            public void unexport() {
            	try {
            		exporter.unexport();
            	} catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
                try {
                	registry.unregister(registedProviderUrl);
                } catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
                try {
                	overrideListeners.remove(overrideSubscribeUrl);
                	registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
                } catch (Throwable t) {
                	logger.warn(t.getMessage(), t);
                }
            }
        };
    }
上面的代码里有一段特别重要，关键性的代码在doLocalExport中： 

final Invoker<?> invokerDelegete = new InvokerDelegete<T>(originInvoker, getProviderUrl(originInvoker));
//此处protol为dubboProtocol
exporter = new ExporterChangeableWrapper<T>((Exporter<T>)protocol.export(invokerDelegete), originInvoker);
从上面的代码中可以看到会调用dubboProtocol的export对服务进行暴露，这个export最终目的就是开启netty的监听，下面来看dubbo是如何一步一步开启netty的 

 private void openServer(URL url) {
        // find server. ip:port
        String key = url.getAddress();
        //client 也可以暴露一个只有server可以调用的服务。
        boolean isServer = url.getParameter(Constants.IS_SERVER_KEY,true);
        if (isServer) {
        	ExchangeServer server = serverMap.get(key);
        	if (server == null) {
                //创建 Server
        		serverMap.put(key, createServer(url));
        	} else {
        		//server支持reset,配合override功能使用
        		server.reset(url);
        	}
        }
    }
    
    private ExchangeServer createServer(URL url) {
        //默认开启server关闭时发送readonly事件
        url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());
        //默认开启heartbeat
        url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
        //默认使用netty
        String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);

        if (str != null && str.length() > 0 && ! ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str))
            throw new RpcException("Unsupported server type: " + str + ", url: " + url);
        //默认使用dubbo协议编码
        url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);
        ExchangeServer server;
        try {
            //HeaderExchangeServer 在此处已经开启了Netty Server 进行监听
            server = Exchangers.bind(url, requestHandler);
        } catch (RemotingException e) {
            throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
        }
        str = url.getParameter(Constants.CLIENT_KEY);
        if (str != null && str.length() > 0) {
            Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
            if (!supportedTypes.contains(str)) {
                throw new RpcException("Unsupported client type: " + str);
            }
        }
        return server;
    }
在上面的代码中：Exchangers.bind(url, requestHandler)  默认为：HeaderExchanger.bind() 

public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
        //Transporters默认为NettyTransporter
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }
代码运行到这里可以看到传输方式了，dubbo默认采用的通信方式为 NettyTransporter ，再来看NettyTransporter.bind方法 

public static final String NAME = "netty";
    
    public Server bind(URL url, ChannelHandler listener) throws RemotingException {
        return new NettyServer(url, listener);
    }

已经能看到NettyServer了，dubbo在暴露服务最终开启的netty服务监听，监听消费者发送的请求，通过反射调用方法得到结果通过 tcp/ip 网络传输返回给消费者。再进入到NettyServer中我们就能看到非常传统的开启Netty服务的代码了 

protected void doOpen() throws Throwable {
        NettyHelper.setNettyLoggerFactory();
        ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
        ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
        //最后一个参数为 NIO 最大工作线程数
        ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
        //netty server 启动器
        bootstrap = new ServerBootstrap(channelFactory);
        
        final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
        channels = nettyHandler.getChannels();
        // https://issues.jboss.org/browse/NETTY-365
        // https://issues.jboss.org/browse/NETTY-379
        // final Timer timer = new HashedWheelTimer(new NamedThreadFactory("NettyIdleTimer", true));
        bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            public ChannelPipeline getPipeline() {
                NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec() ,getUrl(), NettyServer.this);
                ChannelPipeline pipeline = Channels.pipeline();
                /*int idleTimeout = getIdleTimeout();
                if (idleTimeout > 10000) {
                    pipeline.addLast("timer", new IdleStateHandler(timer, idleTimeout / 1000, 0, 0));
                }*/
                pipeline.addLast("decoder", adapter.getDecoder());
                pipeline.addLast("encoder", adapter.getEncoder());
                pipeline.addLast("handler", nettyHandler);
                return pipeline;
            }
        });
        // 创建一个绑定到指定地址的新通道，也就是绑定IP、端口供客户端连接
        channel = bootstrap.bind(getBindAddress());
    }
上面的代码执行完成后，netty的服务端就已经开启了，可以接收客户端的连接了，但客户端连接上来要怎么处理呢？消息接收、发送怎么处理呢？所有的处理都在上面代码的 NettyHandler类中，Nettyhandler继承了Netty包中的的SimpleChannelHandler 

NettyHandler extends SimpleChannelHandler
重写了 channelConnected、channelDisconnected、messageReceived等方法，而我们比较关注的可能是messagereceived方法，在收到消息时如何处理，但今天暂时先不看dubbo如果处理消息，只看暴露，消息处理如何实现异步通信下一节再讲。 

/**
     * 收到消息时触发
     * @param ctx
     * @param e
     * @throws Exception
     */
    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        NettyChannel channel = NettyChannel.getOrAddChannel(ctx.getChannel(), url, handler);
        try {
            handler.received(channel, e.getMessage());
        } finally {
            NettyChannel.removeChannelIfDisconnected(ctx.getChannel());
        }
    }
从前面知道,开启netty服务是在RegistryProtocol.export 的 doLocalExport 中，在开启了netty服务后，就是在zookeeper上注册服务节点了，消费者在消费服务时会根据消费的接口名找到对应的zookeeper节点目录，对目录进行监听，接收推送 

//registry provider
final Registry registry = getRegistry(originInvoker);
final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
//调用zodoRegister的doRegister 创建zookeeper的服务节点
registry.register(registedProviderUrl);
// 订阅override数据
// FIXME 提供者订阅时，会影响同一JVM即暴露服务，又引用同一服务的的场景，因为subscribed以服务名为缓存的key，导致订阅信息覆盖。
final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
//订阅
registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);

dubbo服务在zookeeper上的节点注册是：com.alibaba.dubbo.registry.support.FailbackRegistry#register

@Override
    public void register(URL url) {
        super.register(url);
        failedRegistered.remove(url);
        failedUnregistered.remove(url);
        try {
            // 向服务器端发送注册请求
            doRegister(url);
因为doRegister是一个抽象的方法，查看他的实现可以看到如下图：



从上图可以看到doRegister实现有 dubbo、redis、zookeeper，这也是在我们配置时经常看到的 注册协议的配置 ，最为常用的就是 zookeeper了，所以再看ZookeeperRegistry的代码，看他的doRegistry干什么了如下

 protected void doRegister(URL url) {
        try {
        	zkClient.create(toUrlPath(url), url.getParameter(Constants.DYNAMIC_KEY, true));
        } catch (Throwable e) {
            throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }
其实从上面已经可以看到 在zookeeper上面创建 节点了，默认不分组的情况下，服务结构如下：/dubbo/XXXXservice/consumers、providers

至此，dubbo的暴露基本上已经完成，开启了netty服务，注册了zookeeper的节点，就等着消费者连接上来使用了。下一节将介绍dubbo的消息发送和接收，NIO异步通讯的实现。


车文亮
关注
专栏目录
Dubbo服务暴露源码分析
liuffei的专栏
11-13 1061
Dubbo会将每个需要暴露的服务解析为ServiceBean对象。 ServiceBean实现了ApplicationListener接口，对ContextRefreshedEvent进行监听。当Spring容器启动发布ContextRefreshedEvent，会调用export方法。 public void onApplicationEvent(ContextRefreshedEvent event) { if (!isExported() && !isUnexported())
【Java教程】dubbo源码解析-服务暴露与发现
Blue92120的博客
09-26 605
1、Invoker 是实体域，它是 Dubbo 的核心模型，其它模型都向它靠扰，或转换成它，它代表一个可执行体，可向它发起 invoke 调用，它有可能是一个本地的实现，也可能是一个远程的实现，也可能一个集群实现。此方法代码很长，主要完成的配置加载，检查，以及创建引用的代理对象。Dubbo是运行在spring容器中，dubbo的配置文件也是通过spring的配置文件applicationContext.xml来加载，所以dubbo的自定义配置标签实现，其实同样依赖spring的xml schema机制。
手把手带你阅读dubbo源码(一) 服务暴露
热门推荐
u012117723的专栏
06-19 4万+
本篇文章主要是阅读了dubbo官方文档:http://dubbo.apache.org/zh-cn/docs/user/quick-start.html关于服务的暴露和引用，感觉很多细节还不是十分清楚，所以决定从自己手上的项目看起，然后一步步探究其中的实现，顺便记录下这个过程中学到的其他知识，由于dubbo是一个很成熟的框架了，用到的技术也很多，里面定义了很多类和接口十分复杂，所以我一步步去分析篇...
dubbo原理，如何实现服务调用
最新发布
weixin_39304656的博客
09-26 790
Dubbo 的服务调用原理基于模型，通过动态代理、网络通信、负载均衡、容错机制等实现了分布式服务之间的透明调用。其核心过程包括服务的注册与发现、服务的远程调用以及服务结果的返回。动态代理：Dubbo 使用动态代理技术将本地方法调用转换为远程调用。服务注册与发现：通过注册中心管理服务的注册与发现。负载均衡与容错：Dubbo 提供多种负载均衡和容错策略，确保服务调用的高可用性。网络通信：基于 Netty 的高效网络通信框架，支持多种协议和序列化方式。
dubbo源码分析7 之 服务本地暴露
carl.zhao的专栏
02-01 3462
在上一篇文章我们分析了一下 dubbo 在服务暴露发生了哪些事，今天我们就来分析一下整个服务暴露中的本地暴露。(PS:其实我感觉本地暴露蛮鸡肋的)。本地暴露需要服务提供方与服务消费方在同一个 JVM。下面我们来写一个本地暴露使用的例子： 1) DemoService.java public interface DemoService { String sayHello(S
Dubbo暴露服务源码解析
02-04 691
Dubbo服务提供方的JavaBean对应的就是ServiceBean。ServiceBean除了继承dubbo自己的配置抽象类以外，还实现了一系列的spring接口用来参与到spring容器的启动以及bean的创建过程中去。 由于ServiceBean是单例模式的，在Spring的容器启动过程中会预先初始化。最后finishRefresh会触发ContextRefreshedEvent事件
dubbo服务暴露过程源码分析
weixin_34066347的博客
03-07 284
2019独角兽企业重金招聘Python工程师标准>>> ...
dubbo源码分析系列
04-06
《Dubbo源码分析系列》是一份深入探讨Java开源...通过对《Dubbo源码分析系列》的学习，开发者不仅可以掌握Dubbo的基本使用，还能深入理解其设计思想，从而更好地在实际项目中应用和优化Dubbo，提高系统的稳定性和效率。
dubbo入门学习框架源码
01-21
通过深入学习和实践Dubbo源码，开发者不仅可以更好地理解Dubbo的工作原理，还能在实际项目中灵活运用，解决各种复杂的分布式服务问题。Dubbo的源码阅读也是一个不断提升自身技术深度的过程，有助于成长为更优秀的...
DUBBO源码学习（三）v2.7.8-服务的暴露过程
lisyee的博客
08-30 795
文章目录dubbo源码学习历史文章一、DUBBO服务暴露1.1、DUBBO容器的启动二、serviceConfig服务暴露2.1、dubbo服务配置初始化2.2、checkAndUpdateSubConfigs()2.3、doExport -> doExportUrls服务暴露2.4、doExportUrlsFor1Protocol根据不同协议暴露服务2.5、获取invoker2.6、远程服务暴露 dubbo源码学习历史文章 DUBBO源码学习（一）spi机制 DUBBO源码学习（二）注册中心源码解析
dubbo源码解析2
05-14
4. **Java RPC机制**：理解RPC（远程过程调用）的概念是学习Dubbo的关键之一。可以先从RMI、Hessian、Thrift等RPC框架入手，了解它们的工作原理及其与Dubbo之间的联系。 5. **Java其他内容**：除了以上提及的知识点...
dubbo入门源代码
06-29
apache dubbo官网最简单的小例子，只是按照说明弄了下。
dubbo的服务调用过程
11-28 528
服务消费的过程：referenceConfig类的init方法调用Protocol的refer方法，生成invoker实例，然后把Invoker转换为客户端需要的接口。 2、源码解析 dubbo的消费端初始化在ReferenceConfig的get()方法 public synchronized T get() { if (destroyed){ thro...
Dubbo——服务调用过程
夜勿语的博客
09-07 784
文章目录引言服务的交互服务降级集群容错服务调用服务端接收请求总结 引言 经过之前文章的铺垫，现在可以来分析服务的交互调用过程了。 服务的交互 服务降级 从名字上看我们不难理解MockClusterInvoker相当于是对普通Invoker（如DubboInvoker）的装饰增强，提供集群容错相关的功能，因此最终还是会进入到DubboInvoker，所以这里就以MockClusterInvoker....
Dubbo源码阅读——服务暴露
yozzs的博客
11-29 1188
Dubbo框架使用方式一般是分为两类应用（application）：服务提供者（我把它成为p端应用）和服务消费者（c端应用），他们的联系可以是直连，也可以是通过注册中心做服务治理。每个application可以包含多支服务或多个引用。本文通过阅读源码理清服务暴露的全过程。
Dubbo之服务暴露
YANGTAO_0的博客
03-02 529
前言本文 Dubbo 使用版本 2.7.5Dubbo 通过使用 dubbo:service配置或 @service在解析完配置后进行服务暴露，供服务消费者消费。Dubbo 的服务暴露有两...
dubbo系列第四篇【服务暴露过程源码详解】
乐乐的博客
05-14 432
dubbo服务暴露过程 入口：org.apache.dubbo.config.spring.ServiceBean#onApplicationEvent // 当Spring容器刷新时会触发其执行 @Override public void onApplicationEvent(ContextRefreshedEvent event) { // 若当前service尚未发布，也没有取消发布，则进行发布 if (!isExported() && !isUnexported()
PHP trait特性
Martian
10-30 234
trait 特点、特征、特性 1 为什么要trait 解决单继承和代码复用问题 2 怎么使用 trait不能实例化，只需在类中使用use + trait名称，多个用逗号隔开 trait T{ public function f(){ echo "T"; } } class C{ use T; } $c = new C(); $c->f(); 3 属性与方法 trait属性和类属性不能重复 多个trait的方法可以相同，只是在使用时需要insteadof或者
dubbo 远程服务调用流程
金溪的博客
07-03 2754
消费端触发请求。 消费端请求编码。 提供端请求解码。 提供端处理请求。 提供端响应结果编码。 消费端响应结果解码。 消费端触发请求 在消费者初始化的时候，会生成一个消费者代理注册到容器中，该代理回调中持有一个MockClusterInvoker实例，消费调用服务接口时它的invoke会被调用，此时会构建一个RpcInvocation对象，把服务接口的method对象和参数放到RpcIn...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值