Java中SPI的一些理解

/**
 * @author jimoer
 **/
public interface SpiInterfaceService {

  /**
   * 打印参数
   * @param parameter 参数
   */
  void printParameter(String parameter);
}

package com.jimoer.spi.service.one;
import com.jimoer.spi.app.SpiInterfaceService;

/**
 * @author jimoer
 **/
public class SpiOneService implements SpiInterfaceService {
  /**
   * 打印参数
   *
   * @param parameter 参数
   */
  @Override
  public void printParameter(String parameter) {
    System.out.println("我是SpiOneService:"+parameter);
  }
}

package com.jimoer.spi.service.two;
import com.jimoer.spi.app.SpiInterfaceService;
/**
 * @author jimoer
 **/
public class SpiTwoService implements SpiInterfaceService {
  /**
   * 打印参数
   *
   * @param parameter 参数
   */
  @Override
  public void printParameter(String parameter) {
    System.out.println("我是SpiTwoService:"+parameter);
  }
}

<dependencies>
  <dependency>
    <groupId>com.jimoer.spi</groupId>
    <artifactId>spi-service-one</artifactId>
    <version>1.0-SNAPSHOT</version>
  </dependency>
  <dependency>
    <groupId>com.jimoer.spi</groupId>
    <artifactId>spi-service-two</artifactId>
    <version>1.0-SNAPSHOT</version>
  </dependency>
</dependencies>

/**
 * @author jimoer
 **/
public class SpiService {

  public static void main(String[] args) {

    ServiceLoader<SpiInterfaceService> spiInterfaceServices = ServiceLoader.load(SpiInterfaceService.class);
    Iterator<SpiInterfaceService> iterator = spiInterfaceServices.iterator();
    while (iterator.hasNext()){
      SpiInterfaceService sip = iterator.next();
      sip.printParameter("参数");
    }
  }
}

ServiceLoader<SpiInterfaceService> spiInterfaceServices = ServiceLoader.load(SpiInterfaceService.class);

public static <S> ServiceLoader<S> load(Class<S> service) {
  ClassLoader cl = Thread.currentThread().getContextClassLoader();
  return ServiceLoader.load(service, cl);
}

// 固定路径
private static final String PREFIX = "META-INF/services/";

private boolean hasNextService() {
   if (nextName != null) {
     return true;
   }
   if (configs == null) {
     try {
     	// 固定路径+接口全限定名称
       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());
   }
   // 后面next()方法中判断当前类是否已经出现化的时候要用
   nextName = pending.next();
   return true;
 }

private S nextService() {
   if (!hasNextService())
     throw new NoSuchElementException();
   String cn = nextName;
   nextName = null;
   Class<?> c = null;
   try {
   // 直接加载类，无需初始化（因为上面hasNext()已经初始化了）。
     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();     // This cannot happen
 }