从零开始实现简单 RPC 框架 2：扩展利器 SPI

RPC 框架有很多可扩展的地方，如：序列化类型、压缩类型、负载均衡类型、注册中心类型等等。 假设框架提供的注册中心只有

zookeeper

Eureka

ccx-rpc

ccx-rpc

JDK SPI

ccx-rpc

JDK SPI

下面我们来看一下 JDK SPI 是如何使用的。 我们先来定义一个序列化接口和

JSON

Protostuff

public interface Serializer {
byte[] serialize(Object object);
}

public class JSONSerializer implements Serializer {
@Override
public byte[] serialize(Object object) {
return JSONUtil.toJsonStr(object).getBytes();
}
}

public class ProtostuffSerializer implements Serializer {
private static final LinkedBuffer BUFFER = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
@Override
public byte[] serialize(Object object) {
Schema schema = RuntimeSchema.getSchema(object.getClass());
return ProtostuffIOUtil.toByteArray(object, schema, BUFFER);
}
}

在

resources/META-INF/services

com.xxx.Serializer

JDK SPI

com.xxx.JSONSerializer
com.xxx.ProtostuffSerializer

如何使用 SPI 将实现类加载出来呢？

public static void main(String[] args) {
ServiceLoader<Serializer> serviceLoader = ServiceLoader.load(Serializer.class);
Iterator<Serializer> iterator = serviceLoader.iterator();
while (iterator.hasNext()) {
Serializer serializer= iterator.next();
System.out.println(serializer.getClass().getName());
}
}

输出如下:

com.xxx.JSONSerializer
com.xxx.ProtostuffSerializer

通过上面的例子，我们可以了解到 SPI 的简单用法。接下来，我们就来看增强版的 SPI 是如何实现的，又增强在哪里。

增强版 SPI

我们先来看看增强版 SPI 是如何使用的吧，还是拿序列化来举例。

1. 定义接口，接口加上

   @SPI

   注解

@SPI
public interface Serializer {
byte[] serialize(Object object);
}

1. 实现类，这个代码跟上面的一模一样，就不重复贴代码了
2. 配置文件

json=com.ccx.rpc.demo.client.spi.JSONSerializer
protostuff=com.ccx.rpc.demo.client.spi.ProtostuffSerializer

1. 获取扩展类 我们可以只实例化想要的实现类

public static void main(String[] args) {
ExtensionLoader<Serializer> loader = ExtensionLoader.getLoader(Serializer.class);
Serializer serializer = loader.getExtension("protostuff");
System.out.println(serializer.getClass().getName());
}

上面是增强版 SPI 的基础用法，还是相当简单的。下面我们就要开始讲解代码实现了，准备好，要发车了。

ccx-rpc-common

com.ccx.rpc.common.extension.ExtensionLoader

懒惰加载

JDK SPI 在查找实现类的时候，需要遍历配置文件中定义的所有实现类，而这个过程会把所有实现类都实例化。一个接口如果有很多实现类，而我们只需要其中一个的时候，就会产生其他不必要的实现类。 例如

Dubbo

fastjson

gson

hession2

jdk

kryo

protobuf

JDK SPI

ccx-rpc

获取扩展类实例的实现如下：

public T getExtension(String name) {
T extension = extensionsCache.get(name);
if (extension == null) {
synchronized (lock) {
extension = extensionsCache.get(name);
if (extension == null) {
extension = createExtension(name);
extensionsCache.put(name, extension);
}
}
}
return extension;
}

这是一个典型的

double-check

配置文件

配置文件采用的格式参考

dubbo

json=com.ccx.rpc.demo.client.spi.JSONSerializer
protostuff=com.ccx.rpc.demo.client.spi.ProtostuffSerializer

采用

key-value

加载解析配置文件的代码也比较简单：

