public interface IShout {
    /**
     * say hello
     */
    void sayHello();
}

public class ShoutOne implements IShout {
    /**
     * say hello
     */
    @Override
    public void sayHello() {
        System.out.println("ShoutOne.sayHello");
    }
}

public class ShoutTwo implements IShout {
    /**
     * say hello
     */
    @Override
    public void sayHello() {
        System.out.println("ShoutTwo.sayHello");
    }
}

- src
    -main
        -resources
            - META-INF
                - services
                    - cn.icanci.demo.IShout

cn.icanci.demo.ShoutOne
cn.icanci.demo.ShoutTwo

public class Main {
    public static void main(String[] args) {
        ServiceLoader<IShout> load = ServiceLoader.load(IShout.class);
        Iterator<IShout> iterator = load.iterator();
        while (iterator.hasNext()) {
            IShout next = iterator.next();
            next.sayHello();
        }
    }
}
// 输出结果如下：
// ShoutOne.sayHello
// ShoutTwo.sayHello

package java.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.AccessController;
import java.security.AccessControlContext;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

public final class ServiceLoader<S>
  implements Iterable<S>
{

  // 需要加载的文件的路径地址
  private static final String PREFIX = "META-INF/services/";

  // 需要被加载的服务或者类(可以是接口、抽象类、普通类)
  private final Class<S> service;

  // 类加载器
  private final ClassLoader loader;

  // 创建ServiceLoader时采用的访问控制上下文
  private final AccessControlContext acc;

  // 缓存providers，按实例化的顺序排列，也就是被创建的目标实例对象
  private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

  // 懒查找迭代器
  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);
  }

  // 从配置文件中解析一行，并且将改行的名称加载在列表中
  private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
                        List<String> names)
    throws IOException, ServiceConfigurationError
  {
    String ln = r.readLine();
    if (ln == null) {
      return -1;
    }
    int ci = ln.indexOf('#');
    if (ci >= 0) ln = ln.substring(0, ci);
    ln = ln.trim();
    int n = ln.length();
    if (n != 0) {
      if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
        fail(service, u, lc, "Illegal configuration-file syntax");
      int cp = ln.codePointAt(0);
      if (!Character.isJavaIdentifierStart(cp))
        fail(service, u, lc, "Illegal provider-class name: " + ln);
      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;
  }

  // 通过 URL 加载
  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 class LazyIterator
    implements Iterator<S>
  {

    Class<S> service;
    ClassLoader loader;
    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 {
          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 {
        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
    }

    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)
  {
    return new ServiceLoader<>(service, loader);
  }

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

  // 使用扩展类加载器为给定的服务类型创建一个新的服务加载器
  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() + "]";
  }
}