亲宝软件园·资讯

展开

java SPI机制 详解java实践SPI机制及浅析源码

溪~源 人气:0

1.概念

正式步入今天的核心内容之前,溪源先给大家介绍一下关于SPI机制的相关概念,最后会提供实践源代码。

SPI即Service Provider Interface,属于JDK内置的一种动态的服务提供发现机制,可以理解为运行时动态加载接口的实现类。更甚至,大家可以将SPI机制与设计模式中的策略模式建立联系。

SPI机制:

从上图中理解SPI机制:标准化接口+策略模式+配置文件;

SPI机制核心思想:系统设计的各个抽象,往往有很多不同的实现方案,在面向的对象的设计里,一般推荐模块之间基于接口编程,模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类,就违反了可拔插的原则,如果需要替换一种实现,就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明,这就需要一种服务发现机制

使用场景:

SPI机制使用约定:

从上面的图中,我们可以清晰的知道SPI的三部分:接口+实现类+配置文件;因此,项目中若要利用SPI机制,则需要遵循以下约定:

注意:除SPI,我还发布了最新Java架构项目实战教程+大厂面试题库, 点击此处免费获取,小白勿进!

2.实践

整体包结构如图:

新建标准化接口:

public interface SayService {
  void say(String word);
}

建立两个实现类

@Service
public class ASayServiceImpl implements SayService {
  @Override
  public void say(String word) {
    System.out.println(word + " A say: I am a boy");
  }
}


@Service
public class BSayServiceImpl implements SayService {
  @Override
  public void say(String word) {
    System.out.println(word + " B say: I am a girl");
  }
}

新建META-INF/services目录和配置文件(以接口全限定名)

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

com.qxy.spi.impl.ASayServiceImpl
com.qxy.spi.impl.BSayServiceImpl

单测

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpiTest {

  static ServiceLoader<SayService> services = ServiceLoader.load(SayService.class);

  @Test
  public void test1() {
    for (SayService sayService : services) {
      sayService.say("Hello");
    }
  }

}

结果

Hello A say: I am a boy
Hello B say: I am a girl

3.源码

源码主要加载流程如下:

应用程序调用ServiceLoader.load方法 ServiceLoader.load方法内先创建一个新的ServiceLoader,并实例化该类中的成员变量;

应用程序通过迭代器接口获取对象实例 ServiceLoader先判断成员变量providers对象中(LinkedHashMap<String,S>类型)是否有缓存实例对象,如果有缓存,直接返回。如果没有缓存,执行类的装载。