/**
* 从资源文件中加载所有扩展类
*/
private Map<String, Class<?>> loadClassesFromResources() {
// ... 省略非关键代码
Enumeration<URL> resources = classLoader.getResources(fileName);
while (resources.hasMoreElements()) {
URL url = resources.nextElement();
try (BufferedReader reader = new BufferedReader(url...) {
// 开始读文件
while (true) {
String line = reader.readLine();
parseLine(line, extensionClasses);
}
}
}
}

/**
* 解析行，并且把解析到的类，放到 extensionClasses 中
*/
private void parseLine(String line, Map<String, Class<?>> extensionClasses) {
// 用等号将行分割开，kv[0]就是名字，kv[1]就是类名
String[] kv = line.split("=");
Class<?> clazz = ExtensionLoader.class.getClassLoader().loadClass(kv[1]);
extensionClasses.put(kv[0], clazz);
}

扩展类的创建

当获取扩展类不存在时，会加锁实例化扩展类。实例化的流程如下：

1. 从配置文件中，加载该接口所有的实现类的 Class 对象，并放到缓存中。
2. 根据要获取的扩展名字，找到对应的 Class 对象。
3. 调用

   clazz.newInstance()

   实例化。(Class 需要有无参构造函数)

private T createExtension(String name) {
// 获取当前类型所有扩展类
Map<String, Class<?>> extensionClasses = getAllExtensionClasses();
// 再根据名字找到对应的扩展类
Class<?> clazz = extensionClasses.get(name);
return (T) clazz.newInstance();
}

加载器缓存

加载器指的就是

ExtensionLoader<T>

ccx-rpc

/**
* 扩展加载器实例缓存 {类型：加载器实例}
*/
private static final Map<Class<?>, ExtensionLoader<?>> extensionLoaderCache = new ConcurrentHashMap<>();

public static <S> ExtensionLoader<S> getLoader(Class<S> type) {
// ... 忽略部分代码
SPI annotation = type.getAnnotation(SPI.class);
ExtensionLoader<?> extensionLoader = extensionLoaderCache.get(type);
if (extensionLoader != null) {
return (ExtensionLoader<S>) extensionLoader;
}
extensionLoader = new ExtensionLoader<>(type);
extensionLoaderCache.putIfAbsent(type, extensionLoader);
return (ExtensionLoader<S>) extensionLoader;
}

extensionLoaderCache

Map

默认扩展

ccx-rpc

@SPI

@SPI("netty")

在扩展类的构造函数中，会从

@SPI

value()

private final String defaultNameCache;

private ExtensionLoader(Class<T> type) {
this.type = type;
SPI annotation = type.getAnnotation(SPI.class);
defaultNameCache = annotation.value();
}

获取默认扩展的代码就很简单了，直接使用了

defaultNameCache

public T getDefaultExtension() {
return getExtension(defaultNameCache);
}

适配扩展

获取扩展类的时候，需要输入扩展名，这样就需要先从配置里面读到响应的扩展名，才能根据扩展名获取扩展类。这个过程稍显麻烦，

ccx-rpc

URL

@SPI
public interface RegistryFactory {

/**
* 获取注册中心
*
* @param url 注册中心的配置，例如注册中心的地址。会自动根据协议获取注册中心实例
* @return 如果协议类型跟注册中心匹配上了，返回对应的配置中心实例
*/
@Adaptive("protocol")
Registry getRegistry(URL url);
}

public static void main(String[] args) {
// 获取适配扩展
RegistryFactory zkRegistryFactory = ExtensionLoader.getLoader(RegistryFactory.class).getAdaptiveExtension();
URL url = URLParser.toURL("zk://localhost:2181");
// 适配扩展自动从 ur 中解析出扩展名，然后返回对应的扩展类
Registry registry = zkRegistryFactory.getRegistry(url);
}

从实例代码，可以看到，有一个

@Adaptive("protocol")

URL

SPI

URL

zk

下面我们来看看获取适配扩展的代码是怎么实现的吧。

public T getAdaptiveExtension() {
InvocationHandler handler = new AdaptiveInvocationHandler<T>(type);
return (T) Proxy.newProxyInstance(ExtensionLoader.class.getClassLoader(),
new Class<?>[]{type}, handler);
}

适配扩展类其实是一个代理类，接下来来看看这个代理类

AdaptiveInvocationHandler

public class AdaptiveInvocationHandler<T> implements InvocationHandler {

private final Class<T> clazz;

public AdaptiveInvocationHandler(Class<T> tClass) {
clazz = tClass;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (args.length == 0) {
return method.invoke(proxy, args);
}
// 找 URL 参数
URL url = null;
for (Object arg : args) {
if (arg instanceof URL) {
url = (URL) arg;
break;
}
}
// 找不到 URL 参数，直接执行方法
if (url == null) {
return method.invoke(proxy, args);
}

Adaptive adaptive = method.getAnnotation(Adaptive.class);
// 如果不包含 @Adaptive，直接执行方法即可
if (adaptive == null) {
return method.invoke(proxy, args);
}

// 从 @Adaptive#value() 中拿到扩展名的 key
String extendNameKey = adaptive.value();
String extendName;
// 如果这个 key 是协议，从协议拿。其他的就直接从 URL 参数拿
if (URLKeyConst.PROTOCOL.equals(extendNameKey)) {
extendName = url.getProtocol();
} else {
extendName = url.getParam(extendNameKey, method.getDeclaringClass() + "." + method.getName());
}
// 拿到扩展名之后，就直接从 ExtensionLoader 拿就行了
ExtensionLoader<T> extensionLoader = ExtensionLoader.getLoader(clazz);
T extension = extensionLoader.getExtension(extendName);
return method.invoke(extension, args);
}
}

从配置中获取扩展的代码注释都有，我们在梳理一下流程：

1. 从方法参数中拿到

   URL

   参数，拿不到就直接执行方法
2. 获取配置 Key。从

   @Adaptive#value()

   拿扩展名的配置 key，如果拿不到就直接执行方法
3. 获取扩展名。判断配置 key 是不是协议，如果是就拿协议类型，否则拿

   URL

   后面的参数。 例如

   URL

   是：

   zk://localhost:2181?type=eureka

   如果

   @Adaptive("protocol")

   ，那么扩展名就是协议类型：

   zk

   • 如果

     @Adaptive("type")

     ，那么扩展名就是

     type

     参数：

     eureka

4. 最后根据扩展名获取扩展

   extensionLoader.getExtension(extendName)

总结

RPC

SPI

JDK SPI

ccx-rpc

SPI

• 懒惰加载
• key-value 结构的配置文件
• 加载器缓存
• 默认扩展
• 适配扩展

ccx-rpc

SPI

Dubbo SPI

Dubbo