深入解析Java SPI🌟从使用到原理的全面之旅🚀

   package com.caicai;
   
   /**
    * @author: 菜菜的后端私房菜
    * @create: 2025/1/5 10:24
    * @description:
    */
   public interface DatabaseInterface {
       String getDatabaseName();
   }

   package com.caicai;
   
   /**
    * @author: 菜菜的后端私房菜
    * @create: 2025/1/5 10:28
    * @description:
    */
   public class MySQLDatabase implements DatabaseInterface{
       @Override
       public String getDatabaseName() {
           return "MySQL";
       }
   }

   package com.caicai;
   
   /**
    * @author: 菜菜的后端私房菜
    * @create: 2025/1/5 10:31
    * @description:
    */
   public class PgSQLDatabase implements DatabaseInterface{
       @Override
       public String getDatabaseName() {
           return "PgSQL";
       }
   }

   import java.util.ServiceLoader;
   
   /**
    * @author: 菜菜的后端私房菜
    * @create: 2025/1/5 10:25
    * @description:
    */
   public class SPIDemo {
       public static void main(String[] args) {
           ServiceLoader<DatabaseInterface> serviceLoader = ServiceLoader.load(DatabaseInterface.class);
           for (DatabaseInterface databaseInterface : serviceLoader) {
               System.out.println("使用的数据库:" + databaseInterface.getDatabaseName());
           }
       }
   }
   
   /*
   结果输出：
   使用的数据库:MySQL
   使用的数据库:PgSQL
   */

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

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();
}

public void reload() {
    //清空缓存
    providers.clear();
    lookupIterator = new LazyIterator(service, loader);
}

for (DatabaseInterface databaseInterface : serviceLoader) {
    System.out.println("使用的数据库:" + databaseInterface.getDatabaseName());
}

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();
        }

    };
}

private boolean hasNextService() {
    if (nextName != null) {
        return true;
    }
    
    //configs是SPI配置文件资源，不为空说明已经加载过
    if (configs == null) {
        try {
            //文件路径：META-INF/services  + SPI接口全限定类名
            String fullName = PREFIX + service.getName();
            if (loader == null)
                configs = ClassLoader.getSystemResources(fullName);
            else
                //查找资源目录下SPI配置文件
                configs = loader.getResources(fullName);
        } catch (IOException x) {
            fail(service, "Error locating configuration files", x);
        }
    }
    
    //pending是实现类全限定类名的迭代器
    while ((pending == null) || !pending.hasNext()) {
        if (!configs.hasMoreElements()) {
            return false;
        }
        //如果实现类迭代器没有下一个值 并且 解析的SPI配置文件有内容就进行解析
        //解析就是读取每一行的全限定类名放入列表最后返回全限定类名的迭代器
        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
}

static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}

private static void loadInitialDrivers() {
    String drivers;
    try {
        drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });
    } catch (Exception ex) {
        drivers = null;
    }
    // If the driver is packaged as a Service Provider, load it.
    // Get all the drivers through the classloader
    // exposed as a java.sql.Driver.class service.
    // ServiceLoader.load() replaces the sun.misc.Providers()

    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
			
            //实例化ServiceLoader
            ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
            Iterator<Driver> driversIterator = loadedDrivers.iterator();

            /* Load these drivers, so that they can be instantiated.
             * It may be the case that the driver class may not be there
             * i.e. there may be a packaged driver with the service class
             * as implementation of java.sql.Driver but the actual class
             * may be missing. In that case a java.util.ServiceConfigurationError
             * will be thrown at runtime by the VM trying to locate
             * and load the service.
             *
             * Adding a try catch block to catch those runtime errors
             * if driver not available in classpath but it's
             * packaged as service and that service is there in classpath.
             */
            try{
                //加载实现类
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
            } catch(Throwable t) {
            // Do nothing
            }
            return null;
        }
    });

    println("DriverManager.initialize: jdbc.drivers = " + drivers);

    if (drivers == null || drivers.equals("")) {
        return;
    }
    String[] driversList = drivers.split(":");
    println("number of Drivers:" + driversList.length);
    for (String aDriver : driversList) {
        try {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        } catch (Exception ex) {
            println("DriverManager.Initialize: load failed: " + ex);
        }
    }
}