public final class ServiceLoader<S>
  implements Iterable<S>
{
  // 加载具体实现类信息的前缀
  private static final String PREFIX = "META-INF/services/";

  // 需要加载的接口
  // The class or interface representing the service being loaded
  private final Class<S> service;

  // 用于加载的类加载器
  // The class loader used to locate, load, and instantiate providers
  private final ClassLoader loader;

  // 创建ServiceLoader时采用的访问控制上下文
  // The access control context taken when the ServiceLoader is created
  private final AccessControlContext acc;

  // 用于缓存已经加载的接口实现类,其中key为实现类的完整类名
  // Cached providers, in instantiation order
  private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

  // 用于延迟加载接口的实现类
  // The current lazy-lookup iterator
  private LazyIterator lookupIterator;

  
  public void reload() {
    providers.clear();
    lookupIterator = new LazyIterator(service, loader);
  }

  private ServiceLoader(Class<S> svc, ClassLoader cl) {
    service = Objects.requireNonNull(svc, "Service interface cannot be null");
    loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
    acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
    reload();
  }

  private static void fail(Class<?> service, String msg, Throwable cause)
    throws ServiceConfigurationError
  {
    throw new ServiceConfigurationError(service.getName() + ": " + msg,
                      cause);
  }

  private static void fail(Class<?> service, String msg)
    throws ServiceConfigurationError
  {
    throw new ServiceConfigurationError(service.getName() + ": " + msg);
  }

  private static void fail(Class<?> service, URL u, int line, String msg)
    throws ServiceConfigurationError
  {
    fail(service, u + ":" + line + ": " + msg);
  }

  // Parse a single line from the given configuration file, adding the name
  // on the line to the names list.
  //具体解析资源文件中的每一行内容
  private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
             List<String> names)
    throws IOException, ServiceConfigurationError
  {
    String ln = r.readLine();
    if (ln == null) {
    	//-1表示解析完成
      return -1;
    }
    // 如果存在'#'字符,截取第一个'#'字符串之前的内容,'#'字符之后的属于注释内容
    int ci = ln.indexOf('#');
    if (ci >= 0) ln = ln.substring(0, ci);
    ln = ln.trim();
    int n = ln.length();
    if (n != 0) {
    	//不合法的标识:' '、'\t'
      if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
        fail(service, u, lc, "Illegal configuration-file syntax");
      int cp = ln.codePointAt(0);
      //判断第一个 char 是否一个合法的 Java 起始标识符
      if (!Character.isJavaIdentifierStart(cp))
        fail(service, u, lc, "Illegal provider-class name: " + ln);
      	//判断所有其他字符串是否属于合法的Java标识符
      for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
        cp = ln.codePointAt(i);
        if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
          fail(service, u, lc, "Illegal provider-class name: " + ln);
      }
      //不存在则缓存
      if (!providers.containsKey(ln) && !names.contains(ln))
        names.add(ln);
    }
    return lc + 1;
  }

  
  private Iterator<String> parse(Class<?> service, URL u)
    throws ServiceConfigurationError
  {
    InputStream in = null;
    BufferedReader r = null;
    ArrayList<String> names = new ArrayList<>();
    try {
      in = u.openStream();
      r = new BufferedReader(new InputStreamReader(in, "utf-8"));
      int lc = 1;
      while ((lc = parseLine(service, u, r, lc, names)) >= 0);
    } catch (IOException x) {
      fail(service, "Error reading configuration file", x);
    } finally {
      try {
        if (r != null) r.close();
        if (in != null) in.close();
      } catch (IOException y) {
        fail(service, "Error closing configuration file", y);
      }
    }
    return names.iterator();
  }

  // Private inner class implementing fully-lazy provider lookup
  //
  private class LazyIterator
    implements Iterator<S>
  {

    Class<S> service;
    ClassLoader loader;
    // 加载资源的URL集合
	  Enumeration<URL> configs = null; 
	  // 需加载的实现类的全限定类名的集合
	  Iterator<String> pending = null;
	  // 下一个需要加载的实现类的全限定类名
	  String nextName = null;

    private LazyIterator(Class<S> service, ClassLoader loader) {
      this.service = service;
      this.loader = loader;
    }

    private boolean hasNextService() {
      if (nextName != null) {
        return true;
      }
      if (configs == null) {
        try {
        // 资源名称,META-INF/services + 全限定名
          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);
        }
      }
      // 从资源中解析出需要加载的所有实现类的全限定名
      while ((pending == null) || !pending.hasNext()) {
        if (!configs.hasMoreElements()) {
          return false;
        }
        pending = parse(service, configs.nextElement());
      }
      //下一个需要加载的实现类全限定名
      nextName = pending.next();
      return true;
    }

    private S nextService() {
      if (!hasNextService())
        throw new NoSuchElementException();
      String cn = nextName;
      nextName = null;
      Class<?> c = null;
      try {
      //反射构造Class实例
        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());
         // 实例完成,添加缓存,Key:实现类全限定类名,Value:实现类实例
        providers.put(cn, p);
        return p;
      } catch (Throwable x) {
        fail(service,
           "Provider " + cn + " could not be instantiated",
           x);
      }
      throw new Error();     // This cannot happen
    }

    public boolean hasNext() {
      if (acc == null) {
        return hasNextService();
      } else {
        PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
          public Boolean run() { return hasNextService(); }
        };
        return AccessController.doPrivileged(action, acc);
      }
    }

    public S next() {
      if (acc == null) {
        return nextService();
      } else {
        PrivilegedAction<S> action = new PrivilegedAction<S>() {
          public S run() { return nextService(); }
        };
        return AccessController.doPrivileged(action, acc);
      }
    }

    public void remove() {
      throw new UnsupportedOperationException();
    }

  }

  
  public Iterator<S> iterator() {
    return new Iterator<S>() {

      Iterator<Map.Entry<String,S>> knownProviders
        = providers.entrySet().iterator();

      public boolean hasNext() {
        if (knownProviders.hasNext())
          return true;
        return lookupIterator.hasNext();
      }

      public S next() {
        if (knownProviders.hasNext())
          return knownProviders.next().getValue();
        return lookupIterator.next();
      }

      public void remove() {
        throw new UnsupportedOperationException();
      }

    };
  }

  
  public static <S> ServiceLoader<S> load(Class<S> service,
                      ClassLoader loader)
  {
  // 返回ServiceLoader的实例
    return new ServiceLoader<>(service, loader);
  }

  
  public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
  
    ClassLoader cl = ClassLoader.getSystemClassLoader();
    ClassLoader prev = null;
    while (cl != null) {
      prev = cl;
      cl = cl.getParent();
    }
    return ServiceLoader.load(service, prev);
  }

  
  public String toString() {
    return "java.util.ServiceLoader[" + service.getName() + "]";
  }

}

4.总结

SPI机制在实际开发中使用得场景也有很多。特别是统一标准的不同厂商实现,溪源也正是利用SPI机制(但略做改进,避免过多加载资源浪费)实现不同技术平台的结果文件解析需求。

优点

使用Java SPI机制的优势是实现解耦,使得第三方服务模块的装配控制的逻辑与调用者的业务代码分离,而不是耦合在一起。应用程序可以根据实际业务情况启用框架扩展或替换框架组件。

缺点

虽然ServiceLoader也算是使用的延迟加载,但是基本只能通过遍历全部获取,也就是接口的实现类全部加载并实例化一遍。如果你并不想用某些实现类,它也被加载并实例化了,这就造成了浪费。

源码传送门:SPI Service

加载全部内容

相关教程
猜你喜欢
用户评论