Dubbo笔记（一）

最新推荐文章于 2022-03-03 00:00:00 发布
最新推荐文章于 2022-03-03 00:00:00 发布
阅读量106 收藏
点赞数
文章标签： java
原文链接：https://juejin.im/post/5cd12885e51d453b5854b880
版权

Dubbo源码 从API方式配置开始

/**
 * 使用api的方式配置dubbo
 * ApiProviderConfiguration
 */
public class ApiProviderConfiguration {
	
	public static void main(String[] args) throws Exception {
		// 服务实现
		OrderService orderService = new OrderServiceImpl();

		// 当前应用配置。 请学习ApplicationConfig的API
		ApplicationConfig application = new ApplicationConfig();
		application.setName("hello-world-app");
		Map<String, String> appParameters = new HashMap<String, String>();
		appParameters.put("qos.enable", "false");
		application.setParameters(appParameters);

		// 连接注册中心配置。 请学习RegistryConfig的API
		RegistryConfig registry = new RegistryConfig("224.5.6.7:1234", "multicast");
		//registry.setDynamic(true);  // 动态注册，服务出现问题自动处理

		// 服务提供者协议配置
		ProtocolConfig protocol = new ProtocolConfig();
		protocol.setName("dubbo");
		protocol.setPort(12345);
		protocol.setThreads(200);

		// 注意：ServiceConfig为重对象，内部封装了与注册中心的连接，以及开启服务端口
		// 服务提供者暴露服务配置。请学习ServiceConfig的API
		// 此实例很重，封装了与注册中心的连接，请自行缓存，否则可能造成内存和连接泄漏
		ServiceConfig<OrderService> service = new ServiceConfig<OrderService>();
		service.setApplication(application);
		service.setRegistry(registry); // 多个注册中心可以用setRegistries()
		service.setProtocol(protocol); // 多个协议可以用setProtocols()
		service.setInterface(OrderService.class);
		service.setRef(orderService);
		service.setVersion("1.0.0");

		// 暴露及注册服务
		service.export(); //入口

		System.in.read(); // 按任意键退出
	}
}
复制代码

暴露服务，检查一些配置是不是为空

检查参数的 

protected synchronized void doExport() {
        if (this.unexported) {
            throw new IllegalStateException("Already unexported!");
        } else if (!this.exported) {
            this.exported = true;
            if (this.interfaceName != null && this.interfaceName.length() != 0) {
                this.checkDefault();
                if (this.provider != null) {
                    if (this.application == null) {
                        this.application = this.provider.getApplication();
                    }

                    if (this.module == null) {
                        this.module = this.provider.getModule();
                    }

                    if (this.registries == null) {
                        this.registries = this.provider.getRegistries();
                    }

                    if (this.monitor == null) {
                        this.monitor = this.provider.getMonitor();
                    }

                    if (this.protocols == null) {
                        this.protocols = this.provider.getProtocols();
                    }
                }

                if (this.module != null) {
                    if (this.registries == null) {
                        this.registries = this.module.getRegistries();
                    }

                    if (this.monitor == null) {
                        this.monitor = this.module.getMonitor();
                    }
                }

                if (this.application != null) {
                    if (this.registries == null) {
                        this.registries = this.application.getRegistries();
                    }

                    if (this.monitor == null) {
                        this.monitor = this.application.getMonitor();
                    }
                }

                if (this.ref instanceof GenericService) {
                    this.interfaceClass = GenericService.class;
                    if (StringUtils.isEmpty(this.generic)) {
                        this.generic = Boolean.TRUE.toString();
                    }
                } else {
                    try {
                        this.interfaceClass = Class.forName(this.interfaceName, true, Thread.currentThread().getContextClassLoader());
                    } catch (ClassNotFoundException var5) {
                        throw new IllegalStateException(var5.getMessage(), var5);
                    }

                    this.checkInterfaceAndMethods(this.interfaceClass, this.methods);
                    this.checkRef();
                    this.generic = Boolean.FALSE.toString();
                }

                Class stubClass;
                if (this.local != null) {
                    if ("true".equals(this.local)) {
                        this.local = this.interfaceName + "Local";
                    }

                    try {
                        stubClass = ClassHelper.forNameWithThreadContextClassLoader(this.local);
                    } catch (ClassNotFoundException var4) {
                        throw new IllegalStateException(var4.getMessage(), var4);
                    }

                    if (!this.interfaceClass.isAssignableFrom(stubClass)) {
                        throw new IllegalStateException("The local implementation class " + stubClass.getName() + " not implement interface " + this.interfaceName);
                    }
                }

                if (this.stub != null) {
                    if ("true".equals(this.stub)) {
                        this.stub = this.interfaceName + "Stub";
                    }

                    try {
                        stubClass = ClassHelper.forNameWithThreadContextClassLoader(this.stub);
                    } catch (ClassNotFoundException var3) {
                        throw new IllegalStateException(var3.getMessage(), var3);
                    }

                    if (!this.interfaceClass.isAssignableFrom(stubClass)) {
                        throw new IllegalStateException("The stub implementation class " + stubClass.getName() + " not implement interface " + this.interfaceName);
                    }
                }

                this.checkApplication();
                this.checkRegistry();
                this.checkProtocol();
                appendProperties(this);
                this.checkStub(this.interfaceClass);
                this.checkMock(this.interfaceClass);
                if (this.path == null || this.path.length() == 0) {
                    this.path = this.interfaceName;
                }

                this.doExportUrls();//在到这里
                ProviderModel providerModel = new ProviderModel(this.getUniqueServiceName(), this, this.ref);
                ApplicationModel.initProviderModel(this.getUniqueServiceName(), providerModel);
            } else {
                throw new IllegalStateException("<dubbo:service interface=\"\" /> interface not allow null!");
            }
        }
    }
