少侠你现在是否还这样连接数据库
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。
总结一下加载过程：
- DriverManager在静态代码块中利用SPI机制获取到数据库驱动，并初始化Driver
- Driver初始化时首先运行静态代码块将Driver注册到DriverManager
