dubbo如何实现可扩展的,援引官网描述:
Dubbo 的扩展点加载从 JDK 标准的 SPI (Service Provider Interface) 扩展点发现机制加强而来。
Dubbo 改进了 JDK 标准的 SPI 的以下问题:
- JDK 标准的 SPI 会一次性实例化扩展点所有实现,如果有扩展实现初始化很耗时,但如果没用上也加载,会很浪费资源。
- 如果扩展点加载失败,连扩展点的名称都拿不到了。比如:JDK 标准的 ScriptEngine,通过
getName()
获取脚本类型的名称,但如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在,导致 RubyScriptEngine 类加载失败,这个失败原因被吃掉了,和 ruby 对应不起来,当用户执行 ruby 脚本时,会报不支持 ruby,而不是真正失败的原因。 - 增加了对扩展点 IoC 和 AOP 的支持,一个扩展点可以直接 setter 注入其它扩展点。
定义个接口:
public interface HelloService { String sayHello(); }
定义两个实现类:
public class DogHelloService implements HelloService { @Override public String sayHello() { return "wang"; } }
public class HumanHelloService implements HelloService { @Override public String sayHello() { return "hello 你好"; } }
1.JDK标准的SPI是怎么回事?
ServiceLoader.load方法会加载META-INF/services/目录下定义的接口全限定名文件,内容为实现类。
com.exm.service.impl.DogHelloService com.exm.service.impl.HumanHelloService
核心为ServiceLoader.LazyIterator迭代器,在load方法被调用时,会初始化该迭代器,如下:
public void reload() { providers.clear(); lookupIterator = new LazyIterator(service, loader); }
LazyIterator会读取配置实现类,并通过反射进行实例化(前提要求实现类需要具备无参构造)。
其中hasNextService方法会加载META-INF/services接口文件,并加载到Enumeration<URL> configs中,源码如下:
private boolean hasNextService() { if (nextName != null) { return true; } if (configs == null) { try { //获取配置全路径名。如:META-INF/services/com.exm.service.HelloService String fullName = PREFIX + service.getName(); if (loader == null) configs = ClassLoader.getSystemResources(fullName); else //并加载到Enumeration<URL> configs中 configs = loader.getResources(fullName); } catch (IOException x) { fail(service, "Error locating configuration files", x); } } while ((pending == null) || !pending.hasNext()) { if (!configs.hasMoreElements()) { return false; } pending = parse(service, configs.nextElement()); } nextName = pending.next(); return true; }
迭代器通过nextService获取下一个实现类对象,源码如下,其中包含反射拿到Class对象,并实例化。
private S nextService() { if (!hasNextService()) throw new NoSuchElementException(); String cn = nextName; nextName = null; Class<?> c = null; try { //反射实例化 c = Class.forName(cn, false, loader); } catch (ClassNotFoundException x) { fail(service, "Provider " + cn + " not found"); } if (!service.isAssignableFrom(c)) { fail(service, "Provider " + cn + " not a subtype"); } try { //转强制化为接口,并放入LinkedHashMap<String,S> providers中 S p = service.cast(c.newInstance()); providers.put(cn, p); return p; } catch (Throwable x) { fail(service, "Provider " + cn + " could not be instantiated", x); } throw new Error(); // This cannot happen }
为什么说JDK的SPI会一次性加载并实例化所有的扩展呢?
1⃣️如果其中有一个实例化或cast时异常,后边所有都将无法遍历。
2⃣️如果某个类的实例化耗时很长,并没用到,会造成资源浪费
编写一个测试方法:
public static void main(String[] args) { final ServiceLoader<HelloService> helloServices = ServiceLoader.load(HelloService.class); for (HelloService helloService : helloServices){ System.out.println(helloService.getClass().getName() + ":" + helloService.sayHello()); } }
测试输出:
com.exm.service.impl.DogHelloService:wang com.exm.service.impl.HumanHelloService:hello 你好
2.Dubbo是怎么进行改进的呢?
dubbo时如何进行改进的呢?
(1)dubbo定义的SPi文件包含了key,即每个实现类对应一个不同的key,在加载class的时候,会将key和class放入一个map中。
这样在使用者想使用哪个类的实例时,只需要实例化对应的类,无需实例化所有类
(2)Adaptive功能:实现动态的使用扩展点。通过 getAdaptiveExtension方法 统一对指定接口对应的所有扩展点进行封装,通过URL的方式对扩展点来进行动态选择。
2.1 加载所有扩展点,选择性实例化
public class Main { public static void main(String[] args) { // 获取扩展加载器 ExtensionLoader<HelloService> extensionLoader = ExtensionLoader.getExtensionLoader(HelloService.class); // 遍历所有的支持的扩展点,并将key与实现类进行关联 Set<String> extensions = extensionLoader.getSupportedExtensions(); for (String extension : extensions){ String result = extensionLoader.getExtension(extension).sayHello(); System.out.println(result); } } }
然后通过extensionLoader.getExtension对指定key进行实例化,这一点是与JDK不同的。
我们看下具体是怎么加载的,getSupportedExtensions为入口,最终会通过loadDirectory进行加载
Set<String> getSupportedExtensions() Map<String, Class<?>> getExtensionClasses() Map<String, Class<?>> loadExtensionClasses() void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type, boolean extensionLoaderClassLoaderFirst)
(1)getSupportedExtensions方法会返回所有扩展点的key,供用户使用。
public Set<String> getSupportedExtensions() { Map<String, Class<?>> clazzes = this.getExtensionClasses(); //获取到所有扩展点后,将key放入TreeSet中(按字符串排序) return Collections.unmodifiableSet(new TreeSet(clazzes.keySet())); }
loadDirectory加载文件的来源为以下6个部分,兼容了JDK路径。
同时加载有顺序,越靠前越优先加载
private Map<String, Class<?>> loadExtensionClasses() { this.cacheDefaultExtensionName(); Map<String, Class<?>> extensionClasses = new HashMap(); this.loadDirectory(extensionClasses, "META-INF/dubbo/internal/", this.type.getName(), true); this.loadDirectory(extensionClasses, "META-INF/dubbo/internal/", this.type.getName().replace("org.apache", "com.alibaba"), true); this.loadDirectory(extensionClasses, "META-INF/dubbo/", this.type.getName()); this.loadDirectory(extensionClasses, "META-INF/dubbo/", this.type.getName().replace("org.apache", "com.alibaba")); this.loadDirectory(extensionClasses, "META-INF/services/", this.type.getName()); this.loadDirectory(extensionClasses, "META-INF/services/", this.type.getName().replace("org.apache", "com.alibaba")); return extensionClasses; }
(2)在Set中获取到扩点类对应的key,通过getExtension获取对应class的实例(包含通过setter进行依赖注入)
public T getExtension(String name) { if (StringUtils.isEmpty(name)) { throw new IllegalArgumentException("Extension name == null"); } else if ("true".equals(name)) { return this.getDefaultExtension(); } else { Holder<Object> holder = this.getOrCreateHolder(name); Object instance = holder.get(); if (instance == null) { synchronized(holder) { instance = holder.get(); if (instance == null) { //创建对应class的实例,完成依赖注入 instance = this.createExtension(name); holder.set(instance); } } } return instance; } }
createExtension方法是实例化的核心,实现了IOC和AOP,注释如下:
private T createExtension(String name) { //获取name对应的class 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); } //依赖注入(IOC) injectExtension(instance); //包装器(AOP) Set<Class<?>> wrapperClasses = cachedWrapperClasses; if (CollectionUtils.isNotEmpty(wrapperClasses)) { for (Class<?> wrapperClass : wrapperClasses) { instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)); } } initExtension(instance); return instance; } catch (Throwable t) { throw new IllegalStateException("Extension instance (name: " + name + ", class: " + type + ") couldn't be instantiated: " + t.getMessage(), t); } }
2.2 getAdaptiveExtension根据URL参数动态获取相应的扩展点
public class AdaptiveMain { public static void main(String[] args) { URL url = URL.valueOf("test://localhost/hello?hello.service=dog"); HelloService adaptiveExtension = ExtensionLoader.getExtensionLoader(HelloService.class).getAdaptiveExtension(); String msg = adaptiveExtension.sayHello(url); System.out.println(msg); } }
(1)核心代码为ExtensionLoader.getAdaptiveExtension方法
public T getAdaptiveExtension() { Object instance = cachedAdaptiveInstance.get(); if (instance == null) { if (createAdaptiveInstanceError != null) { throw new IllegalStateException("Failed to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError); } synchronized (cachedAdaptiveInstance) { instance = cachedAdaptiveInstance.get(); if (instance == null) { try { //创建自适应扩展 instance = createAdaptiveExtension(); cachedAdaptiveInstance.set(instance); } catch (Throwable t) { createAdaptiveInstanceError = t; throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t); } } } } return (T) instance; }
(2)创建自适应扩展类实例
private T createAdaptiveExtension() { try { //获取自适应扩展类,并实例化,然后通过setter注入依赖 return injectExtension((T) getAdaptiveExtensionClass().newInstance()); } catch (Exception e) { throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e); } }
(3)生成自适应扩展类class
private Class<?> getAdaptiveExtensionClass() { getExtensionClasses(); if (cachedAdaptiveClass != null) { return cachedAdaptiveClass; } return cachedAdaptiveClass = createAdaptiveExtensionClass(); }
(4)加载类扩展点(与上文相同)
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; }
(5)创建自适应扩展class,动态生成代码,并进行编译
private Class<?> createAdaptiveExtensionClass() { String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate(); ClassLoader classLoader = findClassLoader(); org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension(); return compiler.compile(code, classLoader); }
得到如下class:
package com.exm.service; import org.apache.dubbo.common.extension.ExtensionLoader; public class HelloService$Adaptive implements com.exm.service.HelloService { public java.lang.String sayHello() { throw new UnsupportedOperationException("The method public abstract java.lang.String com.exm.service.HelloService.sayHello() of interface com.exm.service.HelloService is not adaptive method!"); } public java.lang.String sayHello(org.apache.dubbo.common.URL arg0) { if (arg0 == null) throw new IllegalArgumentException("url == null"); org.apache.dubbo.common.URL url = arg0; String extName = url.getParameter("hello.service", "human"); if(extName == null) throw new IllegalStateException("Failed to get extension (com.exm.service.HelloService) name from url (" + url.toString() + ") use keys([hello.service])"); com.exm.service.HelloService extension = (com.exm.service.HelloService)ExtensionLoader.getExtensionLoader(com.exm.service.HelloService.class).getExtension(extName); return extension.sayHello(arg0); } }
可以看到自适应只支持具有adaptive注解的方法,并且参数汇总需要有URL参数。
(6)通过setter注入依赖
private T injectExtension(T instance) { if (objectFactory == null) { return instance; } try { for (Method method : instance.getClass().getMethods()) { if (!isSetter(method)) { continue; } /** * Check {@link DisableInject} to see if we need auto injection for this property */ if (method.getAnnotation(DisableInject.class) != null) { continue; } Class<?> pt = method.getParameterTypes()[0]; if (ReflectUtils.isPrimitives(pt)) { continue; } try { String property = getSetterProperty(method); //获取到Adaptive对象 Object object = objectFactory.getExtension(pt, property); if (object != null) { method.invoke(instance, object); } } catch (Exception e) { logger.error("Failed to inject via method " + method.getName() + " of interface " + type.getName() + ": " + e.getMessage(), e); } } } catch (Exception e) { logger.error(e.getMessage(), e); } return instance; }
(7)上文中的objectFactory是ExtensionFactory实例,其实现类包含SpiExtensionFactory和SpringExtensionFactory,一个是dubbo的扩展工厂,一个是Spring的工厂;前者只支持type是SPI的接口,并生成自适应类;后者从Spring容器中获取。
在依赖注入时,会在两个容器中遍历,如下:
public <T> T getExtension(Class<T> type, String name) { for (ExtensionFactory factory : factories) { T extension = factory.getExtension(type, name); if (extension != null) { return extension; } } return null; }
在getExtensionClasses()加载ExtensionFactory扩展class时,如果扩点类被Adaptive注解修饰,则将缓存在ExtensionLoader.cachedAdaptiveClass中;
在getAdaptiveExtensionClass方法中,直接返回,不需要生成自适应类
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException { if (!type.isAssignableFrom(clazz)) { throw new IllegalStateException("Error occurred when loading extension class (interface: " + type + ", class line: " + clazz.getName() + "), class " + clazz.getName() + " is not subtype of interface."); } //判断类事都是Adaptive类,是的话就缓存,在getAdaptiveExtensionClass时直接返回 if (clazz.isAnnotationPresent(Adaptive.class)) { cacheAdaptiveClass(clazz); } else if (isWrapperClass(clazz)) { cacheWrapperClass(clazz); } else { clazz.getConstructor(); if (StringUtils.isEmpty(name)) { name = findAnnotationName(clazz); if (name.length() == 0) { throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL); } } String[] names = NAME_SEPARATOR.split(name); if (ArrayUtils.isNotEmpty(names)) { cacheActivateClass(clazz, names[0]); for (String n : names) { cacheName(clazz, n); saveInExtensionClass(extensionClasses, clazz, n); } } } }
综上,dubbo加载class扩展与实例化是分开的,可以通过指定key实例化某一个class;
dubbo支持IOC和AOP;
3.在注入依赖的时候是否有循环依赖的问题?
在dubbo创建扩展class实例时,会通过setter进行依赖注入,如果存在循环依赖,怎么处理?
在dubbo依赖注入时,除了Spring容器外,从SPI容器中获取,获取的是SPI接口的自适应实现,是新创建的类,所以不存在循环依赖的问题。
牛逼的框架,就是让你一眼看不懂它在干什么 —me