复制代码

在循环中,url协议头部改成registry，将注册中心作为参数放到后面。url就变成下面这样。

以上方法就是做了一个协议头的转换。因为Dubbo中URL是一个非常重要的契约，所有扩展点都要遵守。所有扩展点的参数都包含URL参数，URL作为上下文信息贯穿整个扩展点设计体系。URL采用标准格式：protocol：//username:passward@host:port/path?key=value&key=value.

进入这个方法
往下看暴露服务的map信息

开始注册

代理工厂。关键地方，给了3个参数，ref(接口的具体实现)，（Class）interfaceClass ，注册中心的url 

Invoker<?> invoker = proxyFactory.getInvoker(this.ref, this.interfaceClass, registryURL.addParameterAndEncoded("export", url.toFullString()));
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
Exporter<?> exporter =protocol.export(wrapperInvoker);
this.exporters.add(exporter);
复制代码

看下ProxyFactory的getExtensionLoader扩展加载器都私有化了。getAdaptiveExtension属于自适应扩展

private static final ProxyFactory proxyFactory = (ProxyFactory)ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();
复制代码

SPI ExtensionLoader 扩展点加载器？做了什么？怎么做到自适应？

进到ProxyFactory接口中

配置信息

Invoker和Exporter

Invoker是实体域，Dubbo的核心模型，其他模型都向它靠拢或转换成它，它代表一个可以执行体。可以将所有需要代理的方法，用Invoker进行抽象，转换。

API与SPI

Dubbo框架有两类用户，框架使用者和扩展开发者。为对两类用户进行隔离，使用者通过API，开发者使用SPI。使用者无需从编码层面知道扩展的类型，只需配置即可；扩展着也能很方便的扩展功能，不需要考虑适应不同的编码场景。Dubbo没有采用JDK的SPI，而是自己实现了一套。

进入ExtensionLoader类

类似SpringIOC

通过class反射类来构造class对象实例，injectExtension方法通过setter注入扩展类中的依赖的其他扩展点。包装类Wrapper,封装了通用的逻辑，通过有无当前扩展参数构造函数来判断，并注入依赖扩展。

在crateExtension方法中的

Set<Class<?>> wrapperClasses = this.cachedWrapperClasses;
                Class wrapperClass;
                if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
                    for(Iterator i$ = wrapperClasses.iterator(); i$.hasNext(); instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance))) {
                        wrapperClass = (Class)i$.next();
                    }
                }

                return instance;
复制代码

重要 动态生成代码（类）createAdaptiveExtensionClassCode 只会在方法上起作用 具体生成的类。扩展点的类必须有@SPI类注解和@Adaptive方法注解才会动态生成代码。 

