Dubbo的SPI机制简介分享

简介

SPI全称Service Provider Interface，是Java供给的一套用来被第三方完成或者扩展的，它可以用来启用结构扩展和替换组件。

咱们体系里笼统的各个模块，往往有许多不同的完成计划，比方日志模块、xml解析模块、jdbc模块等计划。面向的目标的设计里，咱们一般引荐模块之间依据接口编程，模块之间不对完成类进行硬编码。一旦代码里涉及详细的完成类，就违反了可拔插的准则，假如需要替换一种完成，就需要修正代码。为了完成在模块安装的时分能不在程序里动态指明，这就需要一种服务发现机制。 Java SPI便是供给这样的一个机制：为某个接口寻觅服务完成的机制。有点相似IOC的思维，便是将安装的操控权移到程序之外，在模块化设计中这个机制特别重要。

Java的SPI机制: ServiceLoader

用法

// java.sql.Driver
// 1.new一个ServiceLoader
ServiceLoader<Driver> drivers = ServiceLoader.load(Driver.class);
Iterator<Driver> iterator = drivers.iterator();
// 2.调用推迟加载器的hashNext
while (iterator.hasNext()) {
 // 3.调用推迟加载器的next
 Driver next = iterator.next();
 System.out.println(next.getClass());
}

// result:
class com.mysql.jdbc.Driver
class com.mysql.fabric.jdbc.FabricMySQLDriver
class com.alibaba.druid.proxy.DruidDriver
class com.alibaba.druid.mock.MockDriver

原理

ServiceLoader并不会在load的时分去加载一切接口对应完成类的文件。而是在履行接口的时分去遍历加载。

ServiceLoader的中心特点

// 接口全限定名的文件的途径前缀
private static final String PREFIX = "META-INF/services/";

// 被加载的接口
private final Class<S> service;

// 类的加载器
private final ClassLoader loader;

// 创立serviceLoader时 访问操控上下文
private final AccessControlContext acc;

// 服务缓存池（k-> 类全报名  v-> 完成类信息）
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

// 推迟加载的迭代器
private LazyIterator lookupIterator;

LazyIterator的中心特点

// 接口类型
Class<S> service;
// 接的加载器
ClassLoader loader;
// META-INF/services/内装备文件的URL调集
Enumeration<URL> configs = null;
// 需加载的完成类的全包名调集
Iterator<String> pending = null;
// 下一个完成类的全报名，用于迭代器推迟加载的下一个类
String nextName = null;

源码解析

1、load办法

// 1、load办法
public static <S> ServiceLoader<S> load(Class<S> service) {
 // 获取当时线程的类加载器
 ClassLoader cl = Thread.currentThread().getContextClassLoader();
 // 继续调用重载的办法
 return ServiceLoader.load(service, cl);
}

// 2、调用重载办法
public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader) {
 // new 一个ServiceLoader目标
 return new ServiceLoader<>(service, loader);
}

// 3、new 一个serviceLoader目标
private ServiceLoader(Class<S> svc, ClassLoader cl) {
 // PS：服务接口不能为空
 service = Objects.requireNonNull(svc, "Service interface cannot be null");
 // 指定加载器
 loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
 // 指定下上容器（默以为null）
 acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
 // 改写：1.重置服务缓冲池 2.new一个推迟加载的迭代器
 reload();
}

// 4、改写 
public void reload() {
 // 重置服务缓存池
 providers.clear();
 // 构造一个推迟加载的迭代器
 lookupIterator = new LazyIterator(service, loader);
}

// 5、new LazyIterator
private LazyIterator(Class<S> service, ClassLoader loader) {
 // 指定接口的类信息
 this.service = service;
 // 指定类加载器
 this.loader = loader;
}

2、获取推迟加载的迭代器

3、调用推迟加载迭代器的hasNext()办法

// 1、调用hasNext()办法
public boolean hasNext() {
  // 默许 acc为null
 if (acc == null) {
  // 履行hasNextService()办法
  return hasNextService();
  } else {
  PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
   public Boolean run() { return hasNextService(); }
   };
  return AccessController.doPrivileged(action, acc);
  }
}

// 2、调用hasNextService()办法
private boolean hasNextService() {
 // 默许第一次履行 nextName为null
 if (nextName != null) {
  return true;
  }
 // 默许第一次履行 configs为null, 经过类加载器加载类的全报名，然后获取URL。
 if (configs == null) {
  try {
   // "META-INF/services/" + java.sql.Driver
   // 1.file:/Users/zhouzeng/.m2/repository/mysql/mysql-connector-java/5.1.38/mysql-connector-java-5.1.38.jar!/META-INF/services/java.sql.Driver
   // 2.file:/Users/zhouzeng/.m2/repository/com/alibaba/druid/1.0.28/druid-1.0.28.jar!/META-INF/services/java.sql.Driver
   String fullName = PREFIX + service.getName();
   if (loader == null) {
    configs = ClassLoader.getSystemResources(fullName);
    } else {
    configs = loader.getResources(fullName);
    }
   } catch (IOException x) {
   fail(service, "Error locating configuration files", x);
   }
  }
 // 默许第一次履行 pending为null
 while ((pending == null) || !pending.hasNext()) {
  if (!configs.hasMoreElements()) {
   return false;
   }
  // 依据 接口+ URL 解析 
  /**
   * 1.0 = "com.mysql.jdbc.Driver" 1 = "com.mysql.fabric.jdbc.FabricMySQLDriver"
   * 2.0 = "com.alibaba.druid.proxy.DruidDriver" 1 = "com.alibaba.druid.mock.MockDriver"
   **/
  pending = parse(service, configs.nextElement());
  }
 // com.mysql.jdbc.Driver
 nextName = pending.next();
 return true;
}

