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

Posted 爪哇之路

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了深度Dubbo源码 - SPI的使用与好处相关的知识,希望对你有一定的参考价值。

背景

相信阅读过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

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

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

 
   
   
 
  1. import org.apache.dubbo.config.annotation.Service;

  2. import org.apache.dubbo.rpc.RpcContext;

  3. import org.slf4j.Logger;

  4. import org.slf4j.LoggerFactory;


  5. // 指定版本和分组

  6. @Service(version = "1.0.0",group = "glory")

  7. public class DemoServiceImpl implements DemoService {

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


  9. @Override

  10. public String sayHello(Integer port) {

  11. logger.info("Hello " + port + " request from consumer: " + RpcContext.getContext().getRemoteAddress());

  12. return "Hello ,"+port+" response from provider: " + RpcContext.getContext().getLocalAddress();

  13. }


  14. }

以下为 application.yml配置文件

 
   
   
 
  1. server:

  2. port: 8083

  3. dubbo:

  4. application:

  5. name: dubbo-common-provider

  6. scan:

  7. base-packages: com.redsun.rpc.dubbo

  8. protocol:

  9. name: dubbo

  10. port: 12345

  11. registry:

  12. address: zookeeper://127.0.0.1:2181

还需要注意的是,在启动时需要指定不同端口,否则无法启动。深度Dubbo源码 - SPI的使用与好处此时就能正常启动两个本地应用了,启动效果如下:深度Dubbo源码 - SPI的使用与好处

启动consumer

consumer的代码框架也很简单深度Dubbo源码 - SPI的使用与好处

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

 
   
   
 
  1. public class GloryLoadBalance implements LoadBalance {


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


  3. @Override

  4. public <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException {

  5. Integer port = (Integer) invocation.getArguments()[0];// 前端传入的参数

  6. logger.info("前端传入端口为:" + port);

  7. // java8的流式编程,有兴趣的同学可以研究下,后续会再专门写一篇

  8. Invoker<T> invokerRet = invokers.stream().filter(invoker -> invoker.getUrl().getPort() == port).findFirst().get();

  9. return invokerRet == null ? invokers.get(0) : invokerRet;

  10. }

  11. }

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

 
   
   
 
  1. @RestController

  2. @RequestMapping("/admin")

  3. public class AdminController {

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


  5. @Reference(version = "1.0.0",group = "glory", loadbalance = "glory")

  6. private DemoService demoService;


  7. @RequestMapping("/invoke")

  8. public String invoke(@RequestParam(name = "port") Integer port) {

  9. logger.info("invoke method be invoked!port = " + port);

  10. return demoService.sayHello(port);

  11. }

  12. }

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

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

dubbo会加载 META-INF.dubbo.internal目录中的所有配置信息,在 dubbo目录下也会有很多的默认实现深度Dubbo源码 - SPI的使用与好处

Postman调用

以下两张图测试,满足预期。深度Dubbo源码 - SPI的使用与好处深度Dubbo源码 - SPI的使用与好处

源码

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

  • 别纠结于每个方法的实现,一般都是debug跟,很容易跟晕,最后就失去了兴趣

  • 学会看注释,尤其是方法名、类名、变量名,源码不同于平时自己编写的代码,既然开源了,就是面向所有人的,所以注释、起名往往会写的很详细很规范,英文不认识?翻译看,次数多了也就认识了

  • 在debug跟的时候记住几个核心的类,看完之后梳理下整个的调用链,对代码结构先要有个大概的认知(实在不想看,百度也行,我也经常这么干,然后再自己跟一下,认证下)

加载

ExtensionLoader#getExtensionClasses

 
   
   
 
  1. // synchronized in getExtensionClasses

  2. private Map<String, Class<?>> loadExtensionClasses() {

  3. cacheDefaultExtensionName();


  4. Map<String, Class<?>> extensionClasses = new HashMap<>();

  5. loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());

  6. loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));

  7. loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());

  8. loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));

  9. loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());

  10. loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));

  11. return extensionClasses;

  12. }

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

 
   
   
 
  1. /**

  2. * put clazz in extensionClasses

  3. */

  4. private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name) {

  5. Class<?> c = extensionClasses.get(name);

  6. if (c == null) {

  7. // 将扩展类GloryLoadBalance存入map中,最终会将默认提供的几种都存入map中

  8. extensionClasses.put(name, clazz);

  9. } else if (c != clazz) {

  10. throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName());

  11. }

  12. }

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

运行

AbstractClusterInvoker#invoke

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

 
   
   
 
  1. public Result invoke(final Invocation invocation) throws RpcException {

  2. checkWhetherDestroyed();


  3. // binding attachments into invocation.

  4. Map<String, String> contextAttachments = RpcContext.getContext().getAttachments();

  5. if (contextAttachments != null && contextAttachments.size() != 0) {

  6. ((RpcInvocation) invocation).addAttachments(contextAttachments);

  7. }


  8. List<Invoker<T>> invokers = list(invocation);

  9. // 初始化加载负载均衡类

  10. LoadBalance loadbalance = initLoadBalance(invokers, invocation);

  11. RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);

  12. return doInvoke(invocation, invokers, loadbalance);

  13. }

ExtensionLoader#getExtensionLoader

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

 
   
   
 
  1. public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {

  2. if (type == null) {

  3. throw new IllegalArgumentException("Extension type == null");

  4. }

  5. if (!type.isInterface()) {

  6. throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");

  7. }

  8. // 此处判断是否以SPI注解修饰

  9. if (!withExtensionAnnotation(type)) {

  10. throw new IllegalArgumentException("Extension type (" + type +

  11. ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");

  12. }


  13. ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);

  14. if (loader == null) {

  15. EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));

  16. loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);

  17. }

  18. return loader;

  19. }

ExtensionLoader#getExtension

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

总结

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


以上是关于深度Dubbo源码 - SPI的使用与好处的主要内容,如果未能解决你的问题,请参考以下文章

Dubbo底层源码分析之SPI扩展点

Dubbo之SPI源码分析

Dubbo源码学习 详解Dubbo里的SPI

Dubbo源码学习 详解Dubbo里的SPI

Dubbo源码学习 详解Dubbo里的SPI

深度剖析Dubbo源码