import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class ProxyFactory$Adaptive implements com.alibaba.dubbo.rpc.ProxyFactory {
public com.alibaba.dubbo.rpc.Invoker getInvoker(java.lang.Object arg0, java.lang.Class arg1, com.alibaba.dubbo.common.URL arg2) throws com.alibaba.dubbo.rpc.RpcException {
if (arg2 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg2;
String extName = url.getParameter("proxy", "javassist");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.ProxyFactory) name from url(" + url.toString() + ") use keys([proxy])");
com.alibaba.dubbo.rpc.ProxyFactory extension = (com.alibaba.dubbo.rpc.ProxyFactory)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.ProxyFactory.class).getExtension(extName);
return extension.getInvoker(arg0, arg1, arg2);
}
public java.lang.Object getProxy(com.alibaba.dubbo.rpc.Invoker arg0, boolean arg1) throws com.alibaba.dubbo.rpc.RpcException {
if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
if (arg0.getUrl() == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");com.alibaba.dubbo.common.URL url = arg0.getUrl();
String extName = url.getParameter("proxy", "javassist");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.ProxyFactory) name from url(" + url.toString() + ") use keys([proxy])");
com.alibaba.dubbo.rpc.ProxyFactory extension = (com.alibaba.dubbo.rpc.ProxyFactory)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.ProxyFactory.class).getExtension(extName);
return extension.getProxy(arg0, arg1);
}
public java.lang.Object getProxy(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {
if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
if (arg0.getUrl() == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");com.alibaba.dubbo.common.URL url = arg0.getUrl();
String extName = url.getParameter("proxy", "javassist");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.ProxyFactory) name from url(" + url.toString() + ") use keys([proxy])");
com.alibaba.dubbo.rpc.ProxyFactory extension = (com.alibaba.dubbo.rpc.ProxyFactory)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.ProxyFactory.class).getExtension(extName);
return extension.getProxy(arg0);
}
}
复制代码

生成类的class

再来看看扩展点的包装类