4、next()办法

// 1.履行next办法
public S next() {
 // 默许 acc为null
 if (acc == null) {
  // 调用nexrService()办法
  return nextService();
  } else {
  PrivilegedAction<S> action = new PrivilegedAction<S>() {
   public S run() { return nextService(); }
   };
  return AccessController.doPrivileged(action, acc);
  }
}

// 2.履行nextService()办法
private S nextService() {
 // 判别是否还有下一个类需要加载
 if (!hasNextService()) {
  throw new NoSuchElementException(); 
  }
 // 1.com.mysql.jdbc.Driver
 // 2.com.mysql.fabric.jdbc.FabricMySQLDriver
 // 3.com.alibaba.druid.proxy.DruidDriver
 // 4.com.alibaba.druid.mock.MockDriver
 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 {
  // 将完成类的实例，转化为接口类型（类型转化）
  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();
}

优缺点

优点：将业务代码和详细完成类解耦，便利扩展。如需增加新逻辑，无需修正主流程，直接在PI装备文件增加完成类的全限定名即可。

缺点：颗粒度不行细，无法精确定位某一个完成类。要履行就履行一切的完成类。

SpringBoot 之SPI机制：SpringFactoriesLoader

使用

1.创立一个enableConfiguration

@Configuration
@EnableConfigurationProperties({MybatisProperties.class})
public class MybatisAutoConfiguration {
  
}

2.在resources下界说META-INF/spring.factories

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

3.用SpringBoot发动

@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    } 
}

在springbot发动时回去加载MybatisAutoConfiguration这个类。

原理

1、在SpringBoot发动时，在refreshContext()时，回去调用@Import的selector。

2、然后履行 AutoConfigurationImportSelector的process()办法获取对应的configuration的List。

3、由Spring 去加载实例化configuration的装备类。

// 1.SpringBootApplication中的SpringBootConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};
}
// 2.SpringBootConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
	Class<?>[] exclude() default {};
	String[] excludeName() default {};
}
// 3.检查 AutoConfigurationImportSelector的selectImports()办法
public String[] selectImports(AnnotationMetadata annotationMetadata) {
  if (!this.isEnabled(annotationMetadata)) {
    return NO_IMPORTS;
  } else {
    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
    AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
    // 获取enableautoconfiguration相关的类
    List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
    configurations = this.removeDuplicates(configurations);
    Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
    this.checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
    configurations = this.filter(configurations, autoConfigurationMetadata);
    this.fireAutoConfigurationImportEvents(configurations, exclusions);
    return StringUtils.toStringArray(configurations);
  }
}
// 4. 履行getCandidateConfigurations()办法
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, 
                                                  AnnotationAttributes attributes) {
  // 获取configurations
  List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
    															this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
  Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
  return configurations;
}
// 5. 履行loadFactoryNames()办法
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
  // org.springframework.boot.autoconfigure.EnableAutoConfiguration
  String factoryClassName = factoryClass.getName();
  // 加载spring.fatories的装备项，然后获取key为EnableAutoConfiguration的value
  return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

SpringFactoriesLoader的中心特点

// 1.spring 资源加载的默许途径
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
// 2.缓存池 K为类加载器 HK为接口全包名 HV为完成类
private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();

// 6.履行loadSpringFactories()办法，依据类加载器，获取META-INF/spring.factories下的装备
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
  // 在缓存池中获取，有则直接回来。
  MultiValueMap<String, String> result = cache.get(classLoader);
  if (result != null) {
    return result;
  }
  try {
    // 获取"META-INF/spring.factories"的URL
    Enumeration<URL> urls = (classLoader != null ?
                             classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                             ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
    result = new LinkedMultiValueMap<>();
    while (urls.hasMoreElements()) {
      URL url = urls.nextElement();
      UrlResource resource = new UrlResource(url);
      Properties properties = PropertiesLoaderUtils.loadProperties(resource);
      for (Map.Entry<?, ?> entry : properties.entrySet()) {
        List<String> factoryClassNames = Arrays.asList(
          StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
        result.addAll((String) entry.getKey(), factoryClassNames);
      }
    }
    // 将解析出来的数据放到缓存池中。
    cache.put(classLoader, result);
    return result;
  }
  catch (IOException ex) {
    throw new IllegalArgumentException("Unable to load factories from location [" +
                                       FACTORIES_RESOURCE_LOCATION + "]", ex);
  }
}