傻瓜_blue
傻瓜_blue

2019-07-24 Motan RPC 框架分析

Sina Motan RPC 框架分析 原文写于2年前

1. 场景

  • motan是微博开源的一套轻量级、方便使用的RPC框架
  • 项目地址：https://github.com/weibocom/motan
  • Motan 是基于 Java 的高性能轻量级 RPC 框架，
    • 其具备实用的服务治理功能和 RPC 协议扩展能力。
    • 服务发现灵活支持多种配置管理组件，基于高并发高负载场景的高可用策略优化，
    • 良好的 SPI(Service Provider Interface)扩展，详细的调用统计，灵活支持多种 RPC 传输协议，在使用上，
    • 无缝支持Spring 配置方式，通过简单灵活的配置即可快速接入使用

2 架构图 （图片来自网上）

  • 整体结构
2019-07-24 Motan RPC 框架分析_第1张图片
RPC
  • 分层结构
2019-07-24 Motan RPC 框架分析_第2张图片
Motan

3 RPC框架要重点核心点

推荐从motan看RPC框架实现

核心内容

  1. 如何与Spring做集成？
  2. SPI机制的实现原理是什么？为什么要用这个？
  3. 这么多的配置，究竟是如何在类间传递和保存的？
  4. 服务降级是如何做的？
  5. motan协议究竟是什么样子的？
  6. 服务发现和注册究竟是怎么做的？或者说客户端是如何找到服务端的？
  7. 为什么要用动态代理，到底proxy了什么？
  8. cluster的负载均衡和ha究竟是如何实现的？
  9. transport层是怎么进行抽象的？
  10. client对server的心跳检测是怎么实现的呢？
  11. client端的连接池是如何管理的？
  12. server端的连接是如何共享的？

源代码分析关注点下几点

  1. SPI机制的实现原理是什么？为什么要用这个？
  2. 这么多的配置，究竟是如何在类间传递和保存的？
  3. motan协议究竟是什么样子的？
  4. 为什么要用动态代理，到底proxy了什么？
  5. transport层是怎么进行抽象的？
  6. transport层是怎么进行抽象的？
  7. client对server的心跳检测是怎么实现的呢？
  8. client端的连接池是如何管理的？
  9. server端的连接是如何共享的？

我将从以上几点对motan的源代码进行分析debug
由于spring集成与解决涉及的内容比较多与杂，暂时先不作分析

RPC本质的理解

  1. 对于软件工程师来讲，形如object.method()的方法调用实在是太过熟悉，
    当我们在同一个JVM进程内执行方法调用的时候，一切都显得顺其自然。
    然而如果我们将上述的调用过程拆分成两个部分—-方法的调用端和方法的实现端，
    然后将他们分别放置到不同的进程中，使得调用端和实现端能够做到跨操作系统，跨网络。这便是RPC的本质。

  2. 从功能角度来讲，RPC框架可以分为服务治理型和多语言型。motan显然属于前者，
    因此对motan框架可以简单的理解为：分离方法的调用和实现，并具双端服务治理功能。

  1. 在同一jvm中就是 method.invoke(),而跨vm与网络时，则涉及到对象与数据的交换，而client方只用到了一个接口而已。
  2. 如果打电话，通过电话号找到远程的你call you ,而你我分属不同的vm进程

Quick Start

入门例子

  1. server demo 服务 
     import com.weibo.api.motan.common.MotanConstants;.
 import ...
 public class MotanApiExportDemo {
     public static void main(String[] args) throws InterruptedException {
         ServiceConfig motanDemoService = new ServiceConfig();
 
         // 设置接口及实现类
         motanDemoService.setInterface(MotanDemoService.class);
         motanDemoService.setRef(new MotanDemoServiceImpl());
 
         // 配置服务的group以及版本号
         motanDemoService.setGroup("motan-demo-rpc");
         motanDemoService.setVersion("1.0");
 
         // 配置注册中心直连调用
         // RegistryConfig directRegistry = new RegistryConfig();
         // directRegistry.setRegProtocol("local");
         // directRegistry.setCheck("false"); //不检查是否注册成功
         // motanDemoService.setRegistry(directRegistry);
 
         // 同志我本机没有安装 zk,因此将zk的地上注释 ，此时motan将默认使用local来注册
         RegistryConfig zookeeperRegistry = new RegistryConfig();
         // 配置ZooKeeper注册中心
        //   zookeeperRegistry.setRegProtocol("zookeeper");
        //   zookeeperRegistry.setAddress("127.0.0.1:2181");
         motanDemoService.setRegistry(zookeeperRegistry);
 
         // 配置RPC协议
         ProtocolConfig protocol = new ProtocolConfig();
         protocol.setId("motan");
         protocol.setName("motan");
         motanDemoService.setProtocol(protocol);
 
         motanDemoService.setExport("motan:8002");
         motanDemoService.export();
 
         MotanSwitcherUtil.setSwitcherValue(MotanConstants.REGISTRY_HEARTBEAT_SWITCHER, true);
 
         System.out.println("server start...");
     }
 }
  • ServiceConfig 显露外部服务的公用类，如果是用spring集成，将会使用其子类 ServiceConfigBean，暂时不讨论
    1. ServiceConfig 有两个属性 interface ,ref 分别代码接口与实现类。然后指名服务 的分组与版本.
    2. RegistryConfig 代码服务生成后，注册地上，暂时不用zk，因此注释设置相关属性的地方。
    3. ProtocolConfig 服务是用保种协议进行传输与调用的 motan
    4. ServiceConfig 设置~ setRegistryConfig,setProtocolConfig~ ,然后调用export就实现了
  1. client调用 
          
 public class MotanApiClientDemo {
 
     public static void main(String[] args) throws InterruptedException {
         RefererConfig motanDemoServiceReferer = new RefererConfig();
 
         // 设置接口及实现类
         motanDemoServiceReferer.setInterface(MotanDemoService.class);
 
         // 配置服务的group以及版本号
         motanDemoServiceReferer.setGroup("motan-demo-rpc");
         motanDemoServiceReferer.setVersion("1.0");
         motanDemoServiceReferer.setRequestTimeout(300);
 
         // 配置注册中心直连调用
         // RegistryConfig directRegistry = new RegistryConfig();
         // directRegistry.setRegProtocol("local");
         // motanDemoServiceReferer.setRegistry(directRegistry);
 
         // 配置ZooKeeper注册中心
         RegistryConfig zookeeperRegistry = new RegistryConfig();
 //        zookeeperRegistry.setRegProtocol("zookeeper");
 //        zookeeperRegistry.setAddress("127.0.0.1:2181");
         motanDemoServiceReferer.setRegistry(zookeeperRegistry);
 
         // 配置RPC协议
         ProtocolConfig protocol = new ProtocolConfig();
         protocol.setId("motan");
         protocol.setName("motan");
         motanDemoServiceReferer.setProtocol(protocol);
         motanDemoServiceReferer.setDirectUrl("localhost:8002");  // 注册中心直连调用需添加此配置
 
         // 使用服务
         MotanDemoService service = motanDemoServiceReferer.getRef();
         for (int i=0;i<1000;i++) {
             System.out.println(service.hello("motan " +i));
             Thread.sleep(1000);
         }
 
         System.exit(0);
     }
 }
  • RefererConfig 客户端对motan服务的一个封装，如果是用spring集成，将会使用其子类 RefererConfigBean，暂时不讨论
    1. RefererConfig 有两个属性 interface ,ref 分别代码接口与实现类。然后指名服务 的分组与版本.
    2. RegistryConfig 代码服务生成后，注册地上，暂时不用zk，因此注释设置相关属性的地方。
    3. ProtocolConfig 服务是用保种协议进行传输与调用的 motan
    4. RefererConfig#gerRef().hello() 通过远程调用返回 hello motan

    这里使用setDirectUrl localhost:8002 主要是因为client,server在同一台机器上，但是端口仍然监听

公共组件部分

  1. SPI：Service Provider Interface，主要通过ExtensionLoader提供扩展点功能，用来动态装载接口具体实现，以提供客户端扩展能力。
  2. Logger：使用slf4j，提供整个框架统一的日志记录工具。
  3. Statistic：使用定时回调方式，收集和记录框架监控信息。
  4. URL：非Jdk里的URL。他对协议，路径，参数的统一抽象，系统也是使用URL来保存和读取配置信息的。
  5. Switcher：提供开关控制服务，能够控制框架关键路径的升级和降级。
  6. Exception：统一异常处理，分为业务异常，框架异常，服务异常等。

层的作用：

  1. Config层：主要提供了配置读取，解析，实体生成。同时他也是整个框架的入口，
  2. Proxy层：服务端无proxy，客户端具有代理功能，他通过InvocationHandler来拦截方法调用。目前只使用了jdk原生动态代理工具。
  3. Registry层：用来进行服务发现和注册，server端进行服务的注册，client进行服务发现。目前有zk,consul的实现，还有对directUrl（就是p2p，不借助中心）的特殊处理。
  4. Cluster层：集群功能，他提供了集群的服务暴露、服务引用、负载均衡，HA等。
  5. Protocol层：协议层，目前只支持injvm和motan协议，主要就是提供给下层协议编码和解析，并且使用filter/pipe模式进行访问日志，最大并发量控制等功能。
  6. Transport层：主要处理网络连接，他主要抽象了Client和Server接口。使用netty框架。

Server端

要关注的问题

  1. 配置解析与传递
    2。服务URL与注册URL
  2. SPI 机制
  3. transport 封装
  4. 服务暴露
  5. 类图

从ServiceConfig.export()开始。

类图

[图片上传失败...(image-b3f4e3-1563956674836)]

ServiceConfig 主要逻辑：


  
public class ServiceConfig extends AbstractServiceConfig {
    private static ConcurrentHashSet existingServices = new ConcurrentHashSet();
    // 具体到方法的配置
    protected List methods;
    // 接口实现类引用
    private T ref;

    // service 对应的exporters，用于管理service服务的生命周期
    private List> exporters = new CopyOnWriteArrayList>();
    private Class interfaceClass;
    private BasicServiceInterfaceConfig basicService;
    private AtomicBoolean exported = new AtomicBoolean(false);
    // service的用于注册的url，用于管理service注册的生命周期，url为regitry url，内部嵌套service url。
    private ConcurrentHashSet registereUrls = new ConcurrentHashSet();

    protected boolean serviceExists(URL url) {
        return existingServices.contains(url.getIdentity());
    }

    public synchronized void export() {
        if (exported.get()) {
            return;
        }
        // [1]
        checkInterfaceAndMethods(interfaceClass, methods);
        // [2]  AbstractInterfaceConfig#loadRegistryUrls  父类的方法来收集
        List registryUrls = loadRegistryUrls();
        if (registryUrls == null || registryUrls.size() == 0) {
            throw new IllegalStateException("Should set registry config for service:" + interfaceClass.getName());
        }

        Map protocolPorts = getProtocolAndPort();
        for (ProtocolConfig protocolConfig : protocols) {
            Integer port = protocolPorts.get(protocolConfig.getId());
            if (port == null) {
                throw new MotanServiceException();
            }
            // [3]
            doExport(protocolConfig, port, registryUrls);
        }
        afterExport();
    }

