java SPI机制分析

SPI是什么

     SPI，全拼Service Provider Interface，可翻译成服务提供者接口。其思想源自服务提供者框架（Service Provider Framework)，是一种将服务接口与服务实现分离以达到解耦、提升程序可扩展性的机制。引入服务提供者就是引入了spi接口的实现者，通过本地的注册发现获取到具体的实现类，达到轻松可插拔的目的。

SPI具体约定

       java spi的具体约定为:当服务的提供者，提供了服务接口的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接口命名的文件。该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。基于这样一个约定就能很好的找到服务接口的实现类，而不需要在代码里制定。jdk提供服务实现查找的一个工具类：java.util.ServiceLoader

案例

接口

package com.code.spi;

public interface GreetService {
	public void sayHello(String name);
}

实现一

package com.code.spi;

public class ChineseGreet implements GreetService {

	@Override
	public void sayHello(String name) {
		System.out.println(name + ",你好！");
	}

}

实现二

package com.code.spi;

public class EnglishGreet implements GreetService {

	@Override
	public void sayHello(String name) {
		System.out.println("Hello " + name + "!");
	}

}

       然后创建META-INF/services目录，里面新建文件com.code.spi.GreetService（文件名为接口名），文件内容为具体的实现类的全类名（com.code.spi.ChineseGreet）。

测试代码

package com.code.spi;

import java.util.Iterator;
import java.util.ServiceLoader;

public class TestSPI {
	
	public static void main(String[] args) {
		ServiceLoader<GreetService> serviceLoader = ServiceLoader.load(GreetService.class);
		Iterator<GreetService> iterator = serviceLoader.iterator();
		while(iterator.hasNext()){
			iterator.next().sayHello("Bob");
		}
	}
}

说明

       项目想要用哪个实现类，只需要自己实现接口，然后将META-INF/services下com.code.spi.GreetService文件里的内容改为自己想用的实现类的全路径名称就可以了。

ServiceLoader源码解读

1.通过ServiceLoader.load方法加载服务提供者

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

2.根据服务名和类加载器创建懒加载模式的lookupIterator，用于存放服务提供者

    public void reload() {
        providers.clear();
        lookupIterator = new LazyIterator(service, loader);
    }

3.当程序从上述的lookupIterator获取具体的服务提供者时，首先LazyIterator会通过hasNext()来判断是否存在服务提供者，判    断逻辑如下

• ClassLoader去META-INF/services/service.getName()路径下查找类提供者的配置文件
  
• 如果找到了对应的配置文件，则去解析配置文件
  
• 解析过程：按行读取配置文件内容，每一行即是一个类提供者。然后做一些类名合法性校验，校验通过则将类名存放在names数组里面，返回true

public boolean hasNext() {
    if (nextName != null) {
        return true;
    }
    if (configs == null) {
        try {
        	//服务提供者配置文件路径META-INF/services/serviceName
            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;
        }
        //按行解析配置文件里的服务提供者
        pending = parse(service, configs.nextElement());
    }
    nextName = pending.next();
    return true;
}

4.如果hasNext()返回true，则通过Class.forName()查找对应的类，创建服务提供者实例，最后放入将服务名和服务提供者映射关系存储在providers

public S next() {
    if (!hasNext()) {
        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
}

以上，是我对ServiceLoader主要源码的解读，总结起来主要是包括下面几个步骤：

1.到META-INF/services/路径下查找服务提供者的配置文件

2.读取配置文件，按行解析服务提供者类名，并做一下校验

3.实例化服务提供者