Dubbo2.7.6之服务暴露详细过程解析

最新推荐文章于 2022-12-04 21:08:41 发布
最新推荐文章于 2022-12-04 21:08:41 发布
阅读量1.2k 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaodongchao1992/article/details/106023338
版权

继上一篇Dubbo2.7.6之服务暴露流程 之后，这里就详细讨论服务暴露的过程。由于官方建议注册中心为zookeeper。那么这里就以zookeeper为注册中心。来看一下暴露服务到zookeeper中的详细过程。

在ServiceConfig中，暴露服务的核心逻辑就是三行代码。如下：

//1 使用ProxyFactory来生产一个Invoker实例
Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass,  registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
//2 使用DelegateProviderMetaDataInvoker来包装Invoker,将Invoker委派给DelegateProviderMetaDataInvoker
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
//3 使用Protocol实例来暴露服务
Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);

那么下面就分三步来研究：

  1. 生成Invoker实例

实际调用的是StubProxyFactoryWrapper#getInvoker(T proxy, Class type, URL url)方法。

参数解释：
proxy 服务接口的实现类
type 服务接口，必须是接口
URL 服务注册的所有配置信息

具体实现：

public class StubProxyFactoryWrapper implements ProxyFactory {

    private static final Logger LOGGER = LoggerFactory.getLogger(StubProxyFactoryWrapper.class);

    private final ProxyFactory proxyFactory;

    private Protocol protocol;

    public StubProxyFactoryWrapper(ProxyFactory proxyFactory) {
        this.proxyFactory = proxyFactory;
    }

    public void setProtocol(Protocol protocol) {
        this.protocol = protocol;
    }

    ...
    /**
    *
    * 调用被包装的ProxyFactory实例的getInvoker方法
    * 也就是JavassistProxyFactory#getInvoker(T proxy, Class<T> type, URL url)
    **/
    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) throws RpcException {
        return proxyFactory.getInvoker(proxy, type, url);
    }

    private <T> Exporter<T> export(T instance, Class<T> type, URL url) {
        return protocol.export(proxyFactory.getInvoker(instance, type, url));
    }

}

其实具体逻辑还是在JavassistProxyFactory中，那就继续看它的实现：

public class JavassistProxyFactory extends AbstractProxyFactory {

    @Override
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }

    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
        // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
        //生成接口的Wrapper类，这里又会通过字节码技术，重新生产一个对应服务接口的wrapper类class实例
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);  
        //构建一个AbstractProxyInvoker实例，这里又使用了模版设计模式。自实现模版方法doInvoke
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class<?>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }

}

也就是说，第一步产生了一个AbstractProxyInvoker实例。

  1. 创建Invoker包装类 DelegateProviderMetaDataInvoker

DelegateProviderMetaDataInvoker是一个Invoker的包装类，它的作用就是将服务接口的Invoker实例和ServiceConfig实例包装在一起。

/**
 *
 * A Invoker wrapper that wrap the invoker and all the metadata (ServiceConfig)
 */
public class DelegateProviderMetaDataInvoker<T> implements Invoker {
    protected final Invoker<T> invoker;
    private ServiceConfig<?> metadata;

    public DelegateProviderMetaDataInvoker(Invoker<T> invoker, ServiceConfig<?> metadata) {
        this.invoker = invoker;
        this.metadata = metadata;
    }

    @Override
    public Class<T> getInterface() {
        return invoker.getInterface();
    }

    @Override
    public URL getUrl() {
        return invoker.getUrl();
    }

    @Override
    public boolean isAvailable() {
        return invoker.isAvailable();
    }
    /**
    * Inocation就是对要调用方法的包装。里面包含的接口方法的名称，参数类型，参数等信息
    * 
    * 这里就是对要调用具体方法的执行逻辑
    **/
    @Override
    public Result invoke(Invocation invocation) throws RpcException {
        return invoker.invoke(invocation);
    }

    @Override
    public void destroy() {
        invoker.destroy();
    }

    public ServiceConfig<?> getMetadata() {
        return metadata;
    }
}
  1. export服务

这是Protocol在暴露服务接口时，默认的实现结构图。

在这里插入图片描述
在使用PROTOCOL获取暴露接口时，实际上PROTOCOL是一个包装类。最底层包含了DubboProtocol。 使用QosProtocolWrapper,ProtocolFilterWrapper,ProtocolListenerWrapper这三个包装类一层一层的包装DubboProtocol 。这里就使用到了装饰者设计模式。在每一层都会添加额外的处理逻辑。结构如下：
在这里插入图片描述
下面先来看源码QosProtocolWrapper：

