Java的SPI机制

SPI是什么

SPI的英文名称是Service Provider Interface，是Java 内置的服务发现机制。

在开发过程中，将问题进抽象成API，可以为API提供各种实现。如果现在需要对API提供一种新的实现，我们可以不用修改原来的代码，直接生成新的Jar包，在包里提供API的新实现。通过Java的SPI机制，可以实现了框架的动态扩展，让第三方的实现能像插件一样嵌入到系统中。

Java的SPI类似于IOC的功能，将装配的控制权移到了程序之外，实现在模块装配的时候不用在程序中动态指明。所以SPI的核心思想就是解耦，这在模块化设计中尤其重要。

SPI使用示例

SPI使用方法并不复杂，只需要简单的3步就可以搞定。

• 定义一个接口
• 提供方’‘META-INF/services’'目录下新建一个名称为接口全限定名的文件，内容为接口实现类的全限定名。
• 调用方通过ServiceLoader.load方法加载接口的实现类实例

下面通过一个例子来具体演示下Java SPI是如何使用的，项目的工程结构如下：
(1) 「spi-api」项目

• 定义接口类，SpiService.java：

package com.gallenzhang.spi;

/**
 * @author : zhangxq
 * @date : 2019/01/25
 * @description :
 */
public interface SpiService {

    void sayHello(String name);
}

(2) 「spi-service-a」项目

• SpiService实现类SpiServiceImplA.java

package com.gallenzhang.spi.service;

import com.gallenzhang.spi.SpiService;

/**
 * @author : zhangxq
 * @date : 2019/01/25
 * @description :
 */
public class SpiServiceImplA implements SpiService {
    @Override
    public void sayHello(String name) {
        System.out.println("Hello, " + name + "! from service-a");
    }
}

• resources下创建 "META-INF/services"目录，并在该目录下新建com.gallenzhang.spi.SpiService文件，文件内容为：

com.gallenzhang.spi.service.SpiServiceImplA

「spi-service-b」项目与「spi-service-a」项目类似，这里就不再赘述。

(3) 「spi-application」项目

• SpiMain.java

package com.gallenzhang.spi;

import java.sql.SQLException;
import java.util.Iterator;
import java.util.ServiceLoader;

/**
 * @author : zhangxq
 * @date : 2019/01/25
 * @description :Spi测试类
 */
public class SpiMain {
    public static void main(String[] args) throws SQLException {
        ServiceLoader<SpiService> loadedParsers = ServiceLoader.load(SpiService.class);
        Iterator<SpiService> iterator = loadedParsers.iterator();
        while (iterator.hasNext()){
            SpiService spiService = iterator.next();
            spiService.sayHello("gallenzhang");
        }
    }
}

(4) 运行结果如图：

可以看到通过Java SPI成功的加载到了「spi-service-a」和「spi-service-b」中接口的实现类

应用场景

比较常见的应用场景：
JDK提供一个数据库驱动接口类，JDBC加载不同的数据库驱动实现类

日志门面接口实现类加载，SLF4J加载不同厂商提供的日志实现类。

这里以JDBC为例，看看SPI是如何自动加载驱动的。下面一段代码大家都应该很熟悉了，首先加载驱动程序，然后获取数据库连接。

//加载驱动程序
//Class.forName("com.mysql.jdbc.Driver");
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);

这里首先要说明一下，使用mysql-connector-java连接数据库，在5.1.6之前的版本都需要加上Class.forName(“com.mysql.jdbc.Driver”); 但是从5.1.6版本以及后面的版本，这句代码就可以去掉了。这是为什么呢？下面通过代码来一探究竟。

public class DriverManager {
    // List of registered JDBC drivers
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    
    private DriverManager(){}

