1、RPC原理

一次完整的RPC调用流程（同步调用，异步另说）如下：

服务消费方（client）调用以本地调用方式调用服务；
client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
client stub找到服务地址，并将消息发送到服务端；
server stub收到消息后进行解码；
server stub根据解码结果返回给server stub；
本地服务执行并将结果返回给server stub；
server stub将返回结果打包成消息并发送至消费者；
client stub接收到消息，并进行解码；
服务消费者得到最终结果；

RPC框架的目标就是要将2~8这些步骤都封装起来，这些细节对用户来说是透明的，不可见的。

2、Netty原理

Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。它极大地简化并简化了TCP和UDP套接字服务器等网络编程。
BIO（Blocking Io）:

NIO（Non-Blocking IO）：

通道（Channel）里面有缓冲区（Buffer）来进行数据传输，
Selector：多路复用，也称为选择器
Connect：连接就绪
Accept：接受就绪
Read：读就绪
Write：写就绪
Netty基本原理：

3、dubbo原理

1、dubbo原理-框架设计

https://dubbo.apache.org/zh/docsv2.7/dev/design/

各层说明：

config 配置层：对外配置接口，以 ServiceConfig, ReferenceConfig 为中心，可以直接初始化配置类，也可以通过 spring 解析配置生成配置类
proxy 服务代理层：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心，扩展接口为 ProxyFactory
registry 注册中心层：封装服务地址的注册与发现，以服务 URL 为中心，扩展接口为 RegistryFactory, Registry, RegistryService
cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心，扩展接口为 Cluster, Directory, Router, LoadBalance
monitor 监控层：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory, Monitor, MonitorService
protocol 远程调用层：封装 RPC 调用，以 Invocation, Result 为中心，扩展接口为 Protocol, Invoker, Exporter
exchange 信息交换层：封装请求响应模式，同步转异步，以 Request, Response 为中心，扩展接口为 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer
transport 网络传输层：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel, Transporter, Client, Server, Codec
serialize 数据序列化层：可复用的一些工具，扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool
2、dubbo原理-启动解析、加载配置信息
标签解析：使用Spring的BeanDefinitionParser解析接口 ```java package org.springframework.beans.factory.xml;

import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.lang.Nullable; import org.w3c.dom.Element;

public interface BeanDefinitionParser { @Nullable BeanDefinition parse(Element var1, ParserContext var2); }

**Dubbo使用的标签解析类：**<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/20365223/1651894284687-c27d9bfc-ac88-463c-90dc-4c4eb1d75b0d.png#clientId=u24b5b0c3-0257-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=422&id=u7756719d&margin=%5Bobject%20Object%5D&name=image.png&originHeight=528&originWidth=1604&originalType=binary&ratio=1&rotation=0&showTitle=false&size=180143&status=done&style=none&taskId=u629a1ec0-c959-44e6-aafa-86629f9b1a9&title=&width=1283.2)<br />**配置文件引入启动应用：**
```java
public class MainApplication {
//    public static void main(String[] args) {
//        SpringApplication.run(MainApplication.class);
//    }
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("provider.xml");
        ioc.start();  // start是ClassPathXmlApplicationContext中的方法
        System.in.read();
    }
}

这个DubboBeanDefinitionParser解析器是如何创建的的？
在构造器中打入断点。启动调试。

在dubbo命名空间处理器（DubboNamespaceHandler）注册了许多dubbo标签解析器。

在初始化解析器之后就初始化每个config，注意service、reference标签的配置类不是以Config.class结尾，而是Bean.class结尾，而对于ServiceBean.class的实例的初始化就涉及到了服务暴露的过程。

3、dubbo原理-服务暴露

public class ServiceBean<T> extends ServiceConfig<T> implements 
    InitializingBean, 
    DisposableBean, 
    ApplicationContextAware, 
    BeanNameAware, 
    ApplicationEventPublisherAware {
    // ......
}

public interface InitializingBean {
    void afterPropertiesSet() throws Exception; // 当组件创建完对象的时候，设置完属性的时候，Spring容器会调用该方法。
}

对于老师上课的源码该方法在dubbo2.7.8.jar中并没有去实现该接口。
@Parameter注解说明：https://www.jianshu.com/p/bfe32e4a1030/

服务暴露的方法：

doExportUrls方法做了什么：加载注册中心的一些信息，

那什么时候会将服务注册到注册中心呢？
核心方法：

    Invoker<?> invoker = PROXY_FACTORY.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);

Invoker<?> invoker = PROXY_FACTORY.getInvoker(this.ref, this.interfaceClass, registryURL.addParameterAndEncoded("export", url.toFullString()));
该方法通过代理工厂获取 this.interfaceClass这个接口以及this.ref对象的执行者。
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
将invoker再次进行包装，进行层层包装。

invoker对象将多个对象包装成一个Invoker对象实例。

