Dubbo源码分析（三）Dubbo中的SPI和自适应扩展机制

时间  2019-11-17
标签 dubbo 源码 分析 spi 自适应 扩展 机制 栏目 Dubbo 繁體版
原文   原文链接

前言

咱们在往期文章中，曾经深刻分析过Java的SPI机制，它是一种服务发现机制。具体详见：深刻理解JDK的SPI机制java

在继续深刻Dubbo以前，咱们必须先要明白Dubbo中的SPI机制。由于有位大神（佚名）曾这样说过：redis

要想理解Dubbo，必需要先搞明白Dubbo SPI机制，否则会很是晕。缓存

1、背景

一、来源

Dubbo 的扩展点加载从 JDK 标准的 SPI (Service Provider Interface) 扩展点发现机制增强而来。但还有所不一样，它改进了JDK标准的 SPI的如下问题：安全

  • JDK 标准的 SPI 会一次性实例化扩展点全部实现，若是有扩展实现初始化很耗时，但若是没用上也加载，会很浪费资源。ruby

  • 若是扩展点加载失败，连扩展点的名称都拿不到了。好比：JDK 标准的 ScriptEngine，经过 getName() 获取脚本类型的名称，但若是 RubyScriptEngine 由于所依赖的 jruby.jar 不存在，致使 RubyScriptEngine 类加载失败，这个失败缘由被吃掉了，和 ruby 对应不起来，当用户执行 ruby 脚本时，会报不支持 ruby，而不是真正失败的缘由。bash

  • 增长了对扩展点 IoC 和 AOP 的支持，一个扩展点能够直接 setter 注入其它扩展点。数据结构

二、约定

在扩展类的 jar 包内，放置扩展点配置文件 META-INF/dubbo/接口全限定名，内容为：配置名=扩展实现类全限定名，多个实现类用换行符分隔。app

三、配置文件

Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路径下，几乎全部的功能都有扩展点实现。框架

Dubbo扩展点配置文件

咱们以Protocol接口为例，它里面有不少实现。 jvm

Protocol接口实现

2、Dubbo SPI

经过上图咱们能够看到，Dubbo SPI和JDK SPI配置的不一样，在Dubbo SPI中能够经过键值对的方式进行配置，这样就能够按需加载指定的实现类。 Dubbo SPI的相关逻辑都被封装到ExtensionLoader类中，经过ExtensionLoader咱们能够加载指定的实现类，一个扩展接口就对应一个ExtensionLoader对象，在这里咱们把它亲切的称为：扩展点加载器。

咱们先看下它的属性：

public class ExtensionLoader<T> {
	
    //扩展点配置文件的路径，能够从3个地方加载到扩展点配置文件
    private static final String SERVICES_DIRECTORY = "META-INF/services/";
    private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
    private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";	
    //扩展点加载器的集合
    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
    //扩展点实现的集合
    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>,Object>();
    //扩展点名称和实现的映射缓存
    private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
    //拓展点实现类集合缓存
    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
    //扩展点名称和@Activate的映射缓存
    private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
    //扩展点实现的缓存
    private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
}
复制代码

ExtensionLoader会把不一样的扩展点配置和实现都缓存起来。同时，Dubbo在官网上也给了咱们提醒：扩展点使用单一实例加载（请确保扩展实现的线程安全性），缓存在 ExtensionLoader中。下面咱们看几个重点方法。

一、获取扩展点加载器

