深入学习Motan系列（四）—

困惑的袋鼠，对框架的把握有些茫然，但是仍然一步步向前，行动总比一直迷茫停止不前要好，您说呢，各位客官？

这篇开始客户端的分析。有些地方的代码，就不每段都标出了，中间有跳跃的地方，请自己对照代码来看。鄙人认为，光看武功秘籍没用，得动手debug，您说是不？

文章发了之前，斟酌了一会，因为自己认为写的不理想，有很多东西分析的不透彻，但是，决定还是发布出来，作为自己学习的历程，也希望大家多多给出建议。不断努力。

Demo

当然还是看源码中的tutorial demo了。

 public class MotanApiClientDemo {

     public static void main(String[] args) {

         RefererConfig<MotanDemoService> motanDemoServiceReferer = new RefererConfig<MotanDemoService>();

         // 设置接口及实现类

         motanDemoServiceReferer.setInterface(MotanDemoService.class);

         // 配置服务的group以及版本号

         motanDemoServiceReferer.setGroup("motan-demo-rpc");

         motanDemoServiceReferer.setVersion("1.0");

         motanDemoServiceReferer.setRequestTimeout(1000);

         // 配置注册中心直连调用

         RegistryConfig registry = new RegistryConfig();

         //use direct registry

         //registry.setRegProtocol("direct");

         //registry.setAddress("127.0.0.1:8002");

         // use ZooKeeper registry

         registry.setRegProtocol("zookeeper");

         registry.setAddress("127.0.0.1:2181");

         motanDemoServiceReferer.setRegistry(registry);

         // 配置RPC协议

         ProtocolConfig protocol = new ProtocolConfig();

         protocol.setId("motan");

         protocol.setName("motan");

         motanDemoServiceReferer.setProtocol(protocol);

         // motanDemoServiceReferer.setDirectUrl("localhost:8002");  // 注册中心直连调用需添加此配置

         // 使用服务

34         MotanDemoService service = motanDemoServiceReferer.getRef();

35         System.out.println(service.hello("motan"));

         System.exit(0);

     }

 }

前边的部分跟服务端的差不多，都是配置信息的设置，重点在34行和35行。注意，这边用的是RefererConfig这个类，它和ServiceConfig的关系如下：

（手残，打lol总输5555555555555，图形大家勉强看着，用StarUML画的）

motanDemoServiceReferer.getRef()这行代码中就是Referer的初始化方法

 public T getRef() {

         if (ref == null) {

             initRef();

         }

         return ref;

     }

     @SuppressWarnings({"unchecked", "rawtypes"})

     public synchronized void initRef() {

。。。省略。。。

         checkInterfaceAndMethods(interfaceClass, methods);

         clusterSupports = new ArrayList<>(protocols.size());

         List<Cluster<T>> clusters = new ArrayList<>(protocols.size());

         String proxy = null;

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

         List<URL> registryUrls = loadRegistryUrls();

         String localIp = getLocalHostAddress(registryUrls);

         for (ProtocolConfig protocol : protocols) {

             Map<String, String> params = new HashMap<>();

。。。省略。。。

             String path = StringUtils.isBlank(serviceInterface) ? interfaceClass.getName() : serviceInterface;

             URL refUrl = new URL(protocol.getName(), localIp, MotanConstants.DEFAULT_INT_VALUE, path, params);

             ClusterSupport<T> clusterSupport = createClusterSupport(refUrl, configHandler, registryUrls);

             clusterSupports.add(clusterSupport);

             clusters.add(clusterSupport.getCluster());

             if (proxy == null) {

                 String defaultValue = StringUtils.isBlank(serviceInterface) ? URLParamType.proxy.getValue() : MotanConstants.PROXY_COMMON;

                 proxy = refUrl.getParameter(URLParamType.proxy.getName(), defaultValue);

             }

         }

         ref = configHandler.refer(interfaceClass, clusters, proxy);

         initialized.set(true);

     }

上面的的代码重要的功能，我用图形表示一下：