    @SuppressWarnings("unchecked")
    private void doExport(ProtocolConfig protocolConfig, int port, List registryURLs) {
        String protocolName = protocolConfig.getName();
        if (protocolName == null || protocolName.length() == 0) {
            protocolName = URLParamType.protocol.getValue();
        }

        String hostAddress = host;
        if (StringUtils.isBlank(hostAddress) && basicService != null) {
            hostAddress = basicService.getHost();
        }
        if (NetUtils.isInvalidLocalHost(hostAddress)) {
            hostAddress = getLocalHostAddress(registryURLs);
        }

        Map map = new HashMap();

        map.put(URLParamType.nodeType.getName(), MotanConstants.NODE_TYPE_SERVICE);
        map.put(URLParamType.refreshTimestamp.getName(), String.valueOf(System.currentTimeMillis()));

        collectConfigParams(map, protocolConfig, basicService, extConfig, this);
        collectMethodConfigParams(map, this.getMethods());

        // {id=motan, export=motan:8002, protocol=motan, refreshTimestamp=1505801631928, group=motan-demo-rpc, nodeType=service, version=1.0}
        System.out.println(" 7 service param ==>" +map);
        URL serviceUrl = new URL(protocolName, hostAddress, port, interfaceClass.getName(), map);
        // [4]
        if (serviceExists(serviceUrl)) {
            throw new MotanFrameworkException();
        }

        List urls = new ArrayList();

        // injvm 协议只支持注册到本地，其他协议可以注册到local、remote
        if (MotanConstants.PROTOCOL_INJVM.equals(protocolConfig.getId())) {
            URL localRegistryUrl = null;
            for (URL ru : registryURLs) {
                if (MotanConstants.REGISTRY_PROTOCOL_LOCAL.equals(ru.getProtocol())) {
                    localRegistryUrl = ru.createCopy();
                    break;
                }
            }
            if (localRegistryUrl == null) {
                localRegistryUrl =
                        new URL(MotanConstants.REGISTRY_PROTOCOL_LOCAL, hostAddress, MotanConstants.DEFAULT_INT_VALUE,
                                RegistryService.class.getName());
            }
            urls.add(localRegistryUrl);
        } else {
            // TODO 我使用的是 local，因此会走到此处
            for (URL ru : registryURLs) {
                System.out.println(" ru "+ ru);
                urls.add(ru.createCopy());
            }
        }

        for (URL u : urls) {
            u.addParameter(URLParamType.embed.getName(), StringTools.urlEncode(serviceUrl.toFullStr()));
            registereUrls.add(u.createCopy());
        }
        // [local://127.0.0.1:0/com.weibo.api.motan.registry.RegistryService?group=default_rpc]
        System.out.println(" 8 registereUrls ==>" +registereUrls);
        ConfigHandler configHandler = ExtensionLoader.getExtensionLoader(ConfigHandler.class).getExtension(MotanConstants.DEFAULT_VALUE);
        // ~ [5]  ConfigHandler 如何加载 ~
        exporters.add(configHandler.export(interfaceClass, ref, urls));
        initLocalAppInfo(serviceUrl);
    }

    private void afterExport() {
        exported.set(true);
        for (Exporter ep : exporters) {
            existingServices.add(ep.getProvider().getUrl().getIdentity());
        }
    }

    private void afterUnexport() {
        exported.set(false);
        for (Exporter ep : exporters) {
            existingServices.remove(ep.getProvider().getUrl().getIdentity());
            exporters.remove(ep);
        }
        exporters.clear();
        registereUrls.clear();
    }

    @ConfigDesc(excluded = true)
    public BasicServiceInterfaceConfig getBasicService() {
        return basicService;
    }

    public Map getProtocolAndPort() {
        return ConfigUtil.parseExport(this.export);
    }

    @ConfigDesc(excluded = true)
    public String getHost() {
    }

}
  1. 无论是spring方式，还是api的方式，最终会调用export()方法
  1. loadRegistryUrls():返回注册中心地址，是一个list,打印出来后的结果如下：
    • []local://127.0.0.1:0/com.weibo.api.motan.registry.RegistryService?group=default_rpc]
    • AbstractInterfaceConfig#loadRegistryUrls 用于收集,serviceconfig中设置的注册中心信息

      motanDemoService.setRegistry(zookeeperRegistry);

  1. 执行 ServiceConfig#doExport() 方法
    1. 根据一系统 参数构造一个服务 service URL,请注意（motan中有register url ,servcieurl）

      URL serviceUrl = new URL(protocolName, hostAddress, port, interfaceClass.getName(), map);

    2. 此URL对象模仿了 java 标准api的方法 : protocol url param,后面再分析这个URL，这个是整个motan协议结构的中心
    3. 生成了 service url,然后，通过sip的方式，找到ConfigHandler的实现类 SimpleConfigHandler
      • ConfigHandler configHandler = ExtensionLoader.getExtensionLoader(ConfigHandler.class).getExtension(MotanConstants.DEFAULT_VALUE);
      • 通过configHandler个哦执行真正的export exporters.add(configHandler.export(interfaceClass, ref, urls))
        • configHandler.export(interfaceClass, ref, urls)

          将 interfaceClass， ref，向多个注册中心，注册

SimpleConfigHandler 执行服务暴露

[图片上传失败...(image-af38f-1563956674836)]


@SpiMeta(name = MotanConstants.DEFAULT_VALUE)
public class SimpleConfigHandler implements ConfigHandler {

    @Override
    public  ClusterSupport buildClusterSupport(Class interfaceClass, List registryUrls) {
        ClusterSupport clusterSupport = new ClusterSupport(interfaceClass, registryUrls);
        clusterSupport.init();
        return clusterSupport;
    }

    @Override
    public  T refer(Class interfaceClass, List> clusters, String proxyType) {
        ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getExtension(proxyType);
        return proxyFactory.getProxy(interfaceClass, new RefererInvocationHandler(interfaceClass, clusters));
    }

    @Override
    public  Exporter export(Class interfaceClass, T ref, List registryUrls) {
        // motan://10.14.162.137:8002/com.weibo.motan.demo.service.MotanDemoService?id=motan&export=motan:8002&protocol=motan&refreshTimestamp=1505801631928&group=motan-demo-rpc&nodeType=service&version=1.0&
        String serviceStr = StringTools.urlDecode(registryUrls.get(0).getParameter(URLParamType.embed.getName()));
        System.out.println("5 SimpleConfigHandler export serviceStr ==>" +serviceStr);

        URL serviceUrl = URL.valueOf(serviceStr);
        // export service
        // 利用protocol decorator来增加filter特性
        String protocolName = serviceUrl.getParameter(URLParamType.protocol.getName(), URLParamType.protocol.getValue());
        Protocol ss = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(protocolName);
        Protocol protocol = new ProtocolFilterDecorator(ss);

        //    com.weibo.api.motan.protocol.rpc.DefaultRpcProtocol@33f724c7
        System.out.println(" 11 default Protocol ==> " + ss);
        Provider provider = new DefaultProvider(ref, serviceUrl, interfaceClass);
        Exporter exporter = protocol.export(provider, serviceUrl);
        // register service
        register(registryUrls, serviceUrl);

        return exporter;
    }

    private void register(List registryUrls, URL serviceUrl) {
        for (URL url : registryUrls) {
            // 根据check参数的设置，register失败可能会抛异常，上层应该知晓
            RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getExtension(url.getProtocol());
            if (registryFactory == null) {
                throw  new  Excepiton(..);
            }
            Registry registry = registryFactory.getRegistry(url);
            registry.register(serviceUrl);
        }
    }

    private void unRegister(Collection registryUrls) {
        for (URL url : registryUrls) {
                 // 不管check的设置如何，做完所有unregistry，做好清理工作
                String serviceStr = StringTools.urlDecode(url.getParameter(URLParamType.embed.getName()));
                URL serviceUrl = URL.valueOf(serviceStr);
                RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getExtension(url.getProtocol());
                Registry registry = registryFactory.getRegistry(url);
                registry.unregister(serviceUrl);
            
        }
    }

}
SimpleConfigHandler#export()方法执行服务暴露(refer方法是客户端使用，暂时不讨论)

  1. motan服务协议的是怎么样的？

    • 根据注册地址生成servcie url ？
      • StringTools.urlDecode(registryUrls.get(0).getParameter(URLParamType.embed.getName()));
      • 为什么取的是注册地址第一个呢？ registryUrls.get(0).getParameter(URLParamType.embed.getName());
        1. motan://192.168.1.1:8002/com.weibo.motan.demo.service.MotanDemoService?id=motan&export=motan:8002&protocol=motan&refreshTimestamp=1505801631928&group=motan-demo-rpc&nodeType=service&version=1.0&
        2. String serviceStr =

  2. 服务协议初步分析:类似于java 标准api URL类的方式

    • motan 表示用motan协议
    • 192.168.1.1:8002: 当前服务的ip:port
    • com.weibo.motan.demo.service.MotanDemoService :接口名
    • ？号后面是参数，包括timestamp id version,group 等信息

  3. 将 Service url字符串转换成 motan URL对象

    • URL serviceUrl = URL.valueOf(serviceStr);

  4. 根据第3的URL对象。通过SPI机制找到对应的 Protocol 实现类

    • String protocolName = serviceUrl.getParameter(URLParamType.protocol.getName(), URLParamType.protocol.getValue());
    • Protocol ss = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(protocolName);

      com.weibo.api.motan.protocol.rpc.DefaultRpcProtocol@33f724c7

    • 使用decorate模拟，增强Protocol功能，添加过滤器，后面我在分析

      Protocol protocol = new ProtocolFilterDecorator(ss);

    • 使用默认Provider实现来暴露服务 DefaultProvider ，此为将是service impl的调用就是一个invoke而已
      1. Provider provider = new DefaultProvider(ref, serviceUrl, interfaceClass);
      2. DefaultProvider 本质上是通过 invoke(request) 根据reqeust 来找到对应的method,反射调用方法，仅此而已

    -- 如何将provider暴露 · Exporter exporter = protocol.export(provider, serviceUrl);·

    服务暴露成功，则将服务添加 到对应注册中心地址。先export 再register

DefaultProvider 如何封装服务端调用：原理
  1. 源代码

@SpiMeta(name = "motan")
public class DefaultProvider extends AbstractProvider {
   protected T proxyImpl;

   // TODO SIimpleConfigHandler 中调用引构造器
   public DefaultProvider(T proxyImpl, URL url, Class clz) {
       super(url, clz);
       this.proxyImpl = proxyImpl;
   }

   @Override
   public T getImpl(){   return proxyImpl;  }

