JAVA SPI机制

少侠你现在是否还这样连接数据库

try {
    Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager.getConnection("URL","root","password");
} catch (Exception e) {
    e.printStackTrace();
}

少侠你知道Class.forName()这句早已经没用了么？Java 官方已经把它优化掉了。想知道怎么优化的么？不要急，且看我慢慢道来。

SPI

SPI 全名：Service Provider Interface，是 JDK 内置的一种服务发现机制，可以将服务接口与服务发现分离以达到解耦的效果。可以提升程序的可扩展性。比如 jdbc 只提供了接口，具体的实现由各个运营商解决、经常用的 log 日志类LogFactory，还有阿里的 dubbo 更是将 SPI 运用的淋漓尽致。

SPI 使用说明：

• 在 resources 目录下新建 META-INF/services 目录，并在目录下创建一个文件，文件名字为接口的全限定名，文件内容为实现类的全限定名。
• 通过java.util.ServiceLoder类加载实现类。
• SPI 的实现类必须携带一个不带参数的构造方法。

来个示例

首先定义一个接口

public interface Pay {
    void pay();
}

再来两个实现类

public class AliPay implements Pay {
    @Override
    public void pay() {
        System.out.println("AliPay");
    }
}

public class WeChatPay implements Pay {
    @Override
    public void pay() {
        System.out.println("WeChatPay");
    }
}

在 resources 目录下新建 META-INF/services 目录，并在目录下创建一个文件，文件名为接口的权限定名com.yao.spi.Pay，文件内容为实现类的全限定名

com.yao.spi.AliPay

通过java.util.ServiceLoder获取实现类。

public static void main(String[] args) {

    ServiceLoader<Pay> spiDemoServiceLoader = ServiceLoader.load(Pay.class);

    Iterator<Pay> payIterator = spiDemoServiceLoader.iterator();
    while (payIterator.hasNext()){
        Pay pay = payIterator.next();
        pay.pay();
    }
}

看一下结果。

AliPay

有没有注意到ServiceLoder获取到的是一个列表？这说明什么问题？对的，可以一次初始化多个实现类，只要在文件中声明就可以了。现在再把WechatPay给添加上

com.yao.spi.AliPay
com.yao.spi.WeChatPay

看一下运行结果

AliPay
WeChatPay

源码解析

SPI 的功能比较简单，一个ServiceLoader类包含所有的功能。先来看一下有那些主要的属性和内部类的主要属性。

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;
    //已加载的服务类
    private LinkedHashMap<String, S> providers = new LinkedHashMap();
    //内部类，真正加载类的地方
    private ServiceLoader<S>.LazyIterator lookupIterator;
    //内部类
    private class LazyIterator implements Iterator<S> {
        //加载的类或接口
        Class<S> service;
        //类加载器
        ClassLoader loader;
        //保存配置文件中的信息
        Enumeration<URL> configs;
        //保存配置文件中所有的实现类的全限定名
        Iterator<String> pending;
        String nextName;
        }
}

当看到内部类LazyIterator这个Lazy时，会不会联想到 spring 加载 bean 时的懒加载。这里其实也是一样，当调用load方法时，并不会加载类，只初始化一些内部属性。真正加载实现类是在获取实现类时。

沿着上面main方法第一次获取实现类的过程一步一步解析，第一次以后获取的过程有兴趣的少侠可以自己走一遍。

注册实现类