上文的initRef()中最重要的当属Cluster的初始化。什么是Cluster?他其实代表provider服务集群，每一个具体的provider服务都被抽象成一个Referer接口，这个接口与客户端的Exporter相对应。因此，Cluster的本质是Referer的容器，并且提供了负载均衡和HA服务。每一个Cluster都被ClusterSupport封装起来，以提供对Cluster的刷新机制和生命周期管理。一个RefererConfig只会对应一个Cluster和一个ClusterSupport。（这段话，摘自http://kriszhang.com/motan-rpc-impl/）

createClusterSupport（）

 private ClusterSupport<T> createClusterSupport(URL refUrl, ConfigHandler configHandler, List<URL> registryUrls) {

         List<URL> regUrls = new ArrayList<>();

         // 如果用户指定directUrls 或者 injvm协议访问，则使用local registry

         if (StringUtils.isNotBlank(directUrl) || MotanConstants.PROTOCOL_INJVM.equals(refUrl.getProtocol())) {

。。。省略。。。
         } else { // 通过注册中心配置拼装URL，注册中心可能在本地，也可能在远端

             if (registryUrls == null || registryUrls.isEmpty()) {


。。。
             }

             for (URL url : registryUrls) {

                 regUrls.add(url.createCopy());

             }

         }

         for (URL url : regUrls) {

             url.addParameter(URLParamType.embed.getName(), StringTools.urlEncode(refUrl.toFullStr()));

         }
           // 这里，委托给SimpleConfigHandler进行ClusterSupport的创建

         return configHandler.buildClusterSupport(interfaceClass, regUrls);

     }

class ClusterSupport<T> implements NotifyListener

buildClusterSupport方法中主要是new ClusterSupport，然后进行初始化，我们看看他初始化里的内容。

 public void init() {

         long start = System.currentTimeMillis();
　　　　　　 // 方法里，通过SPI机制，生成ClusterSpi、ConfigurableWeightLoadBalance、FailoverHaStrategy三个对象，然后设置到ClusterSpi的实例中。

         prepareCluster();

         URL subUrl = toSubscribeUrl(url);

         for (URL ru : registryUrls) {

             String directUrlStr = ru.getParameter(URLParamType.directUrl.getName());

             // 如果有directUrl，直接使用这些directUrls进行初始化，不用到注册中心discover

             if (StringUtils.isNotBlank(directUrlStr)) {

                 List<URL> directUrls = parseDirectUrls(directUrlStr);

                 if (!directUrls.isEmpty()) {

                     notify(ru, directUrls);

                     LoggerUtil.info("Use direct urls, refUrl={}, directUrls={}", url, directUrls);

                     continue;

                 }

             }

             // client 注册自己，同时订阅service列表         重点在这两行
               // getRegistry方法中首先是通过SPI机制生成ZookeeperRegistryFactory实例，利用这个工厂模式，创建ZookeeperRegistry

             Registry registry = getRegistry(ru);
               // 这里做的是服务的订阅。方法中最终调用的是CommandFailbackRegistry的doSubscribe方法，相关类图的关系图请往下看

21             registry.subscribe(subUrl, this);

         }

。。。 省略 。。。
     }

服务发现与刷新

RegistryFactory相关类图关系如下：

Registry相关类图关系如下：

CommandFailbackRegistry doSubscribe（）的内容如下：

 protected void doSubscribe(URL url, final NotifyListener listener) {

         LoggerUtil.info("CommandFailbackRegistry subscribe. url: " + url.toSimpleString());

         URL urlCopy = url.createCopy();

         CommandServiceManager manager = getCommandServiceManager(urlCopy);

         manager.addNotifyListener(listener);

         subscribeService(urlCopy, manager);

         subscribeCommand(urlCopy, manager);

         List<URL> urls = doDiscover(urlCopy);

         if (urls != null && urls.size() > 0) {

             this.notify(urlCopy, listener, urls);

         }

     }

