Java中的SPI源码及DriverManager分析

SPI相关源码分析

ClassLoader

//F7单步执行不会进入，必须使用alt+shift+F7强制进入
//AppClassLoader
loader.getResources(fullName);

//ExtClassLoader、AppClassLoader都继承UrlClassLoader再继承ClassLoader，UrlClassLoader中包含UrlClassPath ucp字段，
//返回一个枚举器(懒惰加载)，遍历枚举器时才会
Enumeration<Resource> e = UrlClassPath.getResources(String className)
//根据className遍历loaders进行加载   
e.hasMoreElement()或e.next()

public Enumeration<URL> getResources(String name) throws IOException {
    Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];
    if (parent != null) {
        // AppClassLoader的parent为ExtClassLoader，获取其组合的枚举器
        tmp[0] = parent.getResources(name);
    } else {
        // ExtClassLoader的parent为null，组合BootstrapResources
        tmp[0] = getBootstrapResources(name);
    }
    tmp[1] = findResources(name);
    return new CompoundEnumeration<>(tmp);
}

CompoundEnumeration

private boolean next() {
//遍历枚举器数组找到满足情况的枚举
while(this.index < this.enums.length) {
    if (this.enums[this.index] != null && this.enums[this.index].hasMoreElements()) {
        return true;
    }
    ++this.index;
}
return false;   
}

UrlClassPath

public Enumeration<Resource> getResources(final String var1, final boolean var2) {
return new Enumeration<Resource>() {
private int index = 0;
private int[] cache = URLClassPath.this.getLookupCache(var1);
private Resource res = null;

private boolean next() {
    if (this.res != null) {
        return true;
    } else {
        do {
            URLClassPath.Loader var1x;
            // UrlClassPath中包含ArrayList<URLClassPath.Loader> loaders字段，每个loader一般情况下是一个jarLoader,负责加载jar文件
            if ((var1x = URLClassPath.this.getNextLoader(this.cache, this.index++)) == null) {
                return false;
            }
            // 遍历jarLoader，确定其是否找到对应的class
            this.res = var1x.getResource(var1, var2);
        } while(this.res == null);

        return true;
    }
}

ServiceLoader

// ServiceLoader.LazyIterator
// 判断迭代器中是否还有下一个服务
private boolean hasNextService() {
    if (nextName != null) {
        return true;
    }
    if (configs == null) {
        // 组装META-INF\services\className
        String fullName = PREFIX + service.getName();
        if (loader == null)
            configs = ClassLoader.getSystemResources(fullName);
        else
        // 使用AppClassLoader生成枚举器
            configs = loader.getResources(fullName);
    }
    while ((pending == null) || !pending.hasNext()) {
        //第一次进入或当第一个META-INF\services\className的file中的所有实现类已经初始化完成后，继续找其他的实现类file
        if (!configs.hasMoreElements()) {
            return false;
        }
        // 解析找到的包含了META-INF\services\className的file的URL，得到实现类名称的迭代器
        pending = parse(service, configs.nextElement());
    }
    // 返回实现类名称
    nextName = pending.next();
    return true;
}

private S nextService() {
    if (!hasNextService())
        throw new NoSuchElementException();
    String cn = nextName;
    // 设置为null，便于下一次hashNextService时得到下一个实现类的名称
    nextName = null;
    Class<?> c = null;
    // 找到实现类Class
    //第二个参数表示是否执行该class的初始化，初始化的概念如下
    https://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4
    Initialization of a class consists of executing its static initializers and the initializers for static fields (class variables) declared in the class.
    Initialization of an interface consists of executing the initializers for fields (constants) declared in the interface.
    c = Class.forName(cn, false, loader);
    S p = service.cast(c.newInstance());
    //放入providers数组中
    providers.put(cn, p);
    return p;
}

DriverManager实践

static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}
    
private static void loadInitialDrivers() {
   // 
   ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
   Iterator<Driver> driversIterator = loadedDrivers.iterator();
   //找到下一个实现类
   while(driversIterator.hasNext()) {
      //初始化下一个实现类并放入ServiceLoader.providers中
      driversIterator.next();
   }
   //第一次遍历迭代器从lazyIterator中获取对象并设置到providers中，再次初始化迭代器直接从providers中获取对应的实现类
   //driversIterator = loadedDrivers.iterator();
}

//早期的jdbc使用方式
//注册 JDBC 驱动
Class.forName(JDBC_DRIVER);
//不确定是如何使用注册的Driver的
conn = DriverManager.getConnection(DB_URL,USER,PASS);

//后续的方式
//com.mysql.jdbc.Driver&org.postgresql.Driver都包含如下内容
static {
//注册自己的Driver到DriverManager.registeredDrivers(static)中
//由ServiceLoader中S p = service.cast(c.newInstance()),c为Driver对应的Class，触发行为
DriverManager.registerDriver(new Driver());
}
            
//DriverManager.getConnection()
//
for(DriverInfo aDriver : registeredDrivers) {
    //测试使用postgrel的Driver去连mysql，此处返回null
    Connection con = aDriver.driver.connect(url, info);
    if (con != null) {
        // Success!
        println("getConnection returning " + aDriver.driver.getClass().getName());
        return (con);
    }
}

不足

接口所有的实现类都newInstance()
ServiceLoader对多线程不够友好