   @Override
   public Response invoke(Request request) {
       DefaultResponse response = new DefaultResponse();
       // TODO netty 接收客户端请求，从中解析出方法名
       Method method = lookup(request);
       if (method == null) {
           // ... return ;
       }
       try {
           // TODO 因为defaultprovider中已经知道是这个接口实现类了，因此 只需要invoke即可完成
           Object value = method.invoke(proxyImpl, request.getArguments());
           response.setValue(value);
       } catch (Exception e) {/服务发生错误时，显示详细日志
       } catch (Throwable t) {
           // 如果服务发生Error，将Error转化为Exception，防止拖垮调用方         //对于Throwable,也记录日志
       }
       // 传递rpc版本和attachment信息方便不同rpc版本的codec使用。
       response.setRpcProtocolVersion(request.getRpcProtocolVersion());
       response.setAttachments(request.getAttachments());
       return response;
   }
}

[图片上传失败...(image-50c6d7-1563956674836)]

DefaultRpcProtocol 如何暴露 DefaultProvider
  1. 翠花上码

public class ProtocolFilterDecorator implements Protocol {
       public ProtocolFilterDecorator(Protocol protocol) {
            this.protocol = protocol; ///  TODO  默认使用  DefaultRpcProtocol 
        }
        @Override
        public  Exporter export(Provider provider, URL url) {
           // TODO 调用父类  AbstractProtocol#export方法
            return protocol.export(decorateWithFilter(provider, url), url);
        }
}

AbstractProtocol.java

public abstract class AbstractProtocol implements Protocol {
    protected ConcurrentHashMap> exporterMap = new ConcurrentHashMap>();

    @SuppressWarnings("unchecked")
    @Override
    public  Exporter export(Provider provider, URL url) {
        String protocolKey = MotanFrameworkUtil.getProtocolKey(url);
        synchronized (exporterMap) {
            Exporter exporter = (Exporter) exporterMap.get(protocolKey);
            // TODO  此处会回调子类    DefaultRpcProtocol#createExporter
            exporter = createExporter(provider, url);
            // TODO 回调 AbstractNode#init()
            exporter.init();
            exporterMap.put(protocolKey, exporter);
            return exporter;
        }
    }

    public  Referer refer(Class clz, URL url) {  }

    @Override
    public  Referer refer(Class clz, URL url, URL serviceUrl) {   // 略
    }

    protected abstract  Exporter createExporter(Provider provider, URL url);
    protected abstract  Referer createReferer(Class clz, URL url, URL serviceUrl);
}

DefaultRpcProtocol.java


@SpiMeta(name = "motan")
public class DefaultRpcProtocol extends AbstractProtocol {

    // 多个service可能在相同端口进行服务暴露，因此来自同个端口的请求需要进行路由以找到相应的服务，同时不在该端口暴露的服务不应该被找到
    private Map ipPort2RequestRouter = new HashMap();

    @Override
    protected  Exporter createExporter(Provider provider, URL url) {
        return new DefaultRpcExporter(provider, url);
    }

    @Override // 实现父类 
    protected  Referer createReferer(Class clz, URL url, URL serviceUrl) {
        return new DefaultRpcReferer(clz, url, serviceUrl);
    }

    class DefaultRpcExporter extends AbstractExporter {
        private Server server;
        private EndpointFactory endpointFactory;
        // TODO SPI 查找 endpointFactory ，用此创建 server  
        public DefaultRpcExporter(Provider provider, URL url) {
            super(provider, url);
            ProviderMessageRouter requestRouter = initRequestRouter(url);
            endpointFactory =  ExtensionLoader.getExtensionLoader(EndpointFactory.class).getExtension(
                            url.getParameter(URLParamType.endpointFactory.getName(), URLParamType.endpointFactory.getValue()));
            server = endpointFactory.createServer(url, requestRouter);
        }

        @Override
        public void unexport() {
            String protocolKey = MotanFrameworkUtil.getProtocolKey(url);
            String ipPort = url.getServerPortStr();
            Exporter exporter = (Exporter) exporterMap.remove(protocolKey);
            if (exporter != null) {
                exporter.destroy();
            }
            synchronized (ipPort2RequestRouter) {
                ProviderMessageRouter requestRouter = ipPort2RequestRouter.get(ipPort);
                if (requestRouter != null) {
                    requestRouter.removeProvider(provider);
                }
            }
        }

        @Override
        protected boolean doInit() {   server.open();  }

        private ProviderMessageRouter initRequestRouter(URL url) {
            ProviderMessageRouter requestRouter = null;
            String ipPort = url.getServerPortStr();
            synchronized (ipPort2RequestRouter) { //  TODO此处后面再分析 
                requestRouter = ipPort2RequestRouter.get(ipPort);
                if (requestRouter == null) {
                    requestRouter = new ProviderProtectedMessageRouter(provider);
                    ipPort2RequestRouter.put(ipPort, requestRouter);
                } else {
                    requestRouter.addProvider(provider);
                }
            }
            return requestRouter;
        }
    }

    class DefaultRpcReferer extends AbstractReferer {
        // TODO  先略去 
    }
}
  1. ProtocolFilterDecorator(DefaultRpcProtocol proto)
  2. 调用 AbstractProtocol.export();
  3. export()回调子类 createExporter();
  4. 创建内部类 DefaultRpcExporter
  5. 完成exporter实现

[图片上传失败...(image-a3794b-1563956674836)]

DefaultRpcExporter 是如何 暴露的
DefaultRpcExporter.java
class DefaultRpcExporter extends AbstractExporter {
    private Server server;
    private EndpointFactory endpointFactory;

    public DefaultRpcExporter(Provider provider, URL url) {
        // TODO 1 调用父类  AbstractExporter
        super(provider, url);
        // TODO 2 requestRouter 其作用是将 request 映射到provider上
        ProviderMessageRouter requestRouter = initRequestRouter(url);
       // TODO  3 通过SPI找到 endpoint ,相当于底层传输层实现，
        endpointFactory =   ExtensionLoader.getExtensionLoader(EndpointFactory.class).getExtension(
                        url.getParameter(URLParamType.endpointFactory.getName(), URLParamType.endpointFactory.getValue()));
        // TODO 4 根据endpointfactory创建服务器，Server是一个接口，默认实现是NettyServer.java后面专门会分析
        server = endpointFactory.createServer(url, requestRouter);
    }
}

public abstract class AbstractNode implements Node {
    @Override
    public synchronized void init() {
        if (init) {    return;    }
        boolean result = doInit();
    }
    // TODO DefaultRpcExporter会实现此方法
    protected abstract boolean doInit();
}
  1. 整体调用链
  • --> ProtocolFilterDecorator#export()
    • --> AbstractProtocol#export()
      • --> 1. exporter = abstract createExporter(provider, url)
        • --> DefaultRpcProtocol#createExporter() 回调子类的createExporter
      • <-- 2. exporter.init() 父类继续调用 exporter 的init方法
        • --> AbstractNode#init();
          • --> DefaultRpcExporter#doInit(); 做真实的doInit打开
          • --> 打开服务端server server.open()
      • <-- server 的初始化完成
  1. endpointFactory.createServer(url, requestRouter)是什么?
  1. 实现类是 NettyEndpointFactory
  2. 父类会回调 此类的 innerCreateClient()方法实例化NettyServer对象
@SpiMeta(name = "motan")
public class NettyEndpointFactory extends AbstractEndpointFactory {
    @Override
    protected Server innerCreateServer(URL url, MessageHandler messageHandler) {
        return new NettyServer(url, messageHandler);
    }

   //  TODO 此处会被你类回调 
    @Override
    protected Client innerCreateClient(URL url) {
        return new NettyClient(url);
    }
}



public abstract class AbstractEndpointFactory implements EndpointFactory {

    /** 维持share channel 的service列表 **/
    protected Map ipPort2ServerShareChannel = new HashMap();
    protected ConcurrentMap> server2UrlsShareChannel = new ConcurrentHashMap>();
    private EndpointManager heartbeatClientEndpointManager = null;

    public AbstractEndpointFactory() {
        // TODO  服务端Hheartbeat 
        heartbeatClientEndpointManager = new HeartbeatClientEndpointManager();
        heartbeatClientEndpointManager.init();
    }

    @Override
    public Server createServer(URL url, MessageHandler messageHandler) {
        HeartbeatFactory heartbeatFactory = getHeartbeatFactory(url);
        messageHandler = heartbeatFactory.wrapMessageHandler(messageHandler);
        synchronized (ipPort2ServerShareChannel) {
            String ipPort = url.getServerPortStr();
            System.out.println("createServer "+ipPort);
            String protocolKey = MotanFrameworkUtil.getProtocolKey(url);
            boolean shareChannel = url.getBooleanParameter(URLParamType.shareChannel.getName(), URLParamType.shareChannel.getBooleanValue());
            if (!shareChannel) { // 独享一个端口
                // 如果端口已经被使用了，使用该server bind 会有异常
                return innerCreateServer(url, messageHandler);
            }
            Server server = ipPort2ServerShareChannel.get(ipPort);
            if (server != null) {
                // can't share service channel
                if (!MotanFrameworkUtil.checkIfCanShallServiceChannel(server.getUrl(), url)) {
                }
                saveEndpoint2Urls(server2UrlsShareChannel, server, protocolKey);
                return server;
            }

            url = url.createCopy();
            url.setPath(""); // 共享server端口，由于有多个interfaces存在，所以把path设置为空
            // TODO  回调 NettyEndpointFactory# innerCreateServer
            server = innerCreateServer(url, messageHandler);
            ipPort2ServerShareChannel.put(ipPort, server);
            saveEndpoint2Urls(server2UrlsShareChannel, server, protocolKey);
            return server;
        }
    }

    @Override
    public Client createClient(URL url) {
        return createClient(url, heartbeatClientEndpointManager);
    }

    @Override
    public void safeReleaseResource(Server server, URL url) {
        safeReleaseResource(server, url, ipPort2ServerShareChannel, server2UrlsShareChannel);
    }

    @Override
    public void safeReleaseResource(Client client, URL url) { }

    private  void safeReleaseResource(T endpoint, URL url, Map ipPort2Endpoint,ConcurrentMap> endpoint2Urls) {
    }

    private  void saveEndpoint2Urls(ConcurrentMap> map, T endpoint, String namespace) { }

    private HeartbeatFactory getHeartbeatFactory(URL url) {}

    private Client createClient(URL url, EndpointManager endpointManager) {
        Client client = innerCreateClient(url);
        endpointManager.addEndpoint(client);
        return client;
    }
    protected abstract Server innerCreateServer(URL url, MessageHandler messageHandler);
    protected abstract Client innerCreateClient(URL url);

}

[图片上传失败...(image-c034a0-1563956674836)]

  1. createServer最终会返回一个new NettyServer(url, messageHandler);对象

public class NettyServer extends AbstractServer implements StatisticCallback {
    // default io thread is Runtime.getRuntime().availableProcessors() * 2
    private final static ChannelFactory channelFactory = new NioServerSocketChannelFactory(
            Executors.newCachedThreadPool(new DefaultThreadFactory("nettyServerBoss", true)),
            Executors.newCachedThreadPool(new DefaultThreadFactory("nettyServerWorker", true)));

    // 单端口需要对应单executor 1) 为了更好的隔离性 2) 为了防止被动releaseExternalResources:
    private StandardThreadExecutor standardThreadExecutor = null;
    
