深入理解 Java SPI机制

package com.sunfy.Animal;
public interface Animal {
    void noise();
}

package com.sunfy.Animal;
public class Dog implements Animal {
    @Override
    public void noise() {
        System.out.println("wang");
    }
}
--------------------------------------------
package com.sunfy.Animal;
public class Cat implements Animal{
    @Override
    public void noise() {
        System.out.println("miao");
    }
}

package com.sunfy;
import com.sunfy.Animal.Animal;
import sun.misc.Service;
import java.util.Iterator;
import java.util.ServiceLoader;
public class SpiDemoMain {
    public static void main(String[] args) {
        // Spi机制获取Animal接口所有的实现类，在不修改业务代码的基础上，很方便的进行数据扩展
        ServiceLoader<Animal> animals = ServiceLoader.load(Animal.class);
        animals.forEach(animal -> animal.noise());
        System.out.println("--------------------------------");
        Iterator<Animal> providers = Service.providers(Animal.class);
        ServiceLoader<Animal> load = ServiceLoader.load(Animal.class);
        while(providers.hasNext()) {
            Animal animal = providers.next();
            animal.noise();
        }
        System.out.println("--------------------------------");
        Iterator<Animal> iterator = load.iterator();
        while(iterator.hasNext()) {
            Animal animal = iterator.next();
            animal.noise();
        }
    }
}

public final class ServiceLoader<S>
    implements Iterable<S> {
    // 配置文件路径
    private static final String PREFIX = "META-INF/services/";
    // The class or interface representing the service being loaded
    // 加载的服务类或接口
    private final Class<S> service;
    // The class loader used to locate, load, and instantiate providers
    // 类加载器
    private final ClassLoader loader;
    // The access control context taken when the ServiceLoader is created
    private final AccessControlContext acc;
    // Cached providers, in instantiation order
    // 已加载的服务类集合
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    // The current lazy-lookup iterator
    // 当前的惰性查找迭代器
    private LazyIterator lookupIterator;
}

public void reload() {
    providers.clear();
    // 实例化ServiceLoader<S> 内部类
    lookupIterator = new LazyIterator(service, loader);
}
private ServiceLoader(Class<S> svc, ClassLoader cl) {
    // svc，要加载类接口 非空校验
    service = Objects.requireNonNull(svc, "Service interface cannot be null");
    // 返回用于委托的系统类加载器
    loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
    // 获取系统安全性接口，及访问权限
    acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
    // 重新加载系统接口
    reload();
}

public static <S> ServiceLoader<S> load(Class<S> service,
                                        ClassLoader loader){
    // 调用load方法，最终还是调用ServiceLoader初始化方法，调用---》new LazyIterator(service, 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 Iterator<S> iterator() {
    return new Iterator<S>() {
        public boolean hasNext() {
            return lookupIterator.hasNext();
        }
        public S next() {
            return lookupIterator.next();
        }
        .......
    };
}

//sunfy- SPI核心的获取实现类的方法
private boolean hasNextService() {
    // 类名不等于Null,代表类已经加载完成
    if (nextName != null) {
        return true;
    }
    if (configs == null) {
        try {
            // 待加载文件路径
            // PREFIX = "META-INF/services/"
            // service.getName() 为自定义的类的全限定名
            // META-INF/services/com.sunfy.Animal.Animal
            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;
        }
        // 将给定URL的内容解析为提供程序配置文件。
    	// parse方法中，真正的解析文件，读取文件内容，并将读取内容封装后返回（此处只是读取到类的全限定名，还没有创建类对象）
        pending = parse(service, configs.nextElement());
    }
    // 拿到第一个实现类的类名
    nextName = pending.next();
    return true;
}

public class DriverManager {
    private static void loadInitialDrivers() {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                //很明显，它要加载Driver接口的服务类，Driver接口的包为:java.sql.Driver
                //所以它要找的就是META-INF/services/java.sql.Driver文件
                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                try{
                    //查到之后创建对象
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                    // Do nothing
                }
                return null;
            }
        });
    }
}

package com.mysql.jdbc;
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static {
        try {
            //注册
            //调用DriverManager类的注册方法
            //往registeredDrivers集合中加入实例
            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()
    }
}

private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {   
    //registeredDrivers中就包含com.mysql.cj.jdbc.Driver实例
    for(DriverInfo aDriver : registeredDrivers) {
        if(isDriverAllowed(aDriver.driver, callerCL)) {
            try {
                //调用connect方法创建连接
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    return (con);
                }
            }catch (SQLException ex) {
                if (reason == null) {
                    reason = ex;
                }
            }
        } else {
            println("    skipping: " + aDriver.getClass().getName());
        }
    }
}

package com.viewscenes.netsupervisor.spi
public class MyDriver extends NonRegisteringDriver implements Driver{
    static {
        try {
            java.sql.DriverManager.registerDriver(new MyDriver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    public MyDriver()throws SQLException {}
    public Connection connect(String url, Properties info) throws SQLException {
        System.out.println("准备创建数据库连接.url:"+url);
        System.out.println("JDBC配置信息："+info);
        info.setProperty("user", "root");
        Connection connection =  super.connect(url, info);
        System.out.println("数据库连接创建完成!"+connection.toString());
        return connection;
    }
}
--------------------输出结果---------------------
准备创建数据库连接.url:jdbc:mysql:///consult?serverTimezone=UTC
JDBC配置信息：{user=root, password=root}
数据库连接创建完成!com.mysql.cj.jdbc.ConnectionImpl@7cf10a6f