为什么学SPI

Dubbo 的可扩展性是基于 SPI 去实现的，而且Dubbo所有的组件都是通过 SPI 机制加载。

什么是SPI

SPI 全称为 (Service Provider Interface) ，是一种服务提供发现机制。可以将服务接口与服务实现分离以达到解耦可拔插、大大提升了程序可扩展性。

说人话：

一个接口有多个实现类，具体使用哪个实现类，通过SPI机制让用户来决定。也就是，定好规范，实现允许百花齐放。

举栗子：

以JDBC为例，Java提供了JDBC API用来连接 Java 编程语言和广泛的数据库。可是数据库种类这么多，无法一个个地去适配，怎么办？定好规范（Driver等一系列接口），实现类交由别人实现。

那么，实现类也有了，JDBC怎么知道该使用什么实现类（毕竟命名可以千奇百怪）？通过SPI

Java SPI

简单体验下，Dubbo SPI才是重点

1. 编写测试接口和实现类（我的代码是放在com.javaedit.javaspi包）

   // 定义接口
   public interface Color {
       String getName();
   }
   
   // 两个实现类
   public class BlueColor implements Color{
       @Override
       public String getName() {
           return "blue";
       }
   }
   
   public class RedColor implements Color {
       @Override
       public String getName() {
           return "red";
       }
   }
   

2. SPI配置文件

   在META-INF/services/目录下创建配置文件，文件名格式为接口的全限定名

   

   配置文件的内容为实现类的全限定的类名

   com.javaedit.javaspi.RedColor
   com.javaedit.javaspi.BlueColor
   

3. 运行测试代码

   public class TestDemo {
       public static void main(String[] args) {
           ServiceLoader<Color> colors = ServiceLoader.load(Color.class);
           for (Color color : colors) {
               System.out.println(color.getName());
           }
       }
   }
   

   效果输出：

   red
   blue

Dubbo SPI

基本示例

@SPI：此注解表示这是一个SPI接口，标注在类上。

基本使用

1. 编写测试接口和实现类（我的类在com.javaedit.spi包下）

   接口必须添加SPI注解

   package com.javaedit.spi;
   import com.alibaba.dubbo.common.URL;
   
   @SPI // 必须添加SPI注解
   public interface Robot {
       @Adaptive("robot")
       void sayHello(URL url);
   }
   
   // 实现类
   public class RobotImpl implements Robot {
       @Override
       public void sayHello(URL url) {
           System.out.println("大家好，我是普通机器人...");
       }
   }
   

2. 配置文件

   在指定目录下创建配置文件，文件名格式为接口的全限定名（此处为com.javaedit.spi.Robot）

   指定目录有3个，分别为：

   META-INF/dubbo/internal

   META-INF/dubbo

   META-INF/services

   文件内容为：

   norRobot = com.javaedit.spi.RobotImpl
   

3. 测试方法

   public static void main(String[] args) {
       ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
       // 这里的name需要和配置文件中的key保持一致
       String name = "norRobot";
       Robot robot = extensionLoader.getExtension(name);
       robot.sayHello(null);
   }
   

碎碎念：

@SPI注解有value参数，可以配置默认实现类的key，例如：

// 接口的注解添加默认值
@SPI("norRobot")

// 获取实现类时将getExtension替换一下
// Robot robot = extensionLoader.getExtension("norRobot");
Robot robot = extensionLoader.getDefaultExtension();

包装类

Dubbo SPI提供了类似装饰器模式的实现

1. 在基本使用的代码基础上，增加包装类

   public class RobotWrapper implements Robot {
   
       private Robot robot;
   
       // 带Robot参数的构造方法，这是包装类的重点
       public RobotWrapper(Robot robot) {
           this.robot = robot;
       }
   
       @Override
       public void sayHello(URL url) {
           System.out.println("wrapper before...");
           this.robot.sayHello(url);
           System.out.println("wrapper after...");
       }
   }
   

2. 配置文件中增加包装类的配置

   norRobot = com.javaedit.spi.RobotImpl
   wrapper = com.javaedit.spi.RobotWrapper
   

3. 测试类不变

4. 输出结果

   wrapper before...
   大家好，我是普通机器人...
   wrapper after...
   

碎碎念：

原理就是RobotWrapper只要有构造方法是有且只有一个参数，且这个参数是Robot类型，就认为其实包装类，会自动将Robot通过构造方法注入。

所以getExtension("norRobot")实际返回的是RobotWrapper

自适应扩展

