JDK SPI机制ServiceLoader源码浅析

短命女 2022-10-22 04:12 229阅读 0赞

### 1.load ###

返回创建的ServiceLoader对象

清理providers

lookupIterator指向创建的LazyIterator对象

public static <S> ServiceLoader<S> load(Class<S> service) { 
        // 获取当前线程的上下文类加载器
        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) { 
        // ServiceLoader的字段 private final Class<S> service; private final ClassLoader loader;
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        // acc为null,不用关注
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        // 每次创建ServiceLoader对象都会清除缓存
        reload();
    }

public void reload() { 
        // private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
        // 清理缓存的实现类
        providers.clear();
        // 实例化LazyIterator
        lookupIterator = new LazyIterator(service, loader);
    }

private LazyIterator(Class<S> service, ClassLoader loader) { 
        this.service = service;
        this.loader = loader;
    }

### 2.iterator ###

通过iterator()获取所有的实现类

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

### 3.hasNext ###

是否有下一个实现类

// hasNext()调用hasNextServcie
    private boolean hasNextService() { 
        // 如果有下一个要加载的实现类，返回ture 
        // String nextName是LazyIterator的字段
        if (nextName != null) { 
            return true;
        }
        // LazyIterator字段 Enumeration<URL> configs = null;
        if (configs == null) { 
            try { 
                // ServiceLoader的字段 private static final String PREFIX = "META-INF/services/"
                // 接口名和services下的文件名一样
                String fullName = PREFIX + service.getName();
                if (loader == null)
                    configs = ClassLoader.getSystemResources(fullName);
                else
                    // LazyIterator的字段 Enumeration<URL> configs = null;
                    // 获取文件资源
                    configs = loader.getResources(fullName);
            } catch (IOException x) { 
                fail(service, "Error locating configuration files", x);
            }
        }
        // LazyIterator的字段 Iterator<String> pending = null;
        // 解析文件内容
        while ((pending == null) || !pending.hasNext()) { 
            if (!configs.hasMoreElements()) { 
                return false;
            }
            pending = parse(service, configs.nextElement());
        }
        // 取出一个实现类
        nextName = pending.next();
        return true;
    }

// 解析文件内容，返回实现类名List的迭代器
    private Iterator<String> parse(Class<?> service, URL u)
        throws ServiceConfigurationError
    { 
        InputStream in = null;
        BufferedReader r = null;
        ArrayList<String> names = new ArrayList<>();
        try { 
            in = u.openStream();
            r = new BufferedReader(new InputStreamReader(in, "utf-8"));
            int lc = 1;
            // 一行一行解析
            while ((lc = parseLine(service, u, r, lc, names)) >= 0);
        } catch (IOException x) { 
            fail(service, "Error reading configuration file", x);
        } finally { 
            try { 
                if (r != null) r.close();
                if (in != null) in.close();
            } catch (IOException y) { 
                fail(service, "Error closing configuration file", y);
            }
        }
        return names.iterator();
    }

// 解析一行，将实现类的名字加到List中，并且返回加一的lc
    private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
                          List<String> names)
        throws IOException, ServiceConfigurationError
    { 
        String ln = r.readLine();
        if (ln == null) { 
            return -1;
        }
        int ci = ln.indexOf('#');
        // 截取#之前的内容并且去除前后空格
        if (ci >= 0) ln = ln.substring(0, ci);
        ln = ln.trim();
        int n = ln.length();
        if (n != 0) { 
            if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
                fail(service, u, lc, "Illegal configuration-file syntax");
            int cp = ln.codePointAt(0);
            if (!Character.isJavaIdentifierStart(cp))
                fail(service, u, lc, "Illegal provider-class name: " + ln);
            for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) { 
                cp = ln.codePointAt(i);
                if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
                    fail(service, u, lc, "Illegal provider-class name: " + ln);
            }
            // 主要是这里，将实现类名加到List中
            if (!providers.containsKey(ln) && !names.contains(ln))
                names.add(ln);
        }
        return lc + 1;
    }

### 4.next ###

加载实现类

// next()调用nextService()
    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())
            throw new NoSuchElementException();
        // 获取hasNextServcie()取出的实现类
        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
    }