java框架基础之SPI机制实现及源码解析

public interface Cache {
    String getName();
    <T> T get(Object key, Class<T> type);
    void put(Object key, Object value);
    void evict(Object key);
    void clear();
}

public class ConcurrentMapCache implements Cache {
    private final String name;
    private final ConcurrentMap<Object, Object> store;
    public ConcurrentMapCache() {
        this("defaultMapCache");
    }
    public ConcurrentMapCache(String name) {
        this(name, new ConcurrentHashMap<>(256), true);
    }
    public ConcurrentMapCache(String name, ConcurrentMap<Object, Object> store, boolean allowNullValues) {
        this.name = name;
        this.store = store;
    }
    @Override
    public final String getName() {
        return this.name;
    }
    @Override
    public <T> T get(Object key, Class<T> type) {
        Object value = this.store.get(key);
        if (value != null && type != null && !type.isInstance(value)) {
            throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);
        }
        return (T) value;
    }
    @Override
    public void put(Object key, Object value) {
        this.store.putIfAbsent(key, value);
    }
    @Override
    public void evict(Object key) {
        this.store.remove(key);
    }
    @Override
    public void clear() {
        this.store.clear();
    }
}

public class CacheSpiTest {
    public static void main(String[] args) {
        ServiceLoader<Cache> serviceLoader = ServiceLoader.load(Cache.class);
        Iterator<Cache> iterator = serviceLoader.iterator();
        while (iterator.hasNext()) {
            Cache cache = iterator.next();
            System.out.println(cache.getName());
            cache.put("user", "nana");
            System.out.println(cache.get("user", String.class));
        }
    }
}

//SPI约定获取扩展接口路径的文件
private static final String PREFIX = "META-INF/services/";
//基础约定接口
private final Class<S> service;
private final ClassLoader loader;
//权限控制上下文
private final AccessControlContext acc;
//厂商接口实现类的实例化对象集合
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();//以初始化的顺序缓存<接口全名称, 实现类实例>
//懒加载迭代器
private LazyIterator lookupIterator

   public void reload() {
        providers.clear();
        lookupIterator = new LazyIterator(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();
    }

 Class<S> service;//通用接口
 ClassLoader loader;//类加载器
Enumeration<URL> configs = null;//厂商接口文件URL的集合
 Iterator<String> pending = null;//接口具体实现的路径类名列表
  public boolean hasNext() {
            if (acc == null) {//访问控制上下文是否为空
                return hasNextService();
            } else {
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                    public Boolean run() { return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }
        public S next() {
            if (acc == null) {
                return nextService();
            } else {
                PrivilegedAction<S> action = new PrivilegedAction<S>() {
                    public S run() { return nextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

 private S nextService() {
            if (!hasNextService()) //获取nextName 需要加载的类名
                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()); //初始化类并类型转换成Cache对象
                providers.put(cn, p); 放入实例化对象集合中
                return p;
            } catch (Throwable x) {
                fail(service,
                     "Provider " + cn + " could not be instantiated", x);
            }
            throw new Error();          // This cannot happen
        }