public class QosProtocolWrapper implements Protocol {

    private final Logger logger = LoggerFactory.getLogger(QosProtocolWrapper.class);
    private static AtomicBoolean hasStarted = new AtomicBoolean(false);
    private Protocol protocol;
    public QosProtocolWrapper(Protocol protocol) {
        if (protocol == null) {
            throw new IllegalArgumentException("protocol == null");
        }
        this.protocol = protocol;
    }
    ...
    
    @Override
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        //如果是应用注册，则启动Qos服务
        if (UrlUtils.isRegistry(invoker.getUrl())) {
            startQosServer(invoker.getUrl());
            return protocol.export(invoker);
        }
        //暴露接口就直接调用自己包装的Protocol实例的export方法
        return protocol.export(invoker);
    }
   ...
}

可以看到在暴露具体接口服务时，这个wrapper是直接调用ProtocolFilterWrapper#export(),相当于没有执行任何逻辑。下面继续看ProtocolFilterWrapper#export

public class ProtocolFilterWrapper implements Protocol {

    private final Protocol protocol;
    public ProtocolFilterWrapper(Protocol protocol) {
        if (protocol == null) {
            throw new IllegalArgumentException("protocol == null");
        }
        this.protocol = protocol;
    }


    @Override
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        //如果是应用注册，就调下一层Protocol实例
        if (UrlUtils.isRegistry(invoker.getUrl())) {
            return protocol.export(invoker);
        }
        //如果暴露接口服务，就构建InvokerChain
        return protocol.export(buildInvokerChain(invoker, SERVICE_FILTER_KEY, CommonConstants.PROVIDER));
    }
    //获取所有的可激活的filter，然后一层一层包装Invoker实例，构成一个InvokerChian
    private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
        Invoker<T> last = invoker;
        List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);

        if (!filters.isEmpty()) {
            for (int i = filters.size() - 1; i >= 0; i--) {
                final Filter filter = filters.get(i);
                final Invoker<T> next = last;
                last = new Invoker<T>() {

                    @Override
                    public Class<T> getInterface() {
                        return invoker.getInterface();
                    }

                    @Override
                    public URL getUrl() {
                        return invoker.getUrl();
                    }

                    @Override
                    public boolean isAvailable() {
                        return invoker.isAvailable();
                    }

                    @Override
                    public Result invoke(Invocation invocation) throws RpcException {
                        Result asyncResult;
                        try {
                            asyncResult = filter.invoke(next, invocation);
                        } catch (Exception e) {
                            if (filter instanceof ListenableFilter) {
                                ListenableFilter listenableFilter = ((ListenableFilter) filter);
                                try {
                                    Filter.Listener listener = listenableFilter.listener(invocation);
                                    if (listener != null) {
                                        listener.onError(e, invoker, invocation);
                                    }
                                } finally {
                                    listenableFilter.removeListener(invocation);
                                }
                            } else if (filter instanceof Filter.Listener) {
                                Filter.Listener listener = (Filter.Listener) filter;
                                listener.onError(e, invoker, invocation);
                            }
                            throw e;
                        } finally {

                        }
                        return asyncResult.whenCompleteWithContext((r, t) -> {
                            if (filter instanceof ListenableFilter) {
                                ListenableFilter listenableFilter = ((ListenableFilter) filter);
                                Filter.Listener listener = listenableFilter.listener(invocation);
                                try {
                                    if (listener != null) {
                                        if (t == null) {
                                            listener.onResponse(r, invoker, invocation);
                                        } else {
                                            listener.onError(t, invoker, invocation);
                                        }
                                    }
                                } finally {
                                    listenableFilter.removeListener(invocation);
                                }
                            } else if (filter instanceof Filter.Listener) {
                                Filter.Listener listener = (Filter.Listener) filter;
                                if (t == null) {
                                    listener.onResponse(r, invoker, invocation);
                                } else {
                                    listener.onError(t, invoker, invocation);
                                }
                            }
                        });
                    }

                    @Override
                    public void destroy() {
                        invoker.destroy();
                    }

                    @Override
                    public String toString() {
                        return invoker.toString();
                    }
                };
            }
        }

        return last;
    }

ProtocolFilterWrapper将Filter封装进Invoker中之后，再调用被它包装的Protocol实例ProtocolListenerWrapper的export方法。
下面来看下这里面的实现逻辑：

public class ProtocolListenerWrapper implements Protocol {