AbstractRegistry

 protected void notify(URL refUrl, NotifyListener listener, List<URL> urls) {

         if (listener == null || urls == null) {

             return;

         }

 。。。 省略。。。

         for (List<URL> us : nodeTypeUrlsInRs.values()) {
               // 重点在这里，调用了listener的notify方法。那么这个listerner是谁，就是ClusterSupport，它是在上面方法中的这两行代码里注册的
               // Registry registry = getRegistry(ru);
               // registry.subscribe(subUrl, this); this 指定的是ClusterSupport
　　　　　　　　 // 说了一大堆就是，概括说明就是，通过retistry进行回调notify方法  ※

             listener.notify(getUrl(), us);

         }

     }

我们继续探索ClusterSupport中的notfiy方法：

下面的代码，它主要就是根据新的URL（从zk端获得）创建Referer对象，并且刷新整个集群。刷新操作主要将新的Referer加入集群，并将旧的Referer对象释放掉。需要注意，这里并没有直接释放Referer资源，而是采用了延迟机制，主要考虑到Referer可能正在执行中，马上销毁会影响正常请求。我们会一层层进入代码内部去分析。

 /**

      * <pre>

      * 1 notify的执行需要串行

      * 2 notify通知都是全量通知，在设入新的referer后，cluster需要把不再使用的referer进行回收，避免资源泄漏;

      * 3 如果该registry对应的referer数量为0，而没有其他可用的referers，那就忽略该次通知；

      * 4 此处对protoco进行decorator处理，当前为增加filters

      * </pre>

      */

     @Override

     public synchronized void notify(URL registryUrl, List<URL> urls) {

。。。 省略。。。

         // 通知都是全量通知，在设入新的referer后，cluster内部需要把不再使用的referer进行回收，避免资源泄漏

         // ////////////////////////////////////////////////////////////////////////////////

         // 判断urls中是否包含权重信息，并通知loadbalance。

         processWeights(urls);

         List<Referer<T>> newReferers = new ArrayList<Referer<T>>();

         for (URL u : urls) {

             if (!u.canServe(url)) {

                 continue;

             }

             Referer<T> referer = getExistingReferer(u, registryReferers.get(registryUrl));

             if (referer == null) {

                 // careful u: serverURL, refererURL的配置会被serverURL的配置覆盖

                 URL refererURL = u.createCopy();

                 mergeClientConfigs(refererURL);
　　　　　　　　　　　// protocol 的类 ：ProtocolFilterDecorator
                   // debug进入代码内部可以发现，里面是referer的创建和初始化操作。referer可以看成是RPC客户端的操作的类
                   // 里面，创建了NettyClient，在初始化操作中，跟server的类似，委托NettyClient进行transport层的操作

                 referer = protocol.refer(interfaceClass, refererURL, u);

             }

             if (referer != null) {

                 newReferers.add(referer);

             }

         }

         if (CollectionUtil.isEmpty(newReferers)) {

             onRegistryEmpty(registryUrl);

             return;

         }

         // 此处不销毁referers，由cluster进行销毁

         registryReferers.put(registryUrl, newReferers);

         refreshCluster();

     }

netty的部分暂时不进行分析。那么，到这里为止，referer就可以成功生成，这样的话，在前面initRef方法中createClusterSupport的部分就结束了，接下来就是创建代理的部分了。

回顾一下initRef方法

 public synchronized void initRef() {

。。。 
。。。         for (ProtocolConfig protocol : protocols) {

。。。

             String path = StringUtils.isBlank(serviceInterface) ? interfaceClass.getName() : serviceInterface;

             URL refUrl = new URL(protocol.getName(), localIp, MotanConstants.DEFAULT_INT_VALUE, path, params);

             ClusterSupport<T> clusterSupport = createClusterSupport(refUrl, configHandler, registryUrls);

             clusterSupports.add(clusterSupport);

             clusters.add(clusterSupport.getCluster());

             if (proxy == null) {

                 String defaultValue = StringUtils.isBlank(serviceInterface) ? URLParamType.proxy.getValue() : MotanConstants.PROXY_COMMON;

                 proxy = refUrl.getParameter(URLParamType.proxy.getName(), defaultValue);

             }

         }

         ref = configHandler.refer(interfaceClass, clusters, proxy);

         initialized.set(true);

     }