    /**
     * Load the initial JDBC drivers by checking the System property
     * jdbc.properties and then use the {@code ServiceLoader} mechanism
     */
    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<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                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);
            }
        }
    }

    public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {
        registerDriver(driver, null);
    }

    public static synchronized void registerDriver(java.sql.Driver driver,
            DriverAction da)
        throws SQLException {

        /* Register the driver if it has not already been added to our list */
        if(driver != null) {
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            // This is for compatibility with the original DriverManager
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);
    }
    
    @CallerSensitive
    public static Connection getConnection(String url,
        String user, String password) throws SQLException {
        java.util.Properties info = new java.util.Properties();

        if (user != null) {
            info.put("user", user);
        }
        if (password != null) {
            info.put("password", password);
        }

        return (getConnection(url, info, Reflection.getCallerClass()));
    }

    //  Worker method called by the public getConnection() methods.
    private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {
        /*
         * When callerCl is null, we should check the application's
         * (which is invoking this class indirectly)
         * classloader, so that the JDBC driver class outside rt.jar
         * can be loaded from here.
         */
        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
        synchronized(DriverManager.class) {
            // synchronize loading of the correct classloader.
            if (callerCL == null) {
                callerCL = Thread.currentThread().getContextClassLoader();
            }
        }

        if(url == null) {
            throw new SQLException("The url cannot be null", "08001");
        }

        println("DriverManager.getConnection(\"" + url + "\")");

        // Walk through the loaded registeredDrivers attempting to make a connection.
        // Remember the first exception that gets raised so we can reraise it.
        SQLException reason = null;

        for(DriverInfo aDriver : registeredDrivers) {
            // If the caller does not have permission to load the driver then
            // skip it.
            if(isDriverAllowed(aDriver.driver, callerCL)) {
                try {
                    println("    trying " + aDriver.driver.getClass().getName());
                    Connection con = aDriver.driver.connect(url, info);
                    if (con != null) {
                        // Success!
                        println("getConnection returning " + aDriver.driver.getClass().getName());
                        return (con);
                    }
                } catch (SQLException ex) {
                    if (reason == null) {
                        reason = ex;
                    }
                }

            } else {
                println("    skipping: " + aDriver.getClass().getName());
            }

        }

        // if we got here nobody could connect.
        if (reason != null)    {
            println("getConnection failed: " + reason);
            throw reason;
        }

        println("getConnection: no suitable driver found for "+ url);
        throw new SQLException("No suitable driver found for "+ url, "08001");
    }
}

DriverManager.getConnection(url, user, password); 执行时首先执行静态代码块，会调用loadInitialDrivers(); 这个方法能清楚看到这儿有段代码，就是通过Java的SPI加载Driver接口的所有实例，并将实例初始化。mysql-connector-java 包中META-INF/services目录下有个名为java.sql.Driver的文件，内容就是Driver接口的实现类。
com.mysql.jdbc.Driver
com.mysql.fabric.jdbc.FabricMySQLDriver

ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
try{
        while(driversIterator.hasNext()) {
          driversIterator.next();
        }
  } catch(Throwable t) {
        // Do nothing
  }

当Driver 和 FabricMySQLDriver实例化的时候，会先执行静态代码块，向DriverManager注册一个自己的实例，在DriverManager中注册的驱动信息都保存在registeredDrivers中。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

DriverManager.getConnection方法真正调用的时候，就是遍历registeredDrivers 中驱动信息，找到可以使用的驱动，拿到数据库连接。

这里通过SPI机制成功的进行解耦，代码中不再强制指定使用哪个驱动实现，而是将装配的控制权移到了程序外，成功的做到了业务代码和与第三方装配逻辑分离。

优缺点

优点：使用Java SPI机制的优势是实现了解耦，使第三方模块的装配逻辑与业务代码分离。应用程序可以根据实际业务情况使用新的框架拓展或者替换原有组件。

缺点：ServiceLoader在加载实现类的时候会全部加载并实例化，假如不想使用某些实现类，它也会被加载示例化的，这就造成了浪费。另外获取某个实现类只能通过迭代器迭代获取，不能根据某个参数来获取，使用方式上不够灵活。

Dubbo框架中大量使用了SPI来进行框架扩展，但它是重新对SPI进行了实现，完美的解决上面提到的问题。

示例代码

github地址：spi-parent