    private final Protocol protocol;

    public ProtocolListenerWrapper(Protocol protocol) {
        if (protocol == null) {
            throw new IllegalArgumentException("protocol == null");
        }
        this.protocol = protocol;
    }
    ...
    
    @Override
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        //如果应用注册，就跳过此Wrapper逻辑。
        if (UrlUtils.isRegistry(invoker.getUrl())) {
            return protocol.export(invoker);
        }
        //如果服务接口注册，则获取到所有的可激活的ExporterListener实例。使用ListenerExporterWrapper再此wrapper起来
        return new ListenerExporterWrapper<T>(protocol.export(invoker),
                Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class)
                        .getActivateExtension(invoker.getUrl(), EXPORTER_LISTENER_KEY)));
    }
}

直接看ListenerExporterWrapper实现：

public class ListenerExporterWrapper<T> implements Exporter<T> {

    private static final Logger logger = LoggerFactory.getLogger(ListenerExporterWrapper.class);

    private final Exporter<T> exporter;

    private final List<ExporterListener> listeners;
    
    public ListenerExporterWrapper(Exporter<T> exporter, List<ExporterListener> listeners) {
        if (exporter == null) {
            throw new IllegalArgumentException("exporter == null");
        }
        this.exporter = exporter;
        this.listeners = listeners;
        if (CollectionUtils.isNotEmpty(listeners)) {
            RuntimeException exception = null;
            for (ExporterListener listener : listeners) {
                if (listener != null) {
                    try {
                        listener.exported(this);
                    } catch (RuntimeException t) {
                        logger.error(t.getMessage(), t);
                        exception = t;
                    }
                }
            }
            if (exception != null) {
                throw exception;
            }
        }
    }
    @Override
    public Invoker<T> getInvoker() {
        return exporter.getInvoker();
    }

 ...
}

可以看到，在ListenerExporterWrapper的构造方法中，对ExporterListener进行了逐个调用。但是目前ExporterListener 的没有具体实现。也就是这段逻辑就是包装了一下exporter实例。