spiDemoServiceLoader.iterator();获取的迭代器是ServiceLoader重写的迭代器，迭代器中的方法都指向了内部类LazyIterator

 public Iterator<S> iterator() {
        return new Iterator<S>() {
            Iterator<Entry<String, S>> knownProviders;

            {
                this.knownProviders = ServiceLoader.this.providers.entrySet().iterator();
            }

            public boolean hasNext() {
                return this.knownProviders.hasNext() ? true : ServiceLoader.this.lookupIterator.hasNext();
            }

            public S next() {
                return this.knownProviders.hasNext() ? ((Entry)this.knownProviders.next()).getValue() : ServiceLoader.this.lookupIterator.next();
            }

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

当调用payIterator.hasNext()时，调用的是重写迭代器中的

  public boolean hasNext() {
      return this.knownProviders.hasNext() ? true : ServiceLoader.this.lookupIterator.hasNext();
  }

然后会调用内部类LazyIterator中的hasNext()方法

 public boolean hasNext() {
      if (ServiceLoader.this.acc == null) {
          return this.hasNextService();
      } else {
          //省略
      }
  }

接着调用调用内部类LazyIterator中的hasNextService()方法

 private boolean hasNextService() {
      if (this.nextName != null) {
          return true;
      } else {
          if (this.configs == null) {
              try 
                  文件路径
                  String var1 = "META-INF/services/" + this.service.getName();
                  //读取配置文件，并将配置文件内容保存到configs
                  if (this.loader == null) {
                      this.configs = ClassLoader.getSystemResources(var1);
                  } else {
                      this.configs = this.loader.getResources(var1);
                  }
              } catch (IOException var2) {
                    //省略
              }
          }

          while(this.pending == null || !this.pending.hasNext()) {
            if (!this.configs.hasMoreElements()) {
                  return false;
                }
              //将文件中的实现类权限定名保存到pending中
              this.pending = ServiceLoader.this.parse(this.service, (URL)this.configs.nextElement());
              }

          this.nextName = (String)this.pending.next();
          return true;
          }
        }

第一次到这里时，会将配置文件的信息保存到到内部类中的’configs’属性中，并解析文件将配置的所有实现类保存到内部类中的pending中，但是这里还是没有未初始化类。

获取实现类

当调用payIterator.next();时，调用的是重写的

public S next() {
    return this.knownProviders.hasNext() ? ((Entry)this.knownProviders.next()).getValue() : ServiceLoader.this.lookupIterator.next();
}

并最终调用到内部类LazyIterator中的next()方法

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

然后调用内部类LazyIterator中的nextService()方法

private S nextService() {
    if (!this.hasNextService()) {
        throw new NoSuchElementException();
    } else {
        String var1 = this.nextName;
        this.nextName = null;
        Class var2 = null;

        try {
	         //初始化实现类
            var2 = Class.forName(var1, false, this.loader);
        } catch (ClassNotFoundException var5) {
         
        }

        //忽略掉后面的代码
    }
}

看到Class.forName()，到此才是初始化实现类。

JDBC 中的运用

回到最初的话题，既然Class.forName()没有用了，那JDBC在那优化的呢？首先要知道Class.forName()的作用：强制JVM将com.mysql.jdbc.Driver这个类加载入内存，以便DriverManager类使用，现在既然用不到了，那肯定是在别的地方加载了。那用什么方式加载的？当然是SPI了，要不然前面一大堆东西不是白说了么，哈哈哈哈！看看mysql的jar里

是不是很熟悉，这不就是SPI规范么。

OK，来看看加载的过程。
既然只需要这一句就可以了

Connection connection = DriverManager.getConnection("URL","root","password");

加载

那就从DriverManager类开始，类加载当然要从静态代码块开始了，看一下DriverManager的静态代码块。

    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
        SET_LOG_PERMISSION = new SQLPermission("setLog");
        DEREGISTER_DRIVER_PERMISSION = new SQLPermission("deregisterDriver");
    }

进loadInitialDrivers()方法

熟不熟悉？是不是SPI机制？DriverManager在初始化类时，会先利用SPI机制加载数据库的驱动。那又是怎么注册到DriverManager的呢？继续看！

加载

在上面SPI机制中说了，当调用next()方法时会初始化实现类，也就是会初始化Driver类，那就再看Driver类。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}

静态代码块中DriverManager.registerDriver(new Driver());就是将Driver注册到DriverManager。
总结一下加载过程：

1. DriverManager在静态代码块中利用SPI机制获取到数据库驱动，并初始化Driver
2. Driver初始化时首先运行静态代码块将Driver注册到DriverManager