咱们首先经过ExtensionLoader.getExtensionLoader() 方法获取一个 ExtensionLoader 实例，它就是扩展点加载器。而后再经过 ExtensionLoader 的 getExtension 方法获取拓展类对象。这其中，getExtensionLoader 方法用于从缓存中获取与拓展类对应的 ExtensionLoader，若缓存未命中，则建立一个新的实例。

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 interface!");
    }
    if (!withExtensionAnnotation(type)) {
    	throw new IllegalArgumentException("Extension type("..."); } 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; } 复制代码

好比你能够经过下面这样，来获取Protocol接口的ExtensionLoader实例： ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class); 就能够拿到扩展点加载器的对象实例： com.alibaba.dubbo.common.extension.ExtensionLoader[com.alibaba.dubbo.rpc.Protocol]

二、获取扩展类对象

上一步咱们已经拿到加载器，而后能够根据加载器实例，经过扩展点的名称获取扩展类对象。

public T getExtension(String name) {
    //校验扩展点名称的合法性
    if (name == null || name.length() == 0)
    	throw new IllegalArgumentException("Extension name == null");
    // 获取默认的拓展实现类
    if ("true".equals(name)) {
    	return getDefaultExtension();
    }
    //用于持有目标对象
    Holder<Object> holder = cachedInstances.get(name);
    if (holder == null) {
    	cachedInstances.putIfAbsent(name, new Holder<Object>());
    	holder = cachedInstances.get(name);
    }
    Object instance = holder.get();
    if (instance == null) {
    	synchronized (holder) {
    	    instance = holder.get();
    	    if (instance == null) {
    	    	instance = createExtension(name);
    	    	holder.set(instance);
    	    }
    	}
    }
    return (T) instance;
}
复制代码

它先尝试从缓存中获取，未命中则建立扩展对象。那么它的建立过程是怎样的呢？

private T createExtension(String name) {
    //从配置文件中获取全部的扩展类，Map数据结构
    //而后根据名称获取对应的扩展类
    Class<?> clazz = getExtensionClasses().get(name);
    if (clazz == null) {
    	throw findException(name);
    }
    try {
    	//经过反射建立实例，而后放入缓存
    	T instance = (T) EXTENSION_INSTANCES.get(clazz);
    	if (instance == null) {
    	    EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
    	    instance = (T) EXTENSION_INSTANCES.get(clazz);
    	}
    	//注入依赖
    	injectExtension(instance);
    	Set<Class<?>> wrapperClasses = cachedWrapperClasses;
    	if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
    	    // 包装为Wrapper实例
    	    for (Class<?> wrapperClass : wrapperClasses) {
    	    	instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
    	    }
    	}
    	return instance;
    } catch (Throwable t) {
    	throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
    	    type + ") could not be instantiated: " + t.getMessage(), t);
    }
}
复制代码

这里的重点有两个，依赖注入和Wrapper包装类，它们是Dubbo中IOC 与 AOP 的具体实现。

2.一、依赖注入

向拓展对象中注入依赖，它会获取类的全部方法。判断方法是否以 set 开头，且方法仅有一个参数，且方法访问级别为 public，就经过反射设置属性值。因此说，Dubbo中的IOC仅支持以setter方式注入。

private T injectExtension(T instance) {
	
    if (objectFactory != null) {
    	for (Method method : instance.getClass().getMethods()) {
    	    if (method.getName().startsWith("set")&& method.getParameterTypes().length == 1&& Modifier.isPublic(method.getModifiers())) {
    		    Class<?> pt = method.getParameterTypes()[0];
    		    try {
    		    	String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
    		    	Object object = objectFactory.getExtension(pt, property);
    		    	if (object != null) {
    		    	    method.invoke(instance, object);
    		    	}
    			} catch (Exception e) {
    			    logger.error("");
    			}
    	    }
    	}
    }
    return instance;
}
复制代码
2.二、Wrapper

它会将当前 instance 做为参数传给 Wrapper 的构造方法，并经过反射建立 Wrapper 实例。 而后向 Wrapper 实例中注入依赖，最后将 Wrapper 实例再次赋值给 instance 变量。提及来可能比较绕，咱们直接看下它最后生成的对象就明白了。 咱们以DubboProtocol为例，它包装后的对象为：

Wrapper包装对象

综上所述，若是咱们获取一个扩展类对象，最后拿到的就是这个Wrapper类的实例。 就像这样：

ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class);
Protocol extension = extensionLoader.getExtension("dubbo");
System.out.println(extension);
复制代码

输出为：com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper@4cdf35a9

三、获取全部的扩展类

在咱们经过名称获取扩展类对象以前，首先须要根据配置文件解析出全部的扩展类。 它是一个扩展点名称和扩展类的映射表Map<String, Class<?>>

首先，仍是从缓存中cachedClasses获取，若是没有就调用loadExtensionClasses从配置文件中加载。配置文件有三个路径：

META-INF/services/ META-INF/dubbo/ META-INF/dubbo/internal/

先尝试从缓存中获取。

private Map<String, Class<?>> getExtensionClasses() {
    //从缓存中获取
    Map<String, Class<?>> classes = cachedClasses.get();
    if (classes == null) {
    	synchronized (cachedClasses) {
    	    classes = cachedClasses.get();
    	    if (classes == null) {
    	        //加载扩展类
    	        classes = loadExtensionClasses();
    	        cachedClasses.set(classes);
    	    }
    	}
    }
    return classes;
}	
复制代码

若是没有，就调用loadExtensionClasses从配置文件中读取。