private static final Protocol PROTOCOL = (Protocol)ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
// 基于java的SPI机制，获取扩展的类加载器得到Protocol.class的适配。
Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);

Ctrl+alt+B：悬浮显示一个接口的所有实现类

首先进入的是RegistryProtocol的export(final Invoker originInvoker)方法。

    public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
        URL registryUrl = this.getRegistryUrl(originInvoker);
        URL providerUrl = this.getProviderUrl(originInvoker);
        URL overrideSubscribeUrl = this.getSubscribedOverrideUrl(providerUrl);
        RegistryProtocol.OverrideListener overrideSubscribeListener = new RegistryProtocol.OverrideListener(overrideSubscribeUrl, originInvoker);
        this.overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
        providerUrl = this.overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
        // doLocalExport(): 做本地服务的暴露
        RegistryProtocol.ExporterChangeableWrapper<T> exporter = this.doLocalExport(originInvoker, providerUrl); 
        Registry registry = this.getRegistry(originInvoker);
        URL registeredProviderUrl = this.getUrlToRegistry(providerUrl, registryUrl);
        boolean register = providerUrl.getParameter("register", true);
        if (register) {
            this.register(registryUrl, registeredProviderUrl);
        }
        this.registerStatedUrl(registryUrl, registeredProviderUrl, register);
        exporter.setRegisterUrl(registeredProviderUrl);
        exporter.setSubscribeUrl(overrideSubscribeUrl);
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
        this.notifyExport(exporter);
        return new RegistryProtocol.DestroyableExporter(exporter);
    }

 public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        URL url = invoker.getUrl();
        String key = serviceKey(url);
        DubboExporter<T> exporter = new DubboExporter(invoker, key, this.exporterMap);
        this.exporterMap.put(key, exporter);
        Boolean isStubSupportEvent = url.getParameter("dubbo.stub.event", false);
        Boolean isCallbackservice = url.getParameter("is_callback_service", false);
        if (isStubSupportEvent && !isCallbackservice) {
            String stubServiceMethods = url.getParameter("dubbo.stub.event.methods");
            if ((stubServiceMethods == null || stubServiceMethods.length() == 0) && this.logger.isWarnEnabled()) {
                this.logger.warn(new IllegalStateException("consumer [" + url.getParameter("interface") + "], has set stubproxy support event ,but no stub methods founded."));
            }
        }
        this.openServer(url);  // 这里会创建Netty服务器，就是启动Netty服务器，监听20880端口，或者其他，按配置的端口协议来监听。
        this.optimizeSerialization(url);
        return exporter;
    }
    private void openServer(URL url) {
        String key = url.getAddress();
        boolean isServer = url.getParameter("isserver", true);
        if (isServer) {
            ProtocolServer server = (ProtocolServer)this.serverMap.get(key);
            if (server == null) {
                synchronized(this) {
                    server = (ProtocolServer)this.serverMap.get(key);
                    if (server == null) {
                        this.serverMap.put(key, this.createServer(url)); // 首次创建服务器
                    }
                }
            } else {
                server.reset(url);
            }
        }
    }
    private ProtocolServer createServer(URL url) {
        url = URLBuilder.from(url).addParameterIfAbsent("channel.readonly.sent", Boolean.TRUE.toString()).addParameterIfAbsent("heartbeat", String.valueOf(60000)).addParameter("codec", "dubbo").build();
        String str = url.getParameter("server", "netty");
        if (str != null && str.length() > 0 && !ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str)) {
            throw new RpcException("Unsupported server type: " + str + ", url: " + url);
        } else {
            ExchangeServer server;
            try {
                server = Exchangers.bind(url, this.requestHandler);
            } catch (RemotingException var5) {
                throw new RpcException("Fail to start server(url: " + url + ") " + var5.getMessage(), var5);
            }
            str = url.getParameter("client");
            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 new DubboProtocolServer(server);
        }
    }

String key = url.getAddress();该方法获取的是IP地址+端口的方式。

DubboProtocol的createServer方法创建的就是Netty服务器。

启动后，Zookeeper显示的内容

4、dubbo原理-服务引用

调用引用的标签：

    <!-- 生成远程服务代理，可以和本地bean一样使用demoService ,timeout单位毫秒, 重试次数：retries-->
    <dubbo:reference id="userService" interface="com.lzy.gmail.service.UserService"
                     check="false"
                     timeout="3000"
                    retries="3"
                    version="*"
                    stub="com.lzy.service.impl.UserServiceImpl"/>
     // dubbo:reference标签对应的类为ReferenceBean<T>,实现了FactoryBean接口，说明是一个工厂Bean.交由Spring容器管理。
 public class ReferenceBean<T> extends ReferenceConfig<T> 
     implements FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean {
     // ......   
 }

dubbo学习

4、dubbo原理