上面50行的内容如下：

使用JDK的方法来创建动态代理。

     public <T> T refer(Class<T> interfaceClass, List<Cluster<T>> clusters, String proxyType) {

         ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getExtension(proxyType);

         return proxyFactory.getProxy(interfaceClass, clusters);

     }

当客户端初始化完毕之后，我们就能正常使用motan进行方法调用了。对接口的调用，实际上是被动态代理了，动态代理的执行入口是哪里呢？RefererInvocationHandler提供了这个入口。主要实现如下：

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

。。。
 

         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;

         }

         request.setMethodName(methodName);

         request.setParamtersDesc(ReflectUtil.getMethodParamDesc(method));

         request.setInterfaceName(interfaceName);

         return invokeRequest(request, getRealReturnType(async, this.clz, method, methodName), async);

     }

 Object invokeRequest(Request request, Class returnType, boolean async) throws Throwable {

         RpcContext curContext = RpcContext.getContext();

         curContext.putAttribute(MotanConstants.ASYNC_SUFFIX, async);

 。。。

         // 当 referer配置多个protocol的时候，比如A,B,C，

         // 那么正常情况下只会使用A，如果A被开关降级，那么就会使用B，B也被降级，那么会使用C

         for (Cluster<T> cluster : clusters) {

             String protocolSwitcher = MotanConstants.PROTOCOL_SWITCHER_PREFIX + cluster.getUrl().getProtocol();

             Switcher switcher = switcherService.getSwitcher(protocolSwitcher);

。。。

             Response response;

             boolean throwException = Boolean.parseBoolean(cluster.getUrl().getParameter(URLParamType.throwException.getName(), URLParamType.throwException.getValue()));

             try {
                   // 真正的执行入口在这里

                 response = cluster.call(request);

                 if (async) {

                     if (response instanceof ResponseFuture) {

                         ((ResponseFuture) response).setReturnType(returnType);

                         return response;

                     } else {

                         ResponseFuture responseFuture = new DefaultResponseFuture(request, 0, cluster.getUrl());

                         if (response.getException() != null) {

                             responseFuture.onFailure(response);

                         } else {

                             responseFuture.onSuccess(response);

                         }

                         responseFuture.setReturnType(returnType);

                         return responseFuture;

                     }

                 } else {

                     Object value = response.getValue();

                     if (value != null && value instanceof DeserializableObject) {

                         try {

                             value = ((DeserializableObject) value).deserialize(returnType);

                         } catch (IOException e) {

                             LoggerUtil.error("deserialize response value fail! deserialize type:" + returnType, e);

                             throw new MotanFrameworkException("deserialize return value fail! deserialize type:" + returnType, e);

                         }

                     }

                     return value;

                 }

             } 
。。。
     }

Cluster.call()实际上是重头戏，他在方法执行内部代理给了haStrategy.call()，然后ha策略使用LoadBalance选择一个或一批Referer对象，并根据具体策略调用这个Referer的call()方法。Referer接口在motan协议的默认实现是DefaultRpcReferer，他在初始化的时候通过EndpointFactory创建了一个Client对象，他其实就是NettyClient，然后调用client.request()，从而使rpc请求顺利进入了transport层。（前面这段分析，参考了别的文章，写的比我有水平，自己汗颜，感觉到里面的差距）之后，通过transport层，一步步到达服务端。

参考文章：http://kriszhang.com/motan-rpc-impl/

这篇文章作者站在一个高度对Motan框架进行简明概要的分析，钦佩，学习。

对比自己，自己这只袋鼠仍然在扎根，加强自己知识的深度，至于广度，是未来下阶段的目标。

巴特西

深入学习Motan系列（四）—— 客户端

服务发现与刷新

最新文章

热门文章