    protected NettyServerChannelManage channelManage = null;
    private org.jboss.netty.channel.Channel serverChannel;
    private ServerBootstrap bootstrap;
    private MessageHandler messageHandler;

    public NettyServer(URL url, MessageHandler messageHandler) {
        // TODO  调用父类构造器，初始化 encode ,decode 
        super(url);
        /** T
            public AbstractServer(URL url) {
                this.url = url;
                this.codec =
                        ExtensionLoader.getExtensionLoader(Codec.class).getExtension(
                                url.getParameter(URLParamType.codec.getName(), URLParamType.codec.getValue()));
            }
        */
        this.messageHandler = messageHandler;
    }

    @Override
    public Response request(Request request) throws TransportException {
        throw new MotanFrameworkException("NettyServer request(Request request) method unsupport: url: " + url);
    }

    @Override
    public synchronized boolean open() {
        if (isAvailable()) {
            return true;
        }

        initServerBootstrap();

        serverChannel = bootstrap.bind(new InetSocketAddress(url.getPort()));
        state = ChannelState.ALIVE;

        StatsUtil.registryStatisticCallback(this);
        LoggerUtil.info("NettyServer ServerChannel finish Open: url=" + url);

        return state.isAliveState();
    }

    private synchronized void initServerBootstrap() {
        boolean shareChannel = url.getBooleanParameter(URLParamType.shareChannel.getName(), URLParamType.shareChannel.getBooleanValue());
        final int maxContentLength = url.getIntParameter(URLParamType.maxContentLength.getName(),   URLParamType.maxContentLength.getIntValue());
        int maxServerConnection = url.getIntParameter(URLParamType.maxServerConnection.getName(),           URLParamType.maxServerConnection.getIntValue());
        int workerQueueSize = url.getIntParameter(URLParamType.workerQueueSize.getName(),URLParamType.workerQueueSize.getIntValue());
        int minWorkerThread = 0, maxWorkerThread = 0;
        // TODO  .... 略 
        // TODO  StandardThreadExecutor 的目的 ？
        standardThreadExecutor = (standardThreadExecutor != null && !standardThreadExecutor.isShutdown()) ? standardThreadExecutor
                : new StandardThreadExecutor(minWorkerThread, maxWorkerThread, workerQueueSize,
                        new DefaultThreadFactory("NettyServer-" + url.getServerPortStr(), true));
        standardThreadExecutor.prestartAllCoreThreads();
        // 连接数的管理，进行最大连接数的限制 
        channelManage = new NettyServerChannelManage(maxServerConnection);
        bootstrap = new ServerBootstrap(channelFactory);
        bootstrap.setOption("child.tcpNoDelay", true);
        bootstrap.setOption("child.keepAlive", true);

        final NettyChannelHandler handler = new NettyChannelHandler(NettyServer.this, messageHandler,
                standardThreadExecutor);

        bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
            // FrameDecoder非线程安全，每个连接一个 Pipeline
            public ChannelPipeline getPipeline() {
                ChannelPipeline pipeline = Channels.pipeline();
                pipeline.addLast("channel_manage", channelManage);
                pipeline.addLast("decoder", new NettyDecoder(codec, NettyServer.this, maxContentLength));
                pipeline.addLast("encoder", new NettyEncoder(codec, NettyServer.this));
                pipeline.addLast("handler", handler);
                return pipeline;
            }
        });
    }

    @Override
    public synchronized void close() {
        close(0);
    }

    @Override
    public synchronized void close(int timeout) {
        if (state.isCloseState()) {
            return;
        }
        if (state.isUnInitState()) {
            return;
        }
        try {
            // close listen socket
            serverChannel.close();
            // close all clients's channel
            channelManage.close();
            // shutdown the threadPool
            standardThreadExecutor.shutdownNow();
            // 设置close状态
            state = ChannelState.CLOSE;
            // 取消统计回调的注册
            StatsUtil.unRegistryStatisticCallback(this);
        } catch (Exception e) {
        }
    }

    /**
     * 统计回调接口
     */
    @Override
    public String statisticCallback() {
    }

    /**
     * 是否已经绑定端口
     */
    @Override
    public boolean isBound() {
        return serverChannel != null && serverChannel.isBound();
    }
}

  1. NettyServer.open()做了什么？ 创建了一个netty server ，监听 指定端口。

    • 设置 ip port
    • 在pipeline中增加channel factory
    • 增加编码，解码器 codes :后面分析
    • 注册业务handler : NettyChannelHandler

      pipeline.addLast("handler", handler);

  2. NettyChannelHandler 的逻辑是什么？

[图片上传失败...(image-cb6175-1563956674836)]

继承了Netty包中的 SimpleChannelHandler 复写父类的三个方法

  • channelConnected

  • channelDisconnected

  • messageReceived(ChannelHandlerContext ctx, MessageEvent e) 主要处理逻辑

  • 主要逻辑：

    • 判断e事件类型motan定义的 Request ==> processRequest(ctx, e);
    • 判断e事件类型motan定义的 Response ==> processResponse(ctx, e);
    • 对于 server来说 Request 主要来自于client的请求

  • processRequest 逻辑如下：

    • 每一个request会被封装成一个Runnable作为task 供线程池处理
      • threadPoolExecutor.execute(new Runnable() {
        processRequest(ChannelHandlerContext ctx, Request request, long processStartTime) {
        }
      • processRequest(ChannelHandlerContext ctx, Request request, long processStartTime)实现关键内容

        Object result = messageHandler.handle(serverChannel, request); ***
        - 获取 service imp的方法调用结果，将结果写入netty 通道。

  • messageHandler 是什么？作用

    • 对于每一个request请求，服务端需要路由找到对应的接口实现方法，然后invoke得到结果
    • messageHandler从如果来的 DefaultRpcExporter 的构造函数创建，通过encpoint factory方法传递进来的
public class NettyChannelHandler extends SimpleChannelHandler {
    private ThreadPoolExecutor threadPoolExecutor;
    private MessageHandler messageHandler;
    private Channel serverChannel;

    public NettyChannelHandler(Channel serverChannel, MessageHandler messageHandler,
            ThreadPoolExecutor threadPoolExecutor) {
        this.serverChannel = serverChannel;
        this.messageHandler = messageHandler;
        this.threadPoolExecutor = threadPoolExecutor;
    }

    @Override
    public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    }

    @Override
    public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        Object message = e.getMessage();

        if (message instanceof Request) {
            processRequest(ctx, e);
        } else if (message instanceof Response) {
            processResponse(ctx, e);
        } else {
            throw new  Exception();
        }
    }

    /**
     *  request process: 主要来自于client的请求，需要使用threadPoolExecutor进行处理，避免service message处理比较慢导致iothread被阻塞
     */
    private void processRequest(final ChannelHandlerContext ctx, MessageEvent e) {
        final Request request = (Request) e.getMessage();
        request.setAttachment(URLParamType.host.getName(), NetUtils.getHostName(ctx.getChannel().getRemoteAddress()));
        final long processStartTime = System.currentTimeMillis();
        // 使用线程池方式处理
        try {
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try{
                        RpcContext.init(request);
                        System.out.println("ctx instance ==>" +ctx.toString());
                        processRequest(ctx, request, processStartTime);
                    }finally{
                        RpcContext.destroy();
                    }
                }
            });
        } catch (RejectedExecutionException rejectException) {
        }
    }

    private void processRequest(ChannelHandlerContext ctx, Request request, long processStartTime) {
        // TODO 根据 路由判断，找到对应的rpvoder#invoke 其实最终找到的是DefautlProvider类 
        Object result = messageHandler.handle(serverChannel, request);
        DefaultResponse response = null;
        if (!(result instanceof DefaultResponse)) {
            response = new DefaultResponse(result);
        } else {
            response = (DefaultResponse) result;
        }
        response.setRequestId(request.getRequestId());
        response.setProcessTime(System.currentTimeMillis() - processStartTime);
        if (ctx.getChannel().isConnected()) {
            // TODO 回写结果到客户端
            ctx.getChannel().write(response);
        }
    }

    private void processResponse(ChannelHandlerContext ctx, MessageEvent e) {
        messageHandler.handle(serverChannel, e.getMessage());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
        ctx.getChannel().close();
    }
}

稍微总结一下

ServiceConfig #export())

  • -> doExport()
    • -> ConfigHandler的实现 SimpleConfigHandler#export
      • -> 构造service url
      • -> 构造s Protocol 默认实现类 DefaultProtocol
      • -> 构造s Provider 默认实现类 DefaultProvider
      • -> Protocol.exporter(provider,serviceUrl ) 构造s Exporter 默认实现类
        • -> DefaultRpcProtocol#createExporter : new DefaultRpcExporter() 实例后 init
          • -> DefaultRpcExporter构造器
            • -> 实例化 server:生成一个nettyserver对象，使用netty api构造一个bootstrap监听 指定端口
            • -> 实例化 ProviderMessageRouter 路由
          • -> DefaultRpcExporter 实例 doInit()
            • -> server.open(); 完成服务端端口监听 服务启动。

服务端如何解析Request请求

{ client send r equest } --> { network } --> { server listen port }

服务端server.open后，监听 指定端口，获取网络数据流

netty server 如何解析这个网络请求数据，并将其反序列化成 Request对象


class NettyServer{
   public void  initServerBootstrap() {
       // TODO 获取网络流后,使用 NettyDecoder对数据流进行解码
        pipeline.addLast("decoder", new NettyDecoder(codec, NettyServer.this, maxContentLength));
        pipeline.addLast("encoder", new NettyEncoder(codec, NettyServer.this));
   }
}

NettyEncoder NettyDecoder最终调用的是 DefaultRpcCodec

  1. 对于client发起的request请求
    • NettyClient : encode
    • ↓ Request ↑
    • NettServer : decode
  2. 对于server 发起的 response 请求
    • NettyClient : decode
    • ↓ response ↑
    • NettServer : encode

DefaultRpcCodec逻辑:

  1. NettyClient encode逻辑
  • writye body : interfacename,methodname ,method paramter
  • writye head : 16个字节
  • head + body (对象使用hessian序列化)
  1. NettyServer decode 逻辑
  • writye head : 16个字节
  • writye body : interfacename,methodname ,method paramter
  • body (对象使用hessian序列化)
  • server 找到了接口方法，及参数值 ，下面接着如何找到对应的provider调用
public class DefaultRpcCodec extends AbstractCodec {
    private static final short MAGIC = (short) 0xF0F0;
    private static final byte MASK = 0x07;