有些拓展并不想在框架启动阶段被加载，而是希望在拓展方法被调用时，根据运行时参数进行加载。这就是Dubbo SPI自适应扩展的作用。

@Adaptive：此注解用于自适应扩展，可标注在类或者方法上。

类的自适应扩展

1. 新增自适应类

   @Adaptive  // 注意，注解在实现类上
   public class AdaptiveRobot implements Robot {
       @Override
       public void sayHello(URL url) {
           System.out.println("标注在类上的自适应代理类，类名：" + this.getClass().getSimpleName());
       }
   }
   

2. 测试代码

   public static void main(String[] args) {
       ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
       // 不用再指定key
       Robot robot = extensionLoader.getAdaptiveExtension();
       robot.sayHello(null); // 此时的robot是AdaptiveRobot
   }}
   

当@Adaptive标注在类上时，无需通过key指定需要获取的实现类，通过getAdaptiveExtension方法即可获取自适应扩展类。同一个接口，有且只能有一个实现类允许使用@Adaptive标注

方法的自适应扩展

注意：@Adaptive标注在类上和标注在方法上是冲突的，将上一步的AdaptiveRobot删除，或者把AdaptiveRobot类的Adaptive注解注释掉

1. 修改Robot接口，给sayHello方法添加@Adaptive注解。注意，是接口，不是实现类。

   @SPI
   public interface Robot {
       @Adaptive("robotAda") // robotAda是名字，随意
       void sayHello(URL url);
   }
   

2. 测试代码

   public static void main(String[] args) {
       ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
       Map<String, String> map = new HashMap<>();
       map.put("robotAda", "norRobot");
       URL url = new URL("", "", 1, map);
       Robot robot = extensionLoader.getAdaptiveExtension();
       robot.sayHello(url); // 此时的robot是Robot$Adaptive，但是实际调用的是RobotImpl的sayHello
   }}
   

   当@Adaptive标注在方法上时，getAdaptiveExtension获取的是动态生成的自适应扩展类，固定类名是 接口名$Adaptive，下面我们来看看自动生成的Robot$Adaptive长什么样

3. Robot$Adaptive，此类是动态生成的

   public class Robot$Adaptive implements com.javaedit.spi.Robot {
       public void sayHello(com.alibaba.dubbo.common.URL arg0) {
           if (arg0 == null) throw new IllegalArgumentException("url == null");
           com.alibaba.dubbo.common.URL url = arg0;
           // 从url中获取robotAda参数，也就是extName = "norRobot"
           String extName = url.getParameter("robotAda");
           if (extName == null)
               throw new IllegalStateException("Fail to get extension(com.javaedit.spi.Robot) name from url(" + url.toString() + ") use keys([robot])");
           // 获取norRobot，也就是RobotImpl类
           com.javaedit.spi.Robot extension = (com.javaedit.spi.Robot) ExtensionLoader.getExtensionLoader(com.javaedit.spi.Robot.class).getExtension(extName);
           // 调用norRobot的sayHello方法
           extension.sayHello(arg0);
       }
   }
   

   Robot$Adaptive的sayHello会动态从URL参数中获取实际要调用的Robot实现类，这样就实现了根据运行时参数进行加载的功能。

碎碎念：

动态选择实现类，是需要通过URL来传递参数的。也就是方法参数中需要包含URL对象或者方法参数中有getUrl()方法来提供URL对象。

IOC

Dubbo SPI也支持类似spring自动注入的功能，来看看怎么用。

1. 新增需要自动注入的类

   public class IocRobotImpl implements Robot {
   
       private Robot robot;
       // 只要带set开头的方法，都会被判断是否需要自动注入
       public void setRobot(Robot robot) {
           this.robot = robot;
       }
   
       @Override
       public void sayHello(URL url) {
           System.out.println("ioc start");
           robot.sayHello(url);
       }
   }
   

   setRobot方法注入的robot是通过自适应扩展方法getAdaptiveExtension获取的

2. 测试类

   public static void main(String[] args) {
       ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);
       Map<String, String> map = new HashMap<>();
       map.put("robot", "norRobot");
       URL url = new URL("", "", 1, map);
       Robot robot = extensionLoader.getExtension("iocRobot");
       robot.sayHello(url);
   }
   

   输出结果：

   ioc start
   大家好，我是普通机器人...

   由输出结果看到，setRobot注入的是norRobot，而norRobot自适应扩展从URL中获取的。

碎碎念：

Dubbo SPI的自动注入，也支持注入Spring的bean，此处没有演示。

总结

本文讲了Java SPI和Dubbo SPI的使用，至于DubboSPI的实现，请看下回分解。