深度Dubbo源码 – SPI的使用与好处

  • 2019 年 10 月 5 日
  • 笔记

背景

相信阅读过Dubbo源码的同学应该看到在Dubbo中的很多接口上都有一个 @SPI的注解，笔者也不例外，但是一直不知道这个注解具体是干什么的，为了解决什么问题，怎么去使用？网上简单检索了下，中文名：服务供给接口，详见下图（来自百度百科）。

也许因为 dubbo本身的功能强大，所以笔者也只是知道能 dubbo可以自定义实现某些策略，比如负载均衡、序列化、线程池类型等等，但是还未正式在线上环境中使用。趁着节假日花些时间研究下，记录下，希望对大家有用。

代码样例

以下代码均是经过本地验证的，纯属手敲，具体执行详见https://github.com/GloryXu/spring-boot

注：测试项目搭建 spring-boot + spring-boot-dubbo(https://github.com/apache/dubbo-spring-boot-project)

验证思路

正如上图所述，说 @SPI是实现某个特定的服务，那就来个简单的实现，最熟悉的莫过于负载均衡（ LoadBalance）策略了，本地启动两个 provider，端口不同，通过 consumer的入参来决定访问指定的 provider。

启动provider

代码极其简单，代码框架如下

import org.apache.dubbo.config.annotation.Service;  import org.apache.dubbo.rpc.RpcContext;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;    // 指定版本和分组  @Service(version = "1.0.0",group = "glory")  public class DemoServiceImpl implements DemoService {      private static final Logger logger = LoggerFactory.getLogger(DemoServiceImpl.class);        @Override      public String sayHello(Integer port) {          logger.info("Hello " + port + " request from consumer: " + RpcContext.getContext().getRemoteAddress());          return "Hello ,"+port+" response from provider: " + RpcContext.getContext().getLocalAddress();      }    }

以下为 application.yml配置文件

server:    port: 8083  dubbo:    application:      name: dubbo-common-provider    scan:      base-packages: com.redsun.rpc.dubbo    protocol:      name: dubbo      port: 12345    registry:      address: zookeeper://127.0.0.1:2181

还需要注意的是，在启动时需要指定不同端口，否则无法启动。

此时就能正常启动两个本地应用了，启动效果如下：

启动consumer

consumer的代码框架也很简单

想必大家猜也能看出来， GloryLoadBalance就是自定义实现的一种负载均衡策略，通过前端传入的参数来选择 invoker

public class GloryLoadBalance implements LoadBalance {        private static final Logger logger = LoggerFactory.getLogger(GloryLoadBalance.class);        @Override      public <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException {          Integer port = (Integer) invocation.getArguments()[0];// 前端传入的参数          logger.info("前端传入端口为:" + port);          // java8的流式编程，有兴趣的同学可以研究下，后续会再专门写一篇          Invoker<T> invokerRet = invokers.stream().filter(invoker -> invoker.getUrl().getPort() == port).findFirst().get();          return invokerRet == null ? invokers.get(0) : invokerRet;      }  }

此处还简单写了个 controller，方便动态改参数

@RestController  @RequestMapping("/admin")  public class AdminController {      private static final Logger logger = LoggerFactory.getLogger(AdminController.class);        @Reference(version = "1.0.0",group = "glory", loadbalance = "glory")      private DemoService demoService;        @RequestMapping("/invoke")      public String invoke(@RequestParam(name = "port") Integer port) {          logger.info("invoke method be invoked!port = " + port);          return demoService.sayHello(port);      }  }

当然还会最后一步，也是最重要的，在 META-INF.dubbo.internal目录添加配置文件，下面等号前面的 glory其实就是你配置的 loadbalance 的key，如果路径错了，或者未配置，还是会获取到默认的实现 random

glory=com.redsun.rpc.dubbo.loadbalance.GloryLoadBalance

dubbo会加载 META-INF.dubbo.internal目录中的所有配置信息，在 dubbo目录下也会有很多的默认实现

Postman调用

以下两张图测试，满足预期。

源码

下面就到了翻源码的时候了，这里简单讲一下我本人看源码的一点心得。

  • 别纠结于每个方法的实现，一般都是debug跟，很容易跟晕，最后就失去了兴趣
  • 学会看注释，尤其是方法名、类名、变量名，源码不同于平时自己编写的代码，既然开源了，就是面向所有人的，所以注释、起名往往会写的很详细很规范，英文不认识？翻译看，次数多了也就认识了
  • 在debug跟的时候记住几个核心的类，看完之后梳理下整个的调用链，对代码结构先要有个大概的认知（实在不想看，百度也行，我也经常这么干，然后再自己跟一下，认证下）

加载

ExtensionLoader#getExtensionClasses

// synchronized in getExtensionClasses      private Map<String, Class<?>> loadExtensionClasses() {          cacheDefaultExtensionName();            Map<String, Class<?>> extensionClasses = new HashMap<>();          loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());          loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));          loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());          loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));          loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());          loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));          return extensionClasses;      }
/**       * put clazz in extensionClasses       */      private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name) {          Class<?> c = extensionClasses.get(name);          if (c == null) {              // 将扩展类GloryLoadBalance存入map中，最终会将默认提供的几种都存入map中              extensionClasses.put(name, clazz);          } else if (c != clazz) {              throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName());          }      }

加载好实现类最终会将 ReferenceConfig的负载均衡参数设置为 glory

运行

AbstractClusterInvoker#invoke

在 consumer发起 invoke的时候会根据config的key进行有选择的创建实例

public Result invoke(final Invocation invocation) throws RpcException {          checkWhetherDestroyed();            // binding attachments into invocation.          Map<String, String> contextAttachments = RpcContext.getContext().getAttachments();          if (contextAttachments != null && contextAttachments.size() != 0) {              ((RpcInvocation) invocation).addAttachments(contextAttachments);          }            List<Invoker<T>> invokers = list(invocation);          // 初始化加载负载均衡类          LoadBalance loadbalance = initLoadBalance(invokers, invocation);          RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);          return doInvoke(invocation, invokers, loadbalance);      }

ExtensionLoader#getExtensionLoader

每个 META-INF.dubbo.internal目录中的文件都是 ExtensionLoader对象，存储在一个静态的类变量 EXTENSION_LOADERS中

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {          if (type == null) {              throw new IllegalArgumentException("Extension type == null");          }          if (!type.isInterface()) {              throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");          }          // 此处判断是否以SPI注解修饰          if (!withExtensionAnnotation(type)) {              throw new IllegalArgumentException("Extension type (" + type +                      ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");          }            ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);          if (loader == null) {              EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));              loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);          }          return loader;      }

ExtensionLoader#getExtension

如果此时为空，则会通过上面加载的Class信息newInstance一个实例使用，代码比较简单，有兴趣的可以跟一下。

总结

通过以上应该可以看出，后续如果想扩展使用dubbo会非常的简单，增加一个实现类（实现对应接口），再在 META-INF目录下添加一个配置文件，key对应好就能完成了。序列化方式也可以按照自己的意愿来。在跟代码的时候也能看到对于一些其他不使用的扩展类，dubbo都将Class对象加载进去了，也算是一点点小瑕疵吧。

VirMach 便宜 VPS

QNews

QNews