    @Override
    public byte[] encode(Channel channel, Object message) throws IOException {
        if (message instanceof Request) {
            return encodeRequest(channel, (Request) message);
        } else if (message instanceof Response) {
            return encodeResponse(channel, (Response) message);
        }
    }
    /**request body 数据：
     */
    private byte[] encodeRequest(Channel channel, Request request) throws IOException {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ObjectOutput output = createOutput(outputStream);
        //  TODO 生成协议body 
        //  TODO 1 接口名
        output.writeUTF(request.getInterfaceName());
        //  TODO 1 方法名    
        output.writeUTF(request.getMethodName());
        //  TODO 3 方法参数类型
        output.writeUTF(request.getParamtersDesc());
        // TODO 4 使用hessian序列化类
        Serialization serialization =
                ExtensionLoader.getExtensionLoader(Serialization.class).getExtension(
                        channel.getUrl().getParameter(URLParamType.serialize.getName(), URLParamType.serialize.getValue()));

        if (request.getArguments() != null && request.getArguments().length > 0) {
            for (Object obj : request.getArguments()) {
                // TODO 使用hhessain序列化object
                serialize(output, obj, serialization);
            }
        }
        output.writeInt(request.getAttachments().size());
        for (Map.Entry entry : request.getAttachments().entrySet()) {
            output.writeUTF(entry.getKey());
            output.writeUTF(entry.getValue());
        }
        output.flush();
        byte[] body = outputStream.toByteArray();
        byte flag = MotanConstants.FLAG_REQUEST;
        output.close();
        // TODO 5 将motan 协议头与body内容合并
        return encode(body, flag, request.getRequestId());
    }
    
    /**
     * 数据协议：
     * header:  16个字节 
     * 0-15 bit     :  magic
     * 16-23 bit    :  version
     * 24-31 bit    :  extend flag , 其中： 29-30 bit: event 可支持4种event，比如normal, exception等,  31 bit : 0 is request , 1 is response 
     * 32-95 bit    :  request id
     * 96-127 bit   :  body content length
     */
    private byte[] encode(byte[] body, byte flag, long requestId) throws IOException {
        byte[] header = new byte[RpcProtocolVersion.VERSION_1.getHeaderLength()];
        int offset = 0;

        // 0 - 15 bit : magic  标识这是一个motan协议
        ByteUtil.short2bytes(MAGIC, header, offset);
        offset += 2;

        // 16 - 23 bit : version  标识协议版本
        header[offset++] = RpcProtocolVersion.VERSION_1.getVersion();

        // 24 - 31 bit : extend flag  
        header[offset++] = flag;

        // 32 - 95 bit : requestId
        ByteUtil.long2bytes(requestId, header, offset);
        offset += 8;

        // 96 - 127 bit : body content length
        ByteUtil.int2bytes(body.length, header, offset);
        byte[] data = new byte[header.length + body.length];
        System.arraycopy(header, 0, data, 0, header.length);
        System.arraycopy(body, 0, data, header.length, body.length);
        return data;
    }  
     
  /**
     * decode data
     *      对于client端：主要是来自server端的response or exception
     *      对于server端: 主要是来自client端的request
     */
    @Override
    public Object decode(Channel channel, String remoteIp, byte[] data) throws IOException {
        if (data.length <= RpcProtocolVersion.VERSION_1.getHeaderLength()) {
        }
        short type = ByteUtil.bytes2short(data, 0);
        if (data[2] != RpcProtocolVersion.VERSION_1.getVersion()) { //TODO 
        }
        // TODO 解码头码数据
        int bodyLength = ByteUtil.bytes2int(data, 12);
        byte flag = data[3];
        byte dataType = (byte) (flag & MASK);
        boolean isResponse = (dataType != MotanConstants.FLAG_REQUEST);
        byte[] body = new byte[bodyLength];
        // TODO 解码body内容
        System.arraycopy(data, RpcProtocolVersion.VERSION_1.getHeaderLength(), body, 0, bodyLength);

        long requestId = ByteUtil.bytes2long(data, 4);
        Serialization serialization =
                ExtensionLoader.getExtensionLoader(Serialization.class).getExtension(
                        channel.getUrl().getParameter(URLParamType.serialize.getName(), URLParamType.serialize.getValue()));
        if (isResponse) { // response
            return decodeResponse(body, dataType, requestId, serialization);
        } else {
            return decodeRequest(body, requestId, serialization);
        }
         
    }
    

    private Object decodeRequest(byte[] body, long requestId, Serialization serialization) throws IOException, ClassNotFoundException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(body);
        ObjectInput input = createInput(inputStream);
       // TODO  body内容解码 与encode是个逆向操作
        String interfaceName = input.readUTF();
        String methodName = input.readUTF();
        String paramtersDesc = input.readUTF();

        DefaultRequest rpcRequest = new DefaultRequest();
        rpcRequest.setRequestId(requestId);
        rpcRequest.setInterfaceName(interfaceName);
        rpcRequest.setMethodName(methodName);
        rpcRequest.setParamtersDesc(paramtersDesc);
        rpcRequest.setArguments(decodeRequestParameter(input, paramtersDesc, serialization));
        rpcRequest.setAttachments(decodeRequestAttachments(input));
        input.close();
        return rpcRequest;
    }

    private Object decodeResponse(byte[] body, byte dataType, long requestId, Serialization serialization) throws IOException,
            ClassNotFoundException {
        // ......
        return response;
    }
}

于是又回到了 NettyChannelHandler处理业务请求转发

class NettyChannelHandler{
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
            Object message = e.getMessage();
            if (message instanceof Request) {
                processRequest(ctx, e);
             }
    }
        
    private void processRequest(ChannelHandlerContext ctx, Request request, long processStartTime) {
        Object result = messageHandler.handle(serverChannel, request);
    }
}
  1. messageHandler实现方法路由？如何找到指定接口的实现类
     class DefaultRpcExporter extends AbstractExporter {   
       public DefaultRpcExporter (){
          requestRouter = new ProviderProtectedMessageRouter(provider);  
       }
      }
  1. 还记得DefaultRpcExporter类么
  • ProviderMessageRouter#handler
    • -> ProviderMessageRouter#call方法
      • -> super.lookup():找到method
    • -> method.invoke() 生成结果

[图片上传失败...(image-971f7f-1563956674836)]

3 DefaultRpcProvider#call

  • AbstractProvider#invoke

class DefaultRpcProvider {
    public Response invoke(Request request) {
       DefaultResponse response = new DefaultResponse();
       //  TODO AbstractProvider#lookup找到对应的方法
       Method method = lookup(request);
       if (method == null) {    return response;      }
       // TODO 反射回调，生成response对象，netty server 的pipeline对response进行编码，发送至客户端 
       Object value = method.invoke(proxyImpl, request.getArguments());
       response.setValue(value);
                   
       // 传递rpc版本和attachment信息方便不同rpc版本的codec使用。
       response.setRpcProtocolVersion(request.getRpcProtocolVersion());
       response.setAttachments(request.getAttachments());
       return response;
   }
}

class AbstractProvider {
    protected Method lookup(Request request) {
          String methodDesc = ReflectUtil.
              getMethodDesc(request.getMethodName(), request.getParamtersDesc());
          return methodMap.get(methodDesc);
      }
}

Client客户端启动过程

API方式

    // 设置接口及实现类
    RefererConfig motanDemoServiceReferer = new RefererConfig();
    motanDemoServiceReferer.setInterface(MotanDemoService.class);
    
    // 配置服务的group以及版本号
    // 配置注册中心直连调用
    // 配置ZooKeeper注册中心
    
    // 配置RPC协议
    ProtocolConfig protocol = new ProtocolConfig();
    protocol.setId("motan");
    protocol.setName("motan");
    motanDemoServiceReferer.setProtocol(protocol);
    motanDemoServiceReferer.setDirectUrl("localhost:8002");  // 注册中心直连调用需添加此配置
    // 使用服务
    MotanDemoService service = motanDemoServiceReferer.getRef();
    service.hello("motan " +i)

RefererConfig 设置接口类即可

public class RefererConfig extends AbstractRefererConfig {
    private Class interfaceClass;
    // 具体到方法的配置
    protected List methods;
    // 点对点直连服务提供地址
    private String directUrl;
    private AtomicBoolean initialized = new AtomicBoolean(false);

    private T ref;
    public T getRef() {
        if (ref == null) {
            initRef();
        }
        return ref;
    }

    public synchronized void initRef() {
        if (initialized.get()) {
            return;
        }
        interfaceClass = (Class) Class.forName(interfaceClass.getName(), true, Thread.currentThread().getContextClassLoader());
        checkInterfaceAndMethods(interfaceClass, methods);
        clusterSupports = new ArrayList>(protocols.size());
        List> clusters = new ArrayList>(protocols.size());
        String proxy = null;

        ConfigHandler configHandler = ExtensionLoader.getExtensionLoader(ConfigHandler.class).getExtension(MotanConstants.DEFAULT_VALUE);

        List registryUrls = loadRegistryUrls();
        String localIp = getLocalHostAddress(registryUrls);
        for (ProtocolConfig protocol : protocols) {
            Map params = new HashMap();
            params.put(URLParamType.nodeType.getName(), MotanConstants.NODE_TYPE_REFERER);
            // TODO 生成ref url
            URL refUrl = new URL(protocol.getName(), localIp, MotanConstants.DEFAULT_INT_VALUE, interfaceClass.getName(), params);
            ClusterSupport clusterSupport = createClusterSupport(refUrl, configHandler, registryUrls);
            clusterSupports.add(clusterSupport);
            clusters.add(clusterSupport.getCluster());
            
            proxy = (proxy == null) ? refUrl.getParameter(URLParamType.proxy.getName(), URLParamType.proxy.getValue()) : proxy;
        }
        // TODO 根据接口类生成代理类。完成底层 transport的传输
        ref = configHandler.refer(interfaceClass, clusters, proxy);
        initialized.set(true);
    }
}

关键点

   `ref = configHandler.refer(interfaceClass, clusters, proxy);`
  • 熟悉的 SimpleConfigHandler.java
public class SimpleConfigHandler implements ConfigHandler {

    @Override
    public  ClusterSupport buildClusterSupport(Class interfaceClass, List registryUrls) {
        ClusterSupport clusterSupport = new ClusterSupport(interfaceClass, registryUrls);
        clusterSupport.init();
        return clusterSupport;
    }

    @Override
    public  T refer(Class interfaceClass, List> clusters, String proxyType) {
        // TODO 依旧是对过SPI，找到客情端代理工厂，生成代理类 
        ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getExtension(proxyType);
        return proxyFactory.getProxy(interfaceClass, new RefererInvocationHandler(interfaceClass, clusters));
    }
}

代理是什么

  1. 静态代理（静态定义代理类，我们自己静态定义的代理类。比如我们自己定义一个明星的经纪人类）

         //  每一个接口类都要创建一个对应的代理类，增加了代码量。 其次一旦接口发生变化，代理也要修改。     
     public interface Star {
         void confer();//面谈
     }
     public class ProxyStar implements Star{
         private Star star;//真实对象的引用（明星）
         @Override
         public void confer() {
             System.out.println("ProxyStar.confer() start ");
             star.confer(); // TODO 此处才是真实对象的调用
             System.out.println("ProxyStar.confer() end ");
         }
     }
     
     public class RealStar implements Star{
         @Override
         public void confer() {
             System.out.println("RealStar.confer()");
         }
     }
     public static void main(String[] args) {
         Star real = new RealStar();
         Star proxy = new ProxyStar(real);
         proxy.sing();//真实对象的操作（明星唱歌）
     }

  2. 动态代理（通过程序动态生成代理类，该代理类不是我们自己定义的。运行期间由JVM根据反射等机制动态的生！

  3. 怎么样创建的代理 motan中使用 com.weibo.api.motan.proxy.spi.JdkProxyFactory

     public class JdkProxyFactory implements ProxyFactory {
     // 使用JDK 动态代理
     @SuppressWarnings("unchecked")
     public  T getProxy(Class clz, InvocationHandler invocationHandler) {
         return (T) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[] {clz}, invocationHandler);
     }
 }