峡谷程序猿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dubbo——标签解析、服务暴露、服务引用、服务调用1
08-04
一、标签处理 二、服务暴露过程 三、服务引用过程 四、服务调用过程
详解SpringBoot开发案例之整合Dubbo分布式服务
08-26
主要介绍了详解SpringBoot开发案例之整合Dubbo分布式服务，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
无需操作可以直接下载使用的jar 最新版的dubbo admin 2.7 兼容2.6
01-09
最新版的dubbo admin 2.7 兼容 2.6 dubbo-admin是一个dubbo的后台管理与监控平台。可以提供服务查询，服务治理，条件路由，黑白名单，负载均衡等功能操作，十分方便。 使用方法: 首先使用解压工具打开jar包,在dubbo-admin-server-0.1.jar\BOOT-INF\classes下 的application.properties中修改自己的zookeeper的ip server.port=9999 # centers in dubbo2.7 admin.registry.address=zookeeper://192.168.0.102:2181 admin.config-center=zookeeper://192.168.0.102:2181 admin.metadata-report.address=zookeeper://192.168.0.102:2181 为防止端口冲突我修改为了 9999 然后用户名,密码为root和root 命令行:cd进入该jar包所在的路径,下 命令行: java -jar dubbo-admin-server-0.1.jar 浏览访问:http://localhost:9999/index.html 可参照https://blog.csdn.net/u010565545/article/details/103886903
dubbo 2.7新特性
10-25
dubbo2.7版本的新特性！
Spring整合Dubbo框架过程及原理解析
08-25
主要介绍了Spring整合Dubbo框架过程及原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Dubbo服务暴露过程
weixin_33980459的博客
12-09 656
概览 dubbo暴露服务有两种情况，一种是设置了延迟暴露（比如delay=”5000”），另外一种是没有设置延迟暴露或者延迟设置为-1（delay=”-1”）： 设置了延迟暴露，dubbo在Spring实例化bean（initializeBean）的时候会对实现了InitializingBean的类进行回调，回调方法是afterProp...
dubbo服务暴露
tian31233的专栏
06-01 357
远程服务的暴露总体步骤：将ref封装为invoker将invoker转换为exporter启动netty注册服务到zookeeper订阅与通知返回新的exporter实例
Dubbo之服务暴露
YANGTAO_0的博客
03-02 458
前言本文 Dubbo 使用版本 2.7.5Dubbo 通过使用 dubbo:service配置或 @service在解析完配置后进行服务暴露，供服务消费者消费。Dubbo 的服务暴露有两...
Dubbo-服务暴露
weixin_38592881的博客
12-04 461
Dubbo源码阅读分享系列文章，欢迎大家关注点赞SPI实现部分Dubbo-SPI机制Dubbo-Adaptive实现原理Dubbo-Activate实现原理Dubbo SPI-Wrapper注册中心Dubbo-聊聊注册中心的设计Dubbo-时间轮设计通信Dubbo-聊聊通信模块设计RPC聊聊Dubbo协议在介绍RPC核心接口的时候我们说过Protocol核心作用是将Invoker服务暴露出去以及引用服务将Invoker对象返回，因此我们就从Protocol开始说起。下图是Protocol的整个继承结构，从前
hessian序列化_Apache Dubbo 2.7.6反序列化入侵复现及分析
weixin_39524247的博客
01-10 450
转载:先知社区作者：tornado简介Dubbo从大的尺寸上将是RPC框架，负责封装RPC调用，支持很多RPC协议RPC协议包括了dubbo，rmi，hessian，webservice，http，redis，rest，thrift，memcached，jsonrpc等Java中的序列化有Java原生序列化，Hessian序列化，Json序列化，dubbo序列化图片来源：https:...
Dubbo2.7.6启动原理之Provider
zhaodongchao的博客
05-06 5836
上文讲述了Config层的整理流程，这一篇继续讨论配置加载的细节，那就是今天要探讨的DubboBootstrap。 Dubbo启动原理 还是从源码出发，从DubboBootstrap#start()方法开始，顺藤摸瓜，查看dubbo初始化的细节原理 /** * Start the bootstrap * 启动dubbo服务 */ public DubboBootstrap start()...
spring boot 整合dubbo2.7.8
qq_36043775的博客
09-16 4584
由于dubbo2.7.8之前的版本有漏洞，项目需要升级至2.7.8，之前用的是阿里的dubbo，在版本切换上遇到过一些问题，特记录一下心得。 首先讲下dubbo的版本 dubbo在2.6版本是阿里在管理和维护，后面交给了apache管理，2.7.*都是apache的 maven依赖引入的方式也不同，具体引入方式可去maven仓库查询即可。 之前项目用到的是阿里的dubbo，考虑到后面可能又会发现其他漏洞而进行升级，为了减少兼容性问题，现在计划直接升级到最新版，如果后面再升级就方便很多。 现使
链式日志-dubbo2.7.6 + zipkin
jy02718805的专栏
09-17 457
1【架构图】 Collector 收集器、Storage 存储、API、UI 用户界面等几部分构成了 Zipkin Server 部分，对应于 GitHub 上 openzipkin/zipkin 这个项目。而收集应用中调用的耗时信息并将其上报的组件与应用共生，并拥有各个语言的实现版本，其中 Java 的实现是 GitHub 上 openzipkin/brave。除了 Java 客户端实现之外，openzipkin 还提供了许多其他语言的实现，其中包括了 go、php、JavaScript、.ne
springboot2.2.6整合Dubbo2.7.6
热门推荐
诗水人间
05-06 13万+
首先需要准备环境 docker安装zookeeper环境的安装 web 端的监控中心github地址 （需要修改properties配置文件的zookeeper服务器ip为上面搭建好的zookeeper服务器ip，或者你可以直接在本机上直接运行zookeeper，默认就行，下面的web管理后台中properties中的地址为localhost，如果使用的zookeeper服务器地址不是lo...
dubbo的服务暴露
chengzhuo5471的博客
07-10 155
简述 1 dubbo的服务暴露是从serviceBean开始的，该类实现了ApplicationListener<ContextRefreshedEvent>接口，在spring 初始化并加载所有bean后会执行export方法 2 获取dubbo配置中的register转换成ur...
Dubbo服务暴露
ZERO
08-13 857
转载自：https://blog.csdn.net/u012410733/article/category/7159846      在服务提供者暴露的时候，首先从配置文件中获取到对外提供的实际类ref(如：HelloWorldImpl)，然后通过ProxyFactory类(JavassistProxyFactory或JdkProxyFactory)把ref生成一个AbstractProxyInv...
dubbo的服务暴露过程
最新发布
05-27
Dubbo的服务暴露过程大致如下： 1. 首先，Dubbo会通过配置文件或者注解方式定义服务接口，包括接口名称、方法等信息。 2. 接着，Dubbo会将服务接口的实现注册到注册中心，包括服务名称、IP地址、端口号等信息。 3...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值