jdkSPI机制浅析

前言

面试常会问到javaSPI与dubboSPI区别，关于dubbo的SPI已经做过浅析，现在对javaSPI做梳理

问题

1. javaSPI缺点？一次性加载，如何一次性加载？加载完如何获得想要的实现类
2. javaSPI加载哪个路径
3. javaSPI主要解决什么问题

使用

使用上，通过ServiceLoader.load(Interface.class)就能够加载目录为META-INF/services下关于Interface.class定义的实现类，通过遍历迭代器的方式遍历每个实现类，再根据需要对实现类进行进一步的操作，如获取指定实现类

public static void main(String[] args) {
        ServiceLoader<Interface> interfaces = ServiceLoader.load(Interface.class);
        for (Interface i : interfaces) {
            // xxxx
        }
   }
}

源码

要注意的是，上述的使用，load作为入口，只是获得了一个迭代器对象，并没有真正执行获取操作

    public static <S> ServiceLoader<S> load(Class<S> service) {
    	// ContextClassLoader实则为AppClassLoader
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }
    
    public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

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

1. 从load入口进入
2. 通过线程获取AppClassLoader
3. 调用reload方法，创建一个懒加载的迭代器对象LazyIterator，将service与appClassloader作为参数传入
4. LazyIterator完成初始化

由上述过程我们知道，load之后并不会进行实现类的获取，只是初始化了一个LazyIterator
当遍历LazyIterator时，调用nextService完成加载

        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) {
                //
            }
            try {
            	// 实例化
                S p = service.cast(c.newInstance());
                providers.put(cn, p);
                return p;
            } catch (Throwable x) {
              //
            }
            //
        }

1. 通过Class.forName(cn, false, loader)利用AppClassLoader完成类加载
2. c.newInstance() 完成实例化
3. providers.put(cn, p) 放入缓存中
4. 至此SPI结束

总结

javaSPI的缺点？一次性加载，如何一次性加载？加载完如何获得想要的实现类

1. 由于使用迭代器的方式，要通过遍历所有实现类的方式获得需要的实现类，所谓一次性加载，而dubboSPI就不采用这种迭代的方式，而是能够通过key进行一对一的加载
2. javaSPI遍历实现类，根据类名可以获得需要的类

javaSPI加载哪个路径

META-INF/services

javaSPI主要解决什么问题

这部分与打破双亲机制有关，由源码可知，通过SPI的方式，即使是在由BootstrapClassLoader加载的类中使用SPI，也会通过ApplicationClassLoader进行加载，能够打破双亲机制，从而实现类似默认驱动扩展的功能