public class RefererInvocationHandler implements InvocationHandler {

    private List> clusters;
    private Class clz;
    private SwitcherService switcherService = null;
    private String interfaceName;

    public RefererInvocationHandler(Class clz, Cluster cluster) {
        init();
    }

    public RefererInvocationHandler(Class clz, List> clusters) {
        this.clz = clz;
        this.clusters = clusters;
        init();
    }

    private void init() {
        // clusters 不应该为空
        String switchName =
                this.clusters.get(0).getUrl().getParameter(URLParamType.switcherService.getName(), URLParamType.switcherService.getValue());
        switcherService = ExtensionLoader.getExtensionLoader(SwitcherService.class).getExtension(switchName);
        interfaceName = MotanFrameworkUtil.removeAsyncSuffix(clz.getName());
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (isLocalMethod(method)) {
            throw new MotanServiceException("can not invoke local method:" + method.getName());
        }
        DefaultRequest request = new DefaultRequest();
        request.setRequestId(RequestIdGenerator.getRequestId());
        request.setArguments(args);
        String methodName = method.getName();
        boolean async = false;
        if (methodName.endsWith(MotanConstants.ASYNC_SUFFIX) && method.getReturnType().equals(ResponseFuture.class)) {
            methodName = MotanFrameworkUtil.removeAsyncSuffix(methodName);
            async = true;
        }
        RpcContext.getContext().putAttribute(MotanConstants.ASYNC_SUFFIX, async);
        //  TODO   主要是设置 request 中的方法包，参数等信息
        request.setMethodName(methodName);
        request.setParamtersDesc(ReflectUtil.getMethodParamDesc(method));
        request.setInterfaceName(interfaceName);
        request.setAttachment(URLParamType.requestIdFromClient.getName(), String.valueOf(RequestIdGenerator.getRequestIdFromClient()));

        // 当 referer配置多个protocol的时候，比如A,B,C，
        // 那么正常情况下只会使用A，如果A被开关降级，那么就会使用B，B也被降级，那么会使用C
        for (Cluster cluster : clusters) {
            String protocolSwitcher = MotanConstants.PROTOCOL_SWITCHER_PREFIX + cluster.getUrl().getProtocol();
            Switcher switcher = switcherService.getSwitcher(protocolSwitcher);
            if (switcher != null && !switcher.isOn()) {
                continue;
            }
            request.setAttachment(URLParamType.version.getName(), cluster.getUrl().getVersion());
            request.setAttachment(URLParamType.clientGroup.getName(), cluster.getUrl().getGroup());
            // 带上client的application和module
            Response response = null;
            try {
                //  TODO 代码 cluster调用远程服务,本质上是将reqeust的相关信息发送到服务端
                response = cluster.call(request);
                if (async && response instanceof ResponseFuture) {
                    return response;
                } else {
                    return response.getValue();
                }
            } catch (RuntimeException e) {
            }
        }
    }
}

客户端如何选择一个服务地址呢--集群中选择

集群 cluster.call(request) ，这里cluster是什么？
  1. cluster是一系列[] interface,registryUrls] 的配置类的对象集合
    ClusterSupport clusterSupport = new ClusterSupport(interfaceClass, registryUrls);
    clusters.add(clusterSupport.getCluster());
  2. ClusterSupport 做了什么?
  • ClusterSupport 提供了对Cluster的一些辅助工作，cluster生成，参数初始化
class ClusterSupport {

    private void prepareCluster() {
           String clusterName = url.getParameter(URLParamType.cluster.getName(), URLParamType.cluster.getValue());
           String loadbalanceName = url.getParameter(URLParamType.loadbalance.getName(), URLParamType.loadbalance.getValue());
           String haStrategyName = url.getParameter(URLParamType.haStrategy.getName(), URLParamType.haStrategy.getValue());
           // TODO 通过SPI获取默认的  负载均衡实现  ，高可用策略实现 
           System.out.println(lusterName); // default
           System.out.println(" " +loadbalanceName); // activeWeight
           System.out.println(" " +haStrategyName);  // failover
           
           cluster = ExtensionLoader.getExtensionLoader(Cluster.class).getExtension(clusterName);
           LoadBalance loadBalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(loadbalanceName);
           HaStrategy ha = ExtensionLoader.getExtensionLoader(HaStrategy.class).getExtension(haStrategyName);
           cluster.setLoadBalance(loadBalance);
           cluster.setHaStrategy(ha);
           cluster.setUrl(url);
       }
}

  • cluster的 HaStrategy 与 LoadBalance

    • 负载均衡的实现 com.weibo.api.motan.cluster.loadbalance.ActiveWeightLoadBalance
    • 高可用策略实现 com.weibo.api.motan.cluster.ha.FailoverHaStrategy

    [图片上传失败...(image-b7a9d7-1563956674836)]

    [图片上传失败...(image-39b478-1563956674836)]

集群 cluster ，是如何将ha 策略与loadbalance结合起来的呢
什么是HA,高可用
  1. 在集群服务器架构中，当主服务器故障时，备份服务器能够自动接管主服务器的工作，
    并及时切换过去，以实现对用户的不间断服务。这里我感觉它跟故障转移(failover)是一个意思，
  2. 简单的理解：当调用制作时，是直接返回结果，还是重试一定的次数来得到最终结果
  3. motan支持的HaStrategy只有两种：FailfastHatrategy和FailoverStrategy
什么是 LoadBalance
  1. 如何处理高并发带来的系统性能问题，最终大家都会使用负载均衡机制。
    它是根据某种负载策略把请求分发到集群中的每一台服务器上，让整个服务器群来处理网站的请求。
  2. 简单的理解就是如何选择一个合理的请求服务端地址
HA与 LoadBalance的关系
  1. ha向 lB发出请求，lb通过一定机制找到负载全蓝的服务端地址
  2. ha向这个服务端url发出网络请求，根据ha的策略。对请求的次数，时间待作出一定的处理
    直接返回或者重试N次请求
HA源代码分析
public class FailfastHaStrategy extends AbstractHaStrategy {
    @Override
    public Response call(Request request, LoadBalance loadBalance) {
        Referer refer = loadBalance.select(request);
        // 找到一个refer call 
        return refer.call(request);
    }
}
// TODO 最多尝试N次
public class FailoverHaStrategy extends AbstractHaStrategy {

    protected ThreadLocal>> referersHolder = new ThreadLocal>>() {
        @Override
        protected java.util.List> initialValue() {
            return new ArrayList>();
        }
    };

    @Override
    public Response call(Request request, LoadBalance loadBalance) {
        List> referers = selectReferers(request, loadBalance);
        if (referers.isEmpty()) {
            throw new MotanServiceException("xx");
        }
        URL refUrl = referers.get(0).getUrl();
        // 先使用method的配置
        int tryCount =   refUrl.getMethodParameter(request.getMethodName(), request.getParamtersDesc(), URLParamType.retries.getName(),    URLParamType.retries.getIntValue());
        // 如果有问题，则设置为不重试
        if (tryCount < 0) {
            tryCount = 0;
        }

        for (int i = 0; i <= tryCount; i++) {
            Referer refer = referers.get(i % referers.size());
            try {
                request.setRetries(i);
                return refer.call(request);
            } catch (RuntimeException e) {
            }
        }
    }

    protected List> selectReferers(Request request, LoadBalance loadBalance) {
        List> referers = referersHolder.get();
        referers.clear();
        loadBalance.selectToHolder(request, referers);
        return referers;
    }

}
LoadBalance 的实现分析
  1. ActivieWegithLoadBalance 最少并发优先，怎么计算并发量？很简单，通过原子计数器即可

@SpiMeta(name = "activeWeight")
public class ActiveWeightLoadBalance extends AbstractLoadBalance {

    @Override
    protected Referer doSelect(Request request) {
        List> referers = getReferers();
        int refererSize = referers.size();
        int startIndex = ThreadLocalRandom.current().nextInt(refererSize);
        int currentCursor = 0;
        int currentAvailableCursor = 0;
        Referer referer = null;

        while (currentAvailableCursor < MAX_REFERER_COUNT && currentCursor < refererSize) {
            Referer temp = referers.get((startIndex + currentCursor) % refererSize);
            currentCursor++;

            if (!temp.isAvailable()) {
                continue;
            }

            currentAvailableCursor++;

            if (referer == null) {
                referer = temp;
            } else {
                if (compare(referer, temp) > 0) {
                    referer = temp;
                }
            }
        }

        return referer;
    }

    @Override
    protected void doSelectToHolder(Request request, List> refersHolder) {
        List> referers = getReferers();

        int refererSize = referers.size();
        int startIndex = ThreadLocalRandom.current().nextInt(refererSize);
        int currentCursor = 0;
        int currentAvailableCursor = 0;

        while (currentAvailableCursor < MAX_REFERER_COUNT && currentCursor < refererSize) {
            Referer temp = referers.get((startIndex + currentCursor) % refererSize);
            currentCursor++;

            if (!temp.isAvailable()) {
                continue;
            }

            currentAvailableCursor++;

            refersHolder.add(temp);
        }

        Collections.sort(refersHolder, new LowActivePriorityComparator());
    }

    private int compare(Referer referer1, Referer referer2) {
        return referer1.activeRefererCount() - referer2.activeRefererCount();
    }

    static class LowActivePriorityComparator implements Comparator> {
        @Override
        public int compare(Referer referer1, Referer referer2) {
            return referer1.activeRefererCount() - referer2.activeRefererCount();
        }
    }
}
  1. 问题来了，这里只看到 loadbalance#doSelect并没有看到，哪里将referer的权重变化
    • 生成一个随机数，然后使用取余来获取一个referer ，然后将referer进行sort排序
    • LowActivePriorityComparator 中比较的是 activeRefererCount()的值，那么这个值在lb中工没有看到变更
    • 由此怀疑，只能是在referer.call的时候，作的改变
Refer如何控制使用次数
  1. DefaultRpcReferer

public abstract class AbstractReferer extends AbstractNode implements Referer {

    protected Class clz;
    // todo 嘿嘿就在这里 
    protected AtomicInteger activeRefererCount = new AtomicInteger(0);
    protected URL serviceUrl;

    @Override
    public Response call(Request request) {
        if (!isAvailable()) {
        }
        // TODO  ha.call(request,loadbalance)
        // TODO 一旦被调用，则活动数量add ,实现则在具体类
        // TODO 默认策略会将计数器 +1
        incrActiveCount(request);
        Response response = null;
        try {
            response = doCall(request);
            return response;
        } finally {
            // TODO 释放activecount ,默认策略会将计数器-1
            decrActiveCount(request, response);
        }
    }

    @Override
    public int activeRefererCount() {
        return activeRefererCount.get();
    }