powerx_yc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
dubbo笔记——项目实战
02-24
然后启动，在bin目录下：位置我放在根目录下dubbo/dubbo-server.xml，内容如下：在控制台中将会看到如下内容：可以看到，已经将UserService服务注册到zookeeper注册中心，协议采用的是dubbo。从b系统中拷贝User对象...
启动dubbo服务时报错 ＜dubbo:service interface=““ /＞ interface not allow null!
沉睡的猫的博客
11-29 557
启动dubbo服务报错， Initialization of bean failed; nested exception is java.lang.IllegalStateException: interface not allow null!
dubbo源码分析-服务导出
weixin_44195108的博客
02-20 235
简介 dubbo框架spring Schema扩展机制与Spring集成，在spring初始化时候加载dubbo的配置类。 dubbo服务导出的入口类是ServiceBean的onApplicationEvent方法 ServiceBean的继承关系如下 public class ServiceBean&lt;T&gt; extends ServiceConfig&lt;T&gt; imple...
dubbo的半包和粘包
当我谈编程时我谈些什么
08-24 467
若出现粘包，就会根据它的请求长度进行截取； 若出现拆包，数据会不完整，就进入循环重新读取，直到取到完整数据。 一、前言 在客户端与服务端进行通信时候都会约定一个通讯协议，协议一般包含一个header和body，一个header和body组成了一次通讯的内容，一个通讯包。正常情况下客户端通过socket发送一个请求包后，服务端接受后解析请求包，然后进行处理，这看似是一个很简单的问题，但当客户端连续发送多个请求包时就可能会出现半包、粘包现象。 二、什么是粘包与半包问题 在客户端发送数据时，实际是把数据写入
Caused by: java.lang.IllegalStateException: ＜dubbo:service interface=““ /＞ interface not allow null!
qq_45441466的博客
04-18 1894
今天我在dubbo项目中，新增一个服务时，代码写完正准备启动项目报错了：四月 18, 2021 12:16:34 上午 org.apache.catalina.loader.WebappClassLoader findResourceInternal 信息: Illegal access: this web application instance has been stopped already. Could not load . The eventual following stack trace ..
应用启动间断性偶发dubbo:service interface not allow null! 问题解决
tszxlzc的专栏
06-14 2501
应用启动间断性偶发dubbo:service interface not allow null! 问题解决首先贴一下报错信息问题关键环境问题分析问题解决 首先贴一下报错信息 Caused by: java.lang.IllegalStateException: <dubbo:service interface="" /> interface not allow null! at org.apache.dubbo.config.ServiceConfig.checkAndUpdateSu
Dubbo阅读笔记
12-24
dubbo源码分析，服务提供方到消费方的代理实现，代码演示。
dubbo学习笔记.pdf
07-28
用户不得未经著作权人同意擅自对他人的作品进行全部或部分复制、修改、改编、翻译、汇编、反向工程、反向编译、反向汇编或改写并进行上传。用户可以为介绍、评论、研究等目的，在合理范围内依法引用他人已经发表的...
dubbo课堂笔记以及原理
03-30
dubbo的操作和使用流程详解（Dubbo简介及结构图、Dubbo支持的几种Registry、Zookeeper简介、Zookeeper安装、Dubbo支持的几种Protocol、Dubbo项目搭建、Admin管理界面、Assembly打包、监控中心搭建）
dubbo和springcloud问题解决——interface not allow null
Juinjonn的博客
03-03 3982
dubbo和springcloud问题解决——interface not allow null 当使用`@Service`注解注入`dubbo provider`到Spring容器中时，在`dubbo provider`的bean对象里依赖`SpringCloud`的bean时，触发报错，应用报错无法启动！
基于TCPCopy的Dubbo服务引流工具-DubboCopy
weixin_33800463的博客
05-31 152
TCPCopy顾名思义，就是一个可以将tcp流量复制的工具(其实也可以复制UDP)。有了这样一个工具，我们就可以真实的复制线上流量，然后将这些流量复制到我们的测试服务器上。这样就可以很容易模拟线上真实用户的访问，做一些功能上的，性能上的测试。而且经过实际测试发现TCPCopy对线上机器的资源消耗也是极低的。 借助这么一个工具，我们可以比较容易的实现一些比较有意思的功能。比如我们现在我们的应用都已...
dubbo启动出现java.lang.IllegalStateException: ref not allow null!
Hershey's Blog
02-11 1万+
dubbo（消费方）启动时报如下错误：18/02/11 14:50:01 ERROR org.springframework.web.servlet.DispatcherServlet:502: Context initialization failed java.lang.IllegalStateException: ref not allow null!     at com.alibaba...
Dubbo服务启动失败：＜dubbo:service interface=““ /＞ interface not allow null!
jesus_star的博客
11-19 2754
最近升级框架版本： spring boot：2.2.5 --> 2.3.2 spring cloud：Hoxton.SR3 -->Hoxton.SR8 spring cloud alibaba：2.2.1 --> 2.2.3 dubbo：2.7.6 --> 2.7.8 升级后某服务启动失败，异常日志： org.springframework.beans.factory.BeanCreationException: Error creating bean with na.
ref not allow null! (java.lang.IllegalStateException)
jxin
08-20 1255
主要原因应该是dubbo的消费者没有配 ref。 dubbo配置： <!-- 提供者 --> <dubbo:service interface="xxx.GoodsService" ref="goodsServiceImpl" timeout="60000"/> <!-- 消费者 --> <dubbo:reference id="goodsServi...
dubbo容器-客户端调用
Mergades
03-29 7662
1，在Dubbo使用中，客户端通过Dubbo容器来调用远程服务。在客户端调用中，通过如下代码引入远程Dubbo服务器： dubbo:reference id="itemManagement" interface="com.IItemManagemen" version="${items.dubbo.version}" check="false" async="true">dubbo:refe
dubbo提供方与消费方的三种连接方式
阿凡提的小毛驴专栏
05-14 7655
1、采用zookeeper作为注册中心<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.a
第二章 Dubbo配置
Mook的博客
04-25 208
TODO
Dubbo/Dubbox的服务消费（一）- 服务代理的创建
weiythi的Blog
11-20 2936
dubbo的consumer的初始过程一个常见的consumer配置是这样的<dubbo:reference id="dubboDemo" interface="com.company.dsp.adcenter.protocol.dubbo.DubboDemo" protocol="dubbo"/>这样spring会创建一个beanName为dubboDemo的be
DUBBO的com.alibaba.dubbo.rpc.RpcException解决方法
热门推荐
Qi.zheng
11-06 9万+
联接超时问题 Caused by: com.alibaba.dubbo.rpc.RpcException: Failed to invoke the method subscribe in the service com.alibab a.dubbo.registry.RegistryService. Tried 3 times of the providers[172.168.1.167:2
尚硅谷dubbo学习笔记
最新发布
10-12
抱歉，我无法回答关于尚硅谷dubbo学习笔记的问题，因为我是一个通用型AI语言模型，没有具体的学习笔记。但是，我可以为您提供一些关于Dubbo的基本知识。 Dubbo是一种高性能、轻量级的开源Java RPC框架，由阿里巴巴...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值