private Map<String, Class<?>> loadExtensionClasses() {
	//获取 SPI 注解，这里的 type 变量是在调用 getExtensionLoader 方法时传入的
	final SPI defaultAnnotation = type.getAnnotation(SPI.class);
	if (defaultAnnotation != null) {
		String value = defaultAnnotation.value();
		if ((value = value.trim()).length() > 0) {
			String[] names = NAME_SEPARATOR.split(value);
			if (names.length > 1) {
				throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()+ ": " + Arrays.toString(names));
			}
			//设置默认的扩展名称，参考getDefaultExtension 方法
			//若是名称为true，就是调用默认扩赞类
			if (names.length == 1) cachedDefaultName = names[0];
		}
	}
	//加载指定路径的配置文件
	Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
	loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
	loadDirectory(extensionClasses, DUBBO_DIRECTORY);
	loadDirectory(extensionClasses, SERVICES_DIRECTORY);
	return extensionClasses;
}
复制代码

以Protocol接口为例，获取到的实现类集合以下，咱们就能够根据名称加载具体的扩展类对象。

{
	registry=class com.alibaba.dubbo.registry.integration.RegistryProtocol
	injvm=class com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol
	thrift=class com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol
	mock=class com.alibaba.dubbo.rpc.support.MockProtocol
	dubbo=class com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
	http=class com.alibaba.dubbo.rpc.protocol.http.HttpProtocol
	redis=class com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol
	rmi=class com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol
}
复制代码

3、自适应扩展机制

在Dubbo中，不少拓展都是经过 SPI 机制进行加载的，好比 Protocol、Cluster、LoadBalance 等。这些扩展并不是在框架启动阶段就被加载，而是在扩展方法被调用的时候，根据URL对象参数进行加载。 那么，Dubbo就是经过自适应扩展机制来解决这个问题。

自适应拓展机制的实现逻辑是这样的： 首先 Dubbo 会为拓展接口生成具备代理功能的代码。而后经过 javassist 或 jdk 编译这段代码，获得 Class 类。最后再经过反射建立代理类，在代理类中，就能够经过URL对象的参数来肯定到底调用哪一个实现类。

一、Adaptive注解

在开始以前，咱们有必要先看一下与自适应拓展息息相关的一个注解，即 Adaptive 注解。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {
    String[] value() default {};
}
复制代码

从上面的代码中可知，Adaptive 可注解在类或方法上。

  • 标注在类上 Dubbo 不会为该类生成代理类。
  • 标注在方法上 Dubbo 则会为该方法生成代理逻辑，表示当前方法须要根据 参数URL 调用对应的扩展点实现。

二、获取自适应拓展类

getAdaptiveExtension 方法是获取自适应拓展的入口方法。

public T getAdaptiveExtension() {
    // 从缓存中获取自适应拓展
    Object instance = cachedAdaptiveInstance.get();
    if (instance == null) {
    	if (createAdaptiveInstanceError == null) {
    		synchronized (cachedAdaptiveInstance) {
    		    instance = cachedAdaptiveInstance.get();
    		    //未命中缓存，则建立自适应拓展，而后放入缓存
    		    if (instance == null) {
    		    	try {
    		    	    instance = createAdaptiveExtension();
    		    	    cachedAdaptiveInstance.set(instance);
    		    	} catch (Throwable t) {
    		    	    createAdaptiveInstanceError = t;
    		    	    throw new IllegalStateException("", t);
    		    	}
    		    }
    		}
    	}
    }
    return (T) instance;
}
复制代码

getAdaptiveExtension方法首先会检查缓存，缓存未命中，则调用 createAdaptiveExtension方法建立自适应拓展。

private T createAdaptiveExtension() {
    try {
    	return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
    	throw new IllegalStateException("Can not create adaptive extension ....", e);
    }
}
复制代码

这里的代码较少，调用 getAdaptiveExtensionClass方法获取自适应拓展 Class 对象，而后经过反射实例化，最后调用injectExtension方法向拓展实例中注入依赖。 获取自适应扩展类过程以下：