    protected void incrActiveCount(Request request) {
        activeRefererCount.incrementAndGet();
    }

    protected void decrActiveCount(Request request, Response response) {
        activeRefererCount.decrementAndGet();
    }

    protected abstract Response doCall(Request request);

    @Override
    public String desc() {
        return "[" + this.getClass().getSimpleName() + "] url=" + url;
    }

    @Override
    public URL getServiceUrl() {
        return serviceUrl;
    }

}

class DefaultRpcReferer extends AbstractReferer {
        private Client client;
        private EndpointFactory endpointFactory;

        public DefaultRpcReferer(Class clz, URL url, URL serviceUrl) {
            super(clz, url, serviceUrl);
            endpointFactory =
                    ExtensionLoader.getExtensionLoader(EndpointFactory.class).getExtension(
                            url.getParameter(URLParamType.endpointFactory.getName(), URLParamType.endpointFactory.getValue()));
            client = endpointFactory.createClient(url);
        }

        @Override
        protected Response doCall(Request request) {
            // 为了能够实现跨group请求，需要使用server端的group。
            request.setAttachment(URLParamType.group.getName(), serviceUrl.getGroup());
            return client.request(request);
        }

        @Override
        protected void decrActiveCount(Request request, Response response) {
            if (response == null || !(response instanceof Future)) {
                activeRefererCount.decrementAndGet();
                return;
            }
            Future future = (Future) response;
            future.addListener(new FutureListener() {
                @Override
                public void operationComplete(Future future) throws Exception {
                    activeRefererCount.decrementAndGet();
                }
            });
        }

        @Override
        protected boolean doInit() {
            boolean result = client.open();
            return result;
        }
    }
协议位 意义
0-15 bit magic
16-23 bit version
24-28 bit extend flag
29-30 bit event 比如normal, exception等
31 bit 0 is request , 1 is response
32-95 bit request id
96-127 bit body content length

SPI 机制

类加载机制 ：双亲选手

public class Test {
    public static void main(String[] args){
         ClassLoader loader = TestClassLoader.class.getClassLoader();  
        //获得加载ClassLoaderTest.class这个类的类加载器
        while(loader != null) {
            System.out.println(loader);
            loader = loader.getParent();    //获得父类加载器的引用
        }
        System.out.println(loader);
        // output >>>
        // sun.misc.Launcher$AppClassLoader@7b7035c6
        // sun.misc.Launcher$ExtClassLoader@3da997a
        // null
    }
  }
  1. 那么问题来了JDBC人驱动器接口定义是在java核心包中定义，而具体驱动实现是在mysql,oracle的第三方jar中提供
    是怎么做到的很。很明显这接口的与实现类是由不同的类加载器实现的，这似乎违背了前面所
    提到的parent委托机器。

2.为了解决这个矛盾 Java提供了一线程上下文的 thread classloader
Thread.currentThread().getContextClassLoader().

什么是SIP

SPI : Service Provider Interface

java spi就是提供这样的一个机制：为某个接口寻找服务实现的机制。有点类似IOC的思想，
就是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要。

SPI 规范

  1. java spi的具体约定为:当服务的提供者，

  2. 提供了服务接口的一种实现之后，

  3. 在jar包的META-INF/services/目录里同时创建一个以服务接口命名的文件。

  4. 该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候，

  5. 能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。

  6. 基于这样一个约定就能很好的找到服务接口的实现类，而不需要再代码里制定。
    jdk提供服务实现查找的一个工具类：java.util.ServiceLoader

    package my.xyz.spi;
    import java.util.List;
    public interface Search {
    public List serch(String keyword);
    }

    package com.xyz.factory;
    import java.util.Iterator;
    import java.util.ServiceLoader;
    import my.xyz.spi.Search;
    public class SearchFactory {
    private SearchFactory() {
    }
    public static Search newSearch() {
    Search search = null;
    ServiceLoader serviceLoader = ServiceLoader.load(Search.class);
    Iterator searchs = serviceLoader.iterator();
    if (searchs.hasNext()) {
    search = searchs.next();
    }
    return search;
    }
    }

 package my.xyz.test;  
 import java.util.Iterator;  
 import java.util.ServiceLoader;  
 import com.xyz.factory.SearchFactory;  
 import my.xyz.spi.Search;  
 public class SearchTest {  
     public static void main(String[] args) {  
         Search search = SearchFactory.newSearch();  
         search.serch("java spi test");  
     }  
 }

http://www.mamicode.com/info-detail-1328167.html

|   URL  |   URL  |
| ------- | ---- |
| htt   |      ||

你可能感兴趣的:(2019-07-24 Motan RPC 框架分析)

  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理 木南曌 dubbo架构
    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
  • 以太坊DApp开发指南 Kirn
    DApp架构设计DApp架构.png如上图，DApp的架构我们可以简单分为以上三种类型：轻钱包模式、重钱包模式和兼容模式。轻钱包模式轻钱包模式下我们需要有一个开放HttpRPC协议的节点与钱包通信，这个节点可以是任意链上的节点。轻钱包通常会作为一个浏览器插件存在，插件在运行时会自动注入Web3框架，DApp可以通过Web3与区块链节点通信。当DApp只是单纯的获取数据时是不需要钱包介入的，但是当D
  • nfs服务搭建 GHope
    nfs是什么？基哥度娘网络文件系统(NFS)是sun微系统最初开发的分布式文件系统协议,[1]允许客户端计算机上的用户通过计算机网络访问文件很像本地存储被访问。NFS与许多其他协议一样,在开放网络计算远程过程调用(很久以前RPC)系统上建立。NFS是在请求注释(RFC)中定义的开放标准,允许任何人实现协议。NFSNFS优势：节省本地存储空间，将常用的数据存放在一台NFS服务器上且可以通过网络访问，
  • 深入解析 Dubbo 的 attachments 机制及其应用场景 molashaonian dubboattachments隐式传参
    背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
  • 【大模型】triton inference server idiotyi 大模型自然语言处理语言模型人工智能
    前言：tritoninferenceserver常用于大模型部署，可以采用http或GRPC调用，支持大部分的backend，单GPU、多GPU都可以支持，CPU也支持。本文主要是使用tritoninferenceserver部署大模型的简单流程示例。目录1.整体流程2.搭建本地仓库3.服务端代码4.启动服务5.客户端调用1.整体流程搭建模型仓库模型配置服务端调用代码docker启动服务客户端调用
  • 自己实现一个简易RPC调用框架 殷俊杰
    最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
  • Netty权威指南：Netty总结-高性能与可靠性 Ty_1106 Nettyjava网络rpc
    第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
  • Dubbo 与 Zookeeper 在项目中的应用：原理与实现详解 CopyLower 学习Javadubbozookeeper分布式
    引言在微服务架构日益普及的今天，如何实现服务的高效调用和管理成为了关键问题。Dubbo作为阿里巴巴开源的高性能RPC框架，在分布式服务治理方面具有显著的优势。Zookeeper作为一款分布式协调服务，能够高效地管理和协调服务节点信息。因此，Dubbo与Zookeeper的结合不仅能够提供服务注册与发现机制，还能实现更高效的服务治理。在本文中，我们将深入探讨Dubbo和Zookeeper的原理、如何
  • 一篇文章讲清楚ECC和S/4HANA的主要区别 syounger SAP学习制造
    今天给大家分享一下SAPECC和SAPS/4HANA的主要区别，开始比较之前，让我们先回顾一下这两款SAP的重量级ERP产品。什么是SAPECC？SAPECC全称是SAPERP中央组件(ERPCentralComponent）。SAPECC采用模块化设计，可高度定制。我们可以配置SAPECC以满足业务各个领域的需求，从财务到后勤。什么是SAPS/4HANA？SAPS/4HANA是SAP最新一代的E
  • 将json型字符串转换为List＜Map＞的格式处理 ZJJG4 前后端交互
    将json型字符串转换为List>的格式处理1、前台拼接字符串//保存事件$("#btn_save").on("click",(function(e){varpcbh=$("#sel_pcbh").val();varsqargs={list:[]};$("#clgltabletr:not(':first,:last')").each(function(i){varsqjson={};sqjson.
  • go zero rpc认证配置 梦§离 golanggolang开发语言后端
    1.认证配置选项（来自官方文档）RpcServerConfstruct{service.ServiceConf//服务配置，详情见api配置说明，这里不赘述ListenOnstring//rpc监听地址和端口，如：127.0.0.1:8888Etcddiscov.EtcdConf`json:",optional"`//etcd相关配置Authbool`json:",optional"`//是否开启
  • 【go-zero框架】2.服务注册与发现 喝醉的小喵 后端框架与模型golang开发语言web服务框架rpc
    文章目录1server端的服务注册1.1用法1.2原理2client端的服务发现2.1用法2.2原理go-zero支持三种服务注册与发现方式：直连：指定目标地址endpoints基于etcd基于k8s：依赖k8s的集群管理机制，服务发现时直接去k8s的Endpoints里获本篇讨论etcd的服务注册与发现方式~1server端的服务注册1.1用法只需要在rpc的服务配置yaml文件中，定义etcd
  • PHP中使用grpc服务的教程详解 Oona_01 phpandroid开发语言
    这篇文章主要为大家详细介绍了PHP中使用grpc服务的教程相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下grpc是通过定义服务端和客户端的代码来实现的通信的。但是要实现通信，还是要将其方法包装为一个http请求，除非你把grpc的服务端代码放在本地的端口上。grpc是面对微服务框架而风生水起的，上次我用python编写了一个图神经网络处理的微服务，使用grpc放在我的服务
  • Protocol Buffer编译器安装 雪域迷影
    本文翻译自ProtocolBufferCompilerInstallationProtocolBufferCompilerInstallation如何安装protocolbuffer编译器尽管不是强制性的，但gRPC应用程序通常利用ProtocolBuufer来进行服务定义和数据序列化。该站点上的大多数示例代码都使用protocolbuffer语言（proto3）的版本3。protocolbuff
  • metamask简述 小朴同学
    metamask是一个谷歌插件。他是一个很轻的以太坊钱包，支持正式的以太坊网络，支持主流的三种以太坊测试网络：Ropsten，Kovan，Rinkeby。也支持Localhost8545(尝试连接一个未可知的私人网络，可能会连接失败)和CustomRPC(自定义RPC)。简单功能创建新的账户发币和收币购买正式币和测试币（根据不同的测试网络获取的方式不一致）更改地址所在的网络调用合约功能未测试成功T
  • 劳动合同没有写明工资是不是不合法？ 2019-07-24 sea_3b73
    不违法。1，劳动法规定，对约定工资不明的合同，参考该公司同等岗位员工的薪水，当然职工有权可以和单位重新协商，但对于约定工资不明，确实没有法律规定说是不合法的。2，只要公司是按时发工资的，而且确实和周围人的工资差不多的，总工资也不低于当地最低工资标准的，想投诉该企业也比较难的，但为了劳动者保障权益，建议平时多收集自己在该单位工作的证明以防有一天公司不给工资等情况出现。3、法律依据《劳动合同法》第十七
  • 90-4 同频同行，强者共生 与未来有约_周
    今天上午在上班的间隙听了《第4届中国生涯咨询名家大会暨中国生涯产业趋势发布》的直播，晚上回家又重新再听了江晓兴、鞠洁、唐晓晨三位老师的分享，更加深刻理解HRPC爱普生涯所推崇的理念“明天赋、率天性、复天命”，它的共同价值观“助人利他，人生喜悦，富而有爱”。他们阐述了十大生涯新趋势下如何从职业规划走向全面生涯价值管理；如何从职业管理走向事业管理，实现人生逆袭。一个人如果不能全局去看，那么当下每一步都
  • 用Python搞定接口自动化测试：轻松实现RPC协议接口测试_python测试rpc接口 2401_84141210 程序员rpc网络协议网络
    网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！Hessian是一款基于HTTP协议的RPC框架，采
  • 中间件是什么 Amagi. 中间件
    中间件是指在操作系统和应用程序之间提供服务的软件层。它充当了不同软件组件之间的桥梁，帮助它们进行通信和数据管理。中间件的主要目的是简化和加速应用程序的开发过程，提供通用的功能和服务，使开发者能够专注于业务逻辑而不是底层的技术细节。中间件的主要功能通信：中间件提供了不同应用程序或服务之间的通信机制，支持消息传递、远程过程调用（RPC）等。数据管理：中间件可以处理数据的存储、检索和管理，通常与数据库系
  • vue+jsonrpc+mongoDB文件传输解决方案（任意格式文件） weideng_san 前端java文件传输jsonrpcmongoDBvue
    环境及需求：前端采用vue；后端采用spring，但是只用到了spring的对象注入功能，未使用springweb相关功能。前后端通信采用jsonrpc，现需要在前端选中文件（格式未知，上传到后端，后端将其存储在mongoDB中）。背景：springweb可以直接使用controller接受MultipartFile对象；但是jsonrpc不能直接传输文件类型，jsonrpc是轻量级通信框架，擅长
  • RESTful 还是 JSON-RPC 云闲不收 restfuljsonrpc
    前言RESTful比较简单地说就是，大家请求一样的url（GET方法有一个例外，url中带了一个id），通过不同的请求方法，分别进行不同的操作（CRUD）。JSON-RPCJSON-RPC是一个无状态且轻量级的远程过程调用（RPC）传送协议，通过JSON传递内容。远程过程调用意思就是，用函数思维写API，用JSON传值，返回一个JSON。RESTful的逻辑思维比较难转换初学coding，比较定式
  • 【Java】已解决：com.alibaba.dubbo.rpc.RpcException: No provider available from registry 屿小夏 javadubborpc
    文章目录一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例服务提供者配置服务消费者配置注册中心配置（application.properties）五、注意事项已解决：com.alibaba.dubbo.rpc.RpcException:Noprovideravailablefromregistry一、分析问题背景在分布式系统中，Dubbo是一个非常流行的RPC框架，用于实现高性能的
  • Spring Cloud Alibaba面试题 golove666 面试题大全面试微服务springcloud
    SpringCloudAlibaba1SpringCloudAlibaba基础组件1.1解释SpringCloudAlibaba及其主要目标1.2分析Nacos服务注册与发现的原理服务注册服务发现心跳检测数据一致性Nacos集群和持久化基于DNS和RPC的服务发现1.3描述Sentinel的熔断限流机制限流(RateLimiting)熔断降级(CircuitBreakingandFallback)
  • Linux中NFS和Samba的配置 噜噜噜的说~ LinuxLinux
    一.Linux中NFS的配置1、NFS的概念（1）NFS是什么NFS是基于UDP/IP协议的应用，其实现主要是采用远程过程调用RPC机制，RPC提供了一组与机器、操作系统以及低层传送协议无关的存取远程文件的操作。RPC采用了XDR的支持。XDR是一种与机器无关的数据描述编码的协议，他以独立与任意机器体系结构的格式对网上传送的数据进行编码和解码，支持在异构系统之间数据的传送。（2）NFS的作用提供透
  • Linux rpc 远程访问,我是这样学习Linux下C语言编程的-RPC远程调用编程 积极阳光的馨馨胡 Linuxrpc远程访问
    我是这样学习Linux下C语言编程的-RPC远程调用编程在查看libc6-dev软件包提供的工具(用dpkg-Llibc6-dev命令)的时候，发现此软件包提供了一个有用的工具rpcgen命令。通过rpcgen的man手册看到此工具的作用是把RPC源程序编译成C语言源程序，从而轻松实现远程过程调用。下面的例子程序的作用是客户端程序取中心服务器上时间的，编程过程如下：先编写一个“RPC语言”(RPC
  • rpc进程Linux,Linux下实现RPC编程 海边的弗兰克 rpc进程Linux
    Linux下面使用RPC需要使用到命令rpcgen.在Linux下开发RPC程序流程如下：1.写一个rpc程序如test.x2.使用rpcgen生成必须的文件，通常是客户端和服务器端以及头文件$rpcgentest.x3.使用rpcgen生成服务器端和客户端的C语言代码$rpcgen-Ss-otest_server.ctest.x$rpcgen-Sc-otest_client.ctest.x4.生
  • linux RPC 测试 tycoon1988 linux开发
    RPC是glibc提供的函数参数/返回值封装服务,并将封装结果通过网络传到服务器.RPC服务端首先要启动portmapper服务.测试一个简单的RPC传输示例,先定义一个模板文件test.xprogramTESTPROG{versionVERSION{intint_echo(int)=1;intget_str_len(string)=2;intadd(int,int)=3;}=1;}=30000;
  • linux下rpc应用 例程详解 iteye_9367 linuxLinux网络应用应用服务器C#C++
    关于“RPC语言”RPC语言也是一种专门的编程语言，当然这里我们不需要知道太多，只需要能看懂下面这种基本结构就行了：programTESTPROG{versionVERSION{stringTEST(string)=1;}=1;}=87654321;这里TESTPROG和VERSION是两个变量，用于标识一个单独的RPC接口。这被RPC服务程序，比如portmap用到，我们可以不用关心，变量名字也
  • Linux RPC调用的介绍 airekans Linux资料linuxreference
    Reference:http://www.linuxjournal.com/article/2204?page=0,0
  • mysql主从数据同步 林鹤霄 mysql主从数据同步
    配置mysql5.5主从服务器(转) 教程开始：一、安装MySQL 说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22  二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
  • oracle学习笔记 caoyong oracle
    1、ORACLE的安装    a>、ORACLE的版本    8i,9i :   i是internet    10g,11g : grid (网格)    12c : cloud (云计算)       b>、10g不支持win7 &
  • 数据库，SQL零基础入门 天子之骄 sql数据库入门基本术语
    数据库，SQL零基础入门        做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。          数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
  • pom.xml 一炮送你回车库 pom.xml
    1、一级元素dependencies是可以被子项目继承的 2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 3、父项目里的一级元素<modules> <module>lcas-admin-war</module> <
  • sql查地区省市县 3213213333332132 sqlmysql
    -- db_yhm_city SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35 SELECT * FROM db_yhm_city WHERE class_parent_id =169 SELECT d1.cla
  • 关于监听器那些让人头疼的事 宝剑锋梅花香 画图板监听器鼠标监听器
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。       
  • JAVA的遍历MAP darkranger map
    Java Map遍历方式的选择 1. 阐述 　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 　　为了解遍历性能的真实差距，包括在遍历ke
  • POJ 2312 Battle City 优先多列+bfs aijuans 搜索
    来源：http://poj.org/problem?id=2312 题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
  • Hibernate与Jpa的关系，终于弄懂 avords javaHibernate数据库jpa
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
  • 酸爽的console.log bee1314 console
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 /** * log.js hufeng * The safe wrapper for `console.xxx` functions *
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质 bijian1013 时间管理励志人生穷人过于忙碌
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
  • other operate 征客丶 OSosx
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出， 我好及时改正，同时也让我们一
  • 【Scala五】分析Spark源代码总结的Scala语法三 bit1129 scala
    1. If语句作为表达式 val properties = if (jobIdToActiveJob.contains(jobId)) { jobIdToActiveJob(stage.jobId).properties } else { // this stage will be assigned to "default" po
  • ZooKeeper 入门 BlueSkator 中间件zk
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么 BreakingBad mysqlDate
    取得当前时间用 now() 就行。 在数据库中格式化时间 用DATE_FORMA T(date, format) . 根据格式串format 格式化日期或日期和时间值date，返回结果串。 可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值: %S, %s 两位数字形式的秒（ 00,01,
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 4_JAVA+Oracle面试题(有答案) chenke oracle
    基础测试题 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 选择题 1、 What will happen when you attempt to compile and run the following code? （3） public class Static { static { int x = 5; // 在static内有效 } st
  • 新一代工作流系统设计目标 comsci 工作算法脚本
      用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 在这个设计中，最难的地方是系统根据什么来生成流
  • oracle 行链接与行迁移 daizj oracle行迁移
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 第一种情况: INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
  • [JShop]开源电子商务系统jshop的系统缓存实现 dinguangx jshop电子商务
    前言 jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
  • 初三全学年难记忆单词 dcj3sjt126com englishword
    several 儿子；若干 shelf 架子 knowledge 知识；学问 librarian 图书管理员 abroad 到国外，在国外 surf 冲浪 wave 浪；波浪 twice 两次；两倍 describe 描写；叙述 especially 特别；尤其 attract 吸引 prize 奖品；奖赏 competition 比赛；竞争 event 大事；事件 O
  • sphinx实践 dcj3sjt126com sphinx
      安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server   yum install sphinx 如果失败的话使用下面的方式安装 wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm yum loca
  • JPA之JPQL（三） frank1234 ormjpaJPQL
    1 什么是JPQL JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 2 检索单个对象 @Test public  void querySingleObject1() {     Query query = em.createQuery("sele
  • Remove Duplicates from Sorted Array II hcx2013 remove
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? For example,Given sorted array nums = [1,1,1,2,2,3], Your function should return length
  • Spring4新特性——Groovy Bean定义DSL jinnianshilongnian spring 4
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装Mysql5.5 liuxingguome centos
    CentOS下以RPM方式安装MySQL5.5 首先卸载系统自带Mysql： yum remove mysql mysql-server mysql-libs compat-mysql51 rm -rf /var/lib/mysql rm /etc/my.cnf 查看是否还有mysql软件： rpm -qa|grep mysql 去http://dev.mysql.c
  • 第14章 工具函数（下） onestopweb 函数
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • POJ 1050 SaraWon 二维数组子矩阵最大和
    POJ ACM第1050题的详细描述，请参照 http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 题目意思： 给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 如二维数组 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 中和最大的子矩阵是 9 2 -4 1 -1 8 且最大和是15
  • [5]设计模式——单例模式 tsface java单例设计模式虚拟机
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点   安全的单例模式：     /* * @(#)Singleton.java 2014-8-1 * * Copyright 2014 XXXX, Inc. All rights reserved. */ package com.fiberhome.singleton;
  • Java8全新打造，英语学习supertool yangshangchuan javasuperword闭包java8函数式编程
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。   升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他