private Class<?> getAdaptiveExtensionClass() {
    //获取当前接口的全部实现类
    //若是某个实现类标注了@Adaptive，此时cachedAdaptiveClass不为空
    getExtensionClasses();
    if (cachedAdaptiveClass != null) {
    	return cachedAdaptiveClass;
    }
    //以上条件不成立，就建立自适应拓展类
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
复制代码

在上面方法中，它会先获取当前接口的全部实现类，若是某个实现类标注了@Adaptive，那么该类就被赋值给cachedAdaptiveClass变量并返回。若是没有，就调用createAdaptiveExtensionClass建立自适应拓展类。

三、建立自适应拓展类

createAdaptiveExtensionClass方法用于生成自适应拓展类，该方法首先会生成自适应拓展类的源码，而后经过 Compiler 实例（Dubbo 默认使用 javassist 做为编译器）编译源码，获得代理类 Class 实例。

private Class<?> createAdaptiveExtensionClass() {
	//构建自适应拓展代码
	String code = createAdaptiveExtensionClassCode();
	ClassLoader classLoader = findClassLoader();
	// 获取编译器实现类 这个Dubbo默认是采用javassist 
	Compiler compiler =ExtensionLoader.getExtensionLoader(Compiler.class).getAdaptiveExtension();
	//编译代码，返回类实例的对象
	return compiler.compile(code, classLoader);
}
复制代码

在生成自适应扩展类以前，Dubbo会检查接口方法是否包含@Adaptive。若是方法上都没有此注解，就要抛出异常。

if (!hasAdaptiveAnnotation){
	throw new IllegalStateException(
		"No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
}
复制代码

咱们仍是以Protocol接口为例，它的export()和refer()方法，都标注为@Adaptive。destroy和 getDefaultPort未标注 @Adaptive注解。Dubbo 不会为没有标注 Adaptive 注解的方法生成代理逻辑，对于该种类型的方法，仅会生成一句抛出异常的代码。

package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.Adaptive;
import com.alibaba.dubbo.common.extension.SPI;

@SPI("dubbo")
public interface Protocol {
    int getDefaultPort();
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    void destroy();
}
复制代码

因此说当咱们调用这两个方法的时候，会先拿到URL对象中的协议名称，再根据名称找到具体的扩展点实现类，而后去调用。下面是生成自适应扩展类实例的源代码：

package com.viewscenes.netsupervisor.adaptive;

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Protocol;
import com.alibaba.dubbo.rpc.RpcException;

public class Protocol$Adaptive implements Protocol {

    public void destroy() {
    	throw new UnsupportedOperationException("....");
    }
    public int getDefaultPort() {
    	throw new UnsupportedOperationException("....");
    }
    public Exporter export(Invoker invoker)throws RpcException {
    	if (invoker == null) {
    		throw new IllegalArgumentException("Invoker argument == null");
    	}
    	if (invoker.getUrl() == null) {
    		throw new IllegalArgumentException("Invoker argument getUrl() == null");
    	}
    		
    	URL url = invoker.getUrl();
    	String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    	if (extName == null) {
    		throw new IllegalStateException("....");
    	}
    		
    	Protocol extension = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName);
    	return extension.export(invoker);
    }
    public Invoker refer(Class clazz,URL ur)throws RpcException {
    	if (ur == null) {
    		throw new IllegalArgumentException("url == null");
    	}
    	URL url = ur;
    	String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    	if (extName == null) {
    		throw new IllegalStateException("....");
    	}
    	Protocol extension = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName);
    	return extension.refer(clazz, url);
    }
}
复制代码

综上所述，当咱们获取某个接口的自适应扩展类，实际就是一个Adaptive类实例。

ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class);            
Protocol adaptiveExtension = extensionLoader.getAdaptiveExtension();
System.out.println(adaptiveExtension);
复制代码

输出为： com.alibaba.dubbo.rpc.Protocol$Adaptive@47f6473

4、实例

咱们看完以上流程以后，若是想写一套本身的逻辑替换Dubbo中的流程，就变得很简单。

Dubbo默认使用dubbo协议来暴露服务。咱们能够搞一个自定义的协议来替换它。

一、实现类

首先，咱们建立一个MyProtocol类，它实现Protocol接口。

package com.viewscenes.netsupervisor.protocol;

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Protocol;
import com.alibaba.dubbo.rpc.RpcException;
import com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol;

public class MyProtocol extends DubboProtocol implements Protocol{

	public int getDefaultPort() {
		return 28080;
	}
	public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {	
		URL url = invoker.getUrl();
		System.out.println("自定义协议，进行服务暴露:"+url);	
		return super.export(invoker);
	}
	public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
		return super.refer(type, url);
	}
	public void destroy() {}
}
复制代码

二、扩展点配置文件

而后，在本身的项目中META-INF/services建立com.alibaba.dubbo.rpc.Protocol文件，文件内容为： myProtocol=com.viewscenes.netsupervisor.protocol.MyProtocol

三、修改Dubbo配置文件

最后修改生产者端的配置文件：

<!-- 用自定义协议在20880端口暴露服务 -->
<dubbo:protocol name="myProtocol" port="20880"/>  
复制代码

这样在咱们启动生产者端项目的时候，Dubbo在进行服务暴露的过程当中，就会调用到咱们自定义的MyProtocol类，完成相应的逻辑处理。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程