java/java工具类

2020-08-16

字数统计: 6.1k字 | 阅读时长≈ 27分

java jdk 工具类

ServiceLoader

/*
加载服务实现的工具。

<i>service</i>是一个众所周知的接口或类，其中存在零个、一个或多个服务提供者。
一个<i>service provider</i>（或者仅仅是<i>provider</i>）是一个实现已知接口或类的子类的类。
{@code serviceloader}是一个对象，它在应用程序选择的时间定位和加载运行时环境中部署的服务提供程序。
应用程序代码只引用服务，而不是服务提供者，并且假定能够在多个服务提供者之间进行选择（基于它们通过服务公开的功能），并处理找不到服务提供者的可能性。

--获取服务加载程序

应用程序通过调用{@code serviceloader}的一个静态{@code load}方法来获得给定服务的服务加载器。
如果应用程序是一个模块，那么它的模块声明必须有一个指定服务的<i>uses</i>指令；
这有助于定位提供程序并确保它们将可靠地执行。
此外，如果应用程序模块不包含服务，则其模块声明必须具有指定导出服务的模块的<i>requires</i>指令。

强烈建议应用程序模块不需要包含服务提供者的模块。

服务加载器可以通过{@link#iterator（）iterator}方法来定位和实例化服务的提供者。{@codeserviceloader}还定义了{@link#stream（）stream}方法，以获得一个可以在不实例化的情况下检查和筛选的提供者流。

例如，假设服务是{@codecom.example.codeFactory}，定义生成编码器和解码器的方法的接口：

* <pre>{@code
 *     package com.example;
 *     public interface CodecFactory {
 *         Encoder getEncoder(String encodingName);
 *         Decoder getDecoder(String encodingName);
 *     }
 * }</pre>
以下代码获取{@code CodecFactory}服务的服务加载程序，然后使用其迭代器（由增强的for循环自动创建）生成位于以下位置的服务提供程序的实例：

 * <pre>{@code
 *     ServiceLoader<CodecFactory> loader = ServiceLoader.load(CodecFactory.class);
 *     for (CodecFactory factory : loader) {
 *         Encoder enc = factory.getEncoder("PNG");
 *         if (enc != null)
 *             ... use enc to encode a PNG file
 *             break;
 *         }
 * }</pre>
 
如果此代码驻留在模块中，则为了引用{@code com.example.codeFactory}接口，则模块声明将需要导出接口的模块。模块声明还将指定使用{@code com.example.codeFactory}: 
 * <pre>{@code
 *     requires com.example.codec.core;
 *     uses com.example.CodecFactory;
 * }</pre>

有时，应用程序可能希望在实例化服务提供者之前检查它，以便确定该服务提供者的实例是否有用。例如，能够生成“PNG”编码器的{@code codefactory}的服务提供者可以用{@code @PNG}进行注释。以下代码使用服务加载器的{@code stream}方法生成{@code Provider<CodecFactory>}的实例，而迭代器生成{@code CodecFactory}实例的方式不同：
* <pre>{@code
 *     ServiceLoader<CodecFactory> loader = ServiceLoader.load(CodecFactory.class);
 *     Set<CodecFactory> pngFactories = loader
 *            .stream()                                              // Note a below
 *            .filter(p -> p.type().isAnnotationPresent(PNG.class))  // Note b
 *            .map(Provider::get)                                    // Note c
 *            .collect(Collectors.toSet());
 * }</pre>
 * <ol type="a">
 *   <li> A stream of {@code Provider<CodecFactory>} objects </li>
 *   <li> {@code p.type()} yields a {@code Class<CodecFactory>} </li>
 *   <li> {@code get()} yields an instance of {@code CodecFactory} </li>
 * </ol>
 
 
 
 ---设计服务
 服务是单一类型，通常是接口或抽象类。可以使用具体类，但不建议这样做。类型可以具有任何可访问性。服务的方法是高度特定于域的，因此这个API规范不能给出关于它们的形式或函数的具体建议。但是，有两个一般准则：
 	1，服务应根据需要声明尽可能多的方法，以允许服务提供商传递其特定于域的属性和其他实现质量因素。获得服务的服务加载器的应用程序可以在服务提供者的每个实例上调用这些方法，以便为应用程序选择最佳的提供者。
   2服务应该表达它的服务提供者是服务的直接实现还是间接机制，如“代理”或“工厂”。当领域特定的对象实例化成本相对较高时，服务提供者往往是间接机制；在这种情况下，服务提供者的设计应使其成为抽象的，根据需要创建“真正的”实现。例如，{@code codefactory}服务通过其名称表示其服务提供者是编解码器的工厂，而不是编解码器本身，因为生产某些编解码器可能很昂贵或复杂。


--开发服务提供商

服务提供者是一个单一类型，通常是一个具体的类。允许使用接口或抽象类，因为它可以声明一个静态提供程序方法，稍后讨论。类型必须是公共的，并且不能是内部类。
服务提供者及其支持代码可以在模块中开发，然后部署在应用模块路径上或模块化映像中。或者，服务提供者及其支持代码可以打包为JAR文件并部署在应用程序类路径上。在模块中开发服务提供程序的好处是，可以对该提供程序进行完全封装，以隐藏其实现的所有细节。
获取给定服务的服务加载器的应用程序与服务提供者是部署在模块中还是打包为JAR文件无关。应用程序通过服务加载器的迭代器实例化服务提供者，或者通过服务加载器流中的{@link Provider}对象实例化服务提供者，而不知道服务提供者的位置。

--将服务提供者部署为模块
在模块中开发的服务提供程序必须在模块声明中的<i>provides</i>指令中指定。provides指令同时指定服务和服务提供者；这有助于在另一个模块（带有<i>对服务使用</i>指令）获取服务的服务加载器时定位提供程序。强烈建议模块不要导出包含服务提供程序的包。不支持在<i>provides</i>指令中指定另一个模块中的服务提供者的模块。

在模块中开发的服务提供程序无法控制何时实例化，因为这是在应用程序的要求下发生的，但它确实可以控制如何实例化：

  1如果服务提供程序声明了一个提供程序方法，那么服务加载程序将调用该方法以获取服务提供程序的实例。provider方法是一个名为“provider”的公共静态方法，没有形式参数，返回类型可分配给服务的接口或类。在这种情况下，服务提供者本身不需要被指派给服务的接口或类。
 2如果服务提供程序未声明提供程序方法，则通过其提供程序构造函数直接实例化服务提供程序。提供程序构造函数是没有形式参数的公共构造函数。在这种情况下，服务提供者必须可分配给服务的接口或类
 
 
在应用程序模块路径上部署为{@linkplain java.lang.module.ModuleDescriptor#isAutomatic automatic module}的服务提供程序必须具有提供程序构造函数。在这种情况下，不支持提供程序方法。 


例如，假设模块指定以下指令：
  * <pre>{@code
 *     provides com.example.CodecFactory with com.example.impl.StandardCodecs;
 *     provides com.example.CodecFactory with com.example.impl.ExtendedCodecsFactory;
 * }</pre>
 
 当
 * <ul>
 *   <li> {@code com.example.codeFactory}是早期的双方法服务。 </li>
 *
 *   <li> {@code com.example.impl.StandardCodecs}是一个实现{@code CodecFactory}的公共类，它有一个公共的无参数构造函数。 </li>
 *
 *   <li> {@code com.example.impl.ExtendedCodecsFactory}是一个不实现CodecFactory的公共类，但它声明了一个名为“provider”的公共静态无参数方法，返回类型为{@code CodecFactory}。</li>
 * </ul> 
服务加载程序将通过其构造函数实例化{@code StandardCodecs}，并通过调用其{@code provider}方法实例化{@code ExtendedCodecsFactory}。提供程序构造函数或提供程序方法是公共的这一要求有助于记录类（即服务提供程序）将由类包外部的实体（即服务加载程序）实例化的意图。

--在类路径上部署服务提供程序
打包为类路径的JAR文件的服务提供者通过在资源目录{@code META-INF/services}中放置一个<i>提供者配置文件</i>来标识。提供程序配置文件的名称是服务的完全限定的二进制名称。提供程序配置文件包含服务提供程序的完全限定二进制名称的列表，每行一个。
例如，假设服务提供者{@codecom.example.impl.StandardCodecs}打包在类路径的JAR文件中。JAR文件将包含一个名为：
 * <blockquote>{@code
 *     META-INF/services/com.example.CodecFactory
 * }</blockquote>
 
包含以下行：
 * <blockquote>{@code
 *     com.example.impl.StandardCodecs # Standard codecs
 * }</blockquote>
提供程序配置文件必须用UTF-8编码。

将忽略每个服务提供商名称周围的空格和制表符以及空行。注释字符是{@code'#'}（{@code'&#92；u0023'}NUMBER SIGN）；
 在每一行中，第一个注释字符后面的所有字符都将被忽略。如果服务提供程序类名在提供程序配置文件中多次列出，则忽略重复项。如果服务提供程序类在多个配置文件中命名，则忽略重复项。
 
 提供程序配置文件中提到的服务提供程序可能位于与提供程序配置文件相同的JAR文件中，也可能位于不同的JAR文件中。服务提供者必须从最初查询以定位提供者配置文件的类加载器中可见；这不一定是最终定位提供者配置文件的类加载器。
 
--- 提供程序发现的时间
服务提供者是延迟加载和实例化的，即按需加载和实例化。服务加载器维护迄今已加载的提供程序的缓存。对{@code iterator}方法的每次调用都返回一个{@code iterator}，该方法首先按实例化顺序生成前一次迭代缓存的所有元素，然后惰性地定位和实例化任何剩余的提供程序，依次将每个提供程序添加到缓存中。类似地，对stream方法的每次调用都返回一个{@code stream}，它首先按加载顺序处理由以前的流操作加载的所有提供程序，然后懒洋洋地定位任何剩余的提供程序。通过{@link#reload reload}方法清除缓存。

--错误

 当使用服务加载器的{@code iterator}时，{@link iterator#hasNext（）hasNext}和{@link iterator#next（）next}方法将在查找、加载或实例化服务提供程序时失败，并显示{@link ServiceConfigurationError}。当处理服务加载器的流时，{@codeserviceconfigurationerror}可能被任何导致找到或加载服务提供者的方法抛出。
 
  在模块中加载或实例化服务提供程序时，{@code ServiceConfigurationError}可能由于以下原因引发：
   * <ul>
 *
 *   <li> 无法加载服务提供程序。</li>
 *
 *   <li> 服务提供程序未声明提供程序方法，或者该方法不可分配给服务的接口/类，或者没有提供程序构造函数。</li>
 *
 *   <li> 服务提供程序声明一个名为“provider”的公共静态无参数方法，返回类型不可分配给服务的接口或类。</li>
 *
 *   <li>服务提供程序类文件有多个名为“{@codeprovider}”的公共静态无参数方法。 </li>
 *
 *   <li>服务提供程序声明了一个提供程序方法，它通过返回{@code null}或引发异常而失败。 </li>
 *
 *   <li>服务提供程序未声明提供程序方法，其提供程序构造函数因引发异常而失败。</li>
 *
 * </ul>

 在读取提供程序配置文件或加载或实例化提供程序配置文件中命名的提供程序类时，由于以下原因，可能会引发{@code ServiceConfigurationError}：
 
 * <ul>
 *
 *   <li> 提供程序配置文件的格式违反了上述指定的格式； </li>
 *
 *   <li>读取提供者配置文件时发生{@link IOException IOException}； </li>
 *
 *   <li> 无法加载服务提供程序； </li>
 *
 *   <li> 服务提供者不可指派给服务的介面或类别，或未定义提供者建构函式，或无法实例化。 </li>
 *
 * </ul>
 
 
 ---安全
服务加载器总是在迭代器或流方法调用方的安全上下文中执行，也可能受到创建服务加载器的调用方的安全上下文的限制。受信任的系统代码通常应该从特权安全上下文中调用此类中的方法以及它们返回的迭代器的方法。


--并发

此类的实例对于多个并发线程的使用是不安全的。

--空处理

除非另外指定，否则将{@code null}参数传递给此类中的任何方法都将导致抛出{@link nullpointereexception}。


*/



public final class ServiceLoader<S>    implements Iterable<S>{
     // 表示正在加载的服务的类或接口
    private final Class<S> service;

    // 服务类型的类
    private final String serviceName;

    // The module layer used to locate providers; null when locating用于定位提供程序的模块层；查找时为空
    // providers using a class loader使用类加载器的提供程序
    private final ModuleLayer layer;

    // 用于定位、加载和实例化提供者的类加载器；
    // 使用模块层定位提供程序时为空
    private final ClassLoader loader;

    // 创建ServiceLoader时获取的访问控制上下文
    private final AccessControlContext acc;

    // 迭代器操作的延迟查找迭代器
    private Iterator<Provider<S>> lookupIterator1;
    private final List<S> instantiatedProviders = new ArrayList<>();

    // 流操作的延迟查找迭代器
    private Iterator<Provider<S>> lookupIterator2;
    private final List<Provider<S>> loadedProviders = new ArrayList<>();
    private boolean loadedAllProviders; //加载所有提供程序时为真

    //调用重新加载时递增
    private int reloadCount;

    private static JavaLangAccess LANG_ACCESS;
    static {
        LANG_ACCESS = SharedSecrets.getJavaLangAccess();
    }

    
     public Iterator<S> iterator() {

        // create lookup iterator if needed
        if (lookupIterator1 == null) {
            
            //初始化一个查找迭代器
            lookupIterator1 = newLookupIterator();
        }

        return new Iterator<S>() {

            // record reload count
            final int expectedReloadCount = ServiceLoader.this.reloadCount;

            // index into the cached providers list
            int index;

            /**
             * Throws ConcurrentModificationException if the list of cached
             * providers has been cleared by reload.
             */
            private void checkReloadCount() {
                if (ServiceLoader.this.reloadCount != expectedReloadCount)
                    throw new ConcurrentModificationException();
            }

            @Override
            public boolean hasNext() {
                checkReloadCount();
                if (index < instantiatedProviders.size())
                    return true;
                return lookupIterator1.hasNext();
            }

            @Override
            public S next() {
                checkReloadCount();
                S next;
                if (index < instantiatedProviders.size()) {
                    next = instantiatedProviders.get(index);
                } else {
                    next = lookupIterator1.next().get();
                    instantiatedProviders.add(next);
                }
                index++;
                return next;
            }

        };
    }
    
    
     private Iterator<Provider<S>> newLookupIterator() {
         
         
        assert layer == null || loader == null;
        if (layer != null) {
            
            return new LayerLookupIterator<>();
        } else {
            
            //不采用延时加载
            //使用两个 迭代器一个是 ModuleService，另一个是LazyClassPath
            Iterator<Provider<S>> first = new ModuleServicesLookupIterator<>();
            Iterator<Provider<S>> second = new LazyClassPathLookupIterator<>();
            return new Iterator<Provider<S>>() {
                @Override
                public boolean hasNext() {
                    return (first.hasNext() || second.hasNext());
                }
                @Override
                public Provider<S> next() {
                    if (first.hasNext()) {
                        return first.next();
                    } else if (second.hasNext()) {
                        return second.next();
                    } else {
                        throw new NoSuchElementException();
                    }
                }
            };
        }
    }
    
}

LazyClassPathLookupIterator

实现延迟服务提供程序查找，其中通过服务配置文件配置服务提供程序。命名模块中的服务提供者被此查找迭代器忽略。
    
    
    这个是通过   "META-INF/services/"查找 服务名的配置文件来获取
 private final class LazyClassPathLookupIterator<T>
        implements Iterator<Provider<T>>
    {
        static final String PREFIX = "META-INF/services/";

        Set<String> providerNames = new HashSet<>();  // to avoid duplicates
        Enumeration<URL> configs;
        Iterator<String> pending;

        Provider<T> nextProvider;
        ServiceConfigurationError nextError;

        LazyClassPathLookupIterator() { }

        /**
         *解析给定配置文件中的一行，将行上的名称添加到名称集（如果尚未看到）。
         */
        private int parseLine(URL u, BufferedReader r, int lc, Set<String> names)
            throws IOException
        {
            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);
                int start = Character.charCount(cp);
                for (int i = start; i < n; i += Character.charCount(cp)) {
                    cp = ln.codePointAt(i);
                    if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
                        fail(service, u, lc, "Illegal provider-class name: " + ln);
                }
                if (providerNames.add(ln)) {
                    names.add(ln);
                }
            }
            return lc + 1;
        }

        /**
         * 将给定URL的内容解析为提供程序配置文件。
         */
        private Iterator<String> parse(URL u) {
            Set<String> names = new LinkedHashSet<>(); // preserve insertion order
            try {
                URLConnection uc = u.openConnection();
                uc.setUseCaches(false);
                try (InputStream in = uc.getInputStream();
                     BufferedReader r
                         = new BufferedReader(new InputStreamReader(in, "utf-8")))
                {
                    int lc = 1;
                    while ((lc = parseLine(u, r, lc, names)) >= 0);
                }
            } catch (IOException x) {
                fail(service, "Error accessing configuration file", x);
            }
            return names.iterator();
        }

        /**
         * 加载并返回下一个提供程序类。
         */
        private Class<?> nextProviderClass() {
            if (configs == null) {
                try {
                    String fullName = PREFIX + service.getName();
                    if (loader == null) {
                        configs = ClassLoader.getSystemResources(fullName);
                    } else if (loader == ClassLoaders.platformClassLoader()) {
                        // The platform classloader doesn't have a class path,
                        // but the boot loader might.
                        if (BootLoader.hasClassPath()) {
                            configs = BootLoader.findResources(fullName);
                        } else {
                            configs = Collections.emptyEnumeration();
                        }
                    } else {
                        configs = loader.getResources(fullName);
                    }
                } catch (IOException x) {
                    fail(service, "Error locating configuration files", x);
                }
            }
            while ((pending == null) || !pending.hasNext()) {
                if (!configs.hasMoreElements()) {
                    return null;
                }
                pending = parse(configs.nextElement());
            }
            String cn = pending.next();
            try {
                return Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) {
                fail(service, "Provider " + cn + " not found");
                return null;
            }
        }

        @SuppressWarnings("unchecked")
        private boolean hasNextService() {
            while (nextProvider == null && nextError == null) {
                try {
                    Class<?> clazz = nextProviderClass();
                    if (clazz == null)
                        return false;

                    if (clazz.getModule().isNamed()) {
                        // ignore class if in named module
                        continue;
                    }

                    if (service.isAssignableFrom(clazz)) {
                        Class<? extends S> type = (Class<? extends S>) clazz;
                        Constructor<? extends S> ctor
                            = (Constructor<? extends S>)getConstructor(clazz);
                        ProviderImpl<S> p = new ProviderImpl<S>(service, type, ctor, acc);
                        nextProvider = (ProviderImpl<T>) p;
                    } else {
                        fail(service, clazz.getName() + " not a subtype");
                    }
                } catch (ServiceConfigurationError e) {
                    nextError = e;
                }
            }
            return true;
        }

        private Provider<T> nextService() {
            if (!hasNextService())
                throw new NoSuchElementException();

            Provider<T> provider = nextProvider;
            if (provider != null) {
                nextProvider = null;
                return provider;
            } else {
                ServiceConfigurationError e = nextError;
                assert e != null;
                nextError = null;
                throw e;
            }
        }

        @Override
        public boolean hasNext() {
            if (acc == null) {
                return hasNextService();
            } else {
                PrivilegedAction<Boolean> action = new PrivilegedAction<>() {
                    public Boolean run() { return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

        @Override
        public Provider<T> next() {
            if (acc == null) {
                return nextService();
            } else {
                PrivilegedAction<Provider<T>> action = new PrivilegedAction<>() {
                    public Provider<T> run() { return nextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }
    }

ModuleServicesLookupIterator


实现延迟服务提供程序查找，这些服务提供程序是由定义给类加载器的模块提供的，或者是由定义给类加载器的模块的层中的模块提供的。

 private final class ModuleServicesLookupIterator<T>
        implements Iterator<Provider<T>>
    {
        ClassLoader currentLoader;
        Iterator<ServiceProvider> iterator;

        Provider<T> nextProvider;
        ServiceConfigurationError nextError;

        ModuleServicesLookupIterator() {
            this.currentLoader = loader;
            this.iterator = iteratorFor(loader);
        }

        /**
         * Returns iterator to iterate over the implementations of {@code
         * service} in the given layer.
         */
        private List<ServiceProvider> providers(ModuleLayer layer) {
            ServicesCatalog catalog = LANG_ACCESS.getServicesCatalog(layer);
            return catalog.findServices(serviceName);
        }

        /**
         * Returns the class loader that a module is defined to
         */
        private ClassLoader loaderFor(Module module) {
            SecurityManager sm = System.getSecurityManager();
            if (sm == null) {
                return module.getClassLoader();
            } else {
                PrivilegedAction<ClassLoader> pa = module::getClassLoader;
                return AccessController.doPrivileged(pa);
            }
        }

        /**
         * Returns an iterator to iterate over the implementations of {@code
         * service} in modules defined to the given class loader or in custom
         * layers with a module defined to this class loader.
         */
        private Iterator<ServiceProvider> iteratorFor(ClassLoader loader) {
            // modules defined to the class loader
            ServicesCatalog catalog;
            if (loader == null) {
                catalog = BootLoader.getServicesCatalog();
            } else {
                catalog = ServicesCatalog.getServicesCatalogOrNull(loader);
            }
            List<ServiceProvider> providers;
            if (catalog == null) {
                providers = List.of();
            } else {
                providers = catalog.findServices(serviceName);
            }

            // modules in layers that define modules to the class loader
            ClassLoader platformClassLoader = ClassLoaders.platformClassLoader();
            if (loader == null || loader == platformClassLoader) {
                return providers.iterator();
            } else {
                List<ServiceProvider> allProviders = new ArrayList<>(providers);
                Iterator<ModuleLayer> iterator = LANG_ACCESS.layers(loader).iterator();
                while (iterator.hasNext()) {
                    ModuleLayer layer = iterator.next();
                    for (ServiceProvider sp : providers(layer)) {
                        ClassLoader l = loaderFor(sp.module());
                        if (l != null && l != platformClassLoader) {
                            allProviders.add(sp);
                        }
                    }
                }
                return allProviders.iterator();
            }
        }

        @Override
        public boolean hasNext() {
            while (nextProvider == null && nextError == null) {
                // get next provider to load
                while (!iterator.hasNext()) {
                    if (currentLoader == null) {
                        return false;
                    } else {
                        currentLoader = currentLoader.getParent();
                        iterator = iteratorFor(currentLoader);
                    }
                }

                // attempt to load provider
                ServiceProvider provider = iterator.next();
                try {
                    @SuppressWarnings("unchecked")
                    Provider<T> next = (Provider<T>) loadProvider(provider);
                    nextProvider = next;
                } catch (ServiceConfigurationError e) {
                    nextError = e;
                }
            }
            return true;
        }

        @Override
        public Provider<T> next() {
            if (!hasNext())
                throw new NoSuchElementException();

            Provider<T> provider = nextProvider;
            if (provider != null) {
                nextProvider = null;
                return provider;
            } else {
                ServiceConfigurationError e = nextError;
                assert e != null;
                nextError = null;
                throw e;
            }
        }
    }

ProviderImpl


//表示由{@code ServiceLoader}定位的服务提供程序。
    //当使用加载器的{@link ServiceLoader}stream（）stream（）}方法时，元素的类型是{@code Provider}。这允许处理在不实例化提供程序的情况下选择或筛选提供程序类。
      public static interface Provider<S> extends Supplier<S> {
        /**
         *返回提供程序类型。不能保证此类型是可访问的，或者它有一个公共的无参数构造函数。{@link#get（）get（）}方法应用于获取提供程序实例。
         *
         * <p> 当模块声明提供程序类是由提供程序工厂创建的时，此方法返回其公共静态“{@code provider（）}”方法的返回类型。
         *
         * @return The provider type
         */
        Class<? extends S> type();

        /**
         * 返回提供程序的实例。
         *
         * @return An instance of the provider.
         *
         * @throws ServiceConfigurationError
         如果无法实例化服务提供程序，或者对于提供程序工厂，则公共静态“{@code provider（）}”方法返回{@code null}或引发错误或异常。{@code serviceconfigurationerror}将在可能的情况下提供适当的原因。
         */
        @Override S get();
    }


 private static class ProviderImpl<S> implements Provider<S> {
        final Class<S> service;
        final Class<? extends S> type;
        final Method factoryMethod;  // factory method or null
        final Constructor<? extends S> ctor; // public no-args constructor or null
        final AccessControlContext acc;

        ProviderImpl(Class<S> service,
                     Class<? extends S> type,
                     Method factoryMethod,
                     AccessControlContext acc) {
            this.service = service;
            this.type = type;
            this.factoryMethod = factoryMethod;
            this.ctor = null;
            this.acc = acc;
        }

        ProviderImpl(Class<S> service,
                     Class<? extends S> type,
                     Constructor<? extends S> ctor,
                     AccessControlContext acc) {
            this.service = service;
            this.type = type;
            this.factoryMethod = null;
            this.ctor = ctor;
            this.acc = acc;
        }

        @Override
        public Class<? extends S> type() {
            return type;
        }

        @Override
        public S get() {
            if (factoryMethod != null) {
                return invokeFactoryMethod();
            } else {
                return newInstance();
            }
        }

        /**调用提供者的“provider”方法来实例化提供者。
         * 当使用安全管理器运行时，方法的运行权限受创建此加载程序的任何内容的安全上下文的限制。
         */
        private S invokeFactoryMethod() {
            Object result = null;
            Throwable exc = null;
            if (acc == null) {
                try {
                    result = factoryMethod.invoke(null);
                } catch (Throwable x) {
                    exc = x;
                }
            } else {
                PrivilegedExceptionAction<?> pa = new PrivilegedExceptionAction<>() {
                    @Override
                    public Object run() throws Exception {
                        return factoryMethod.invoke(null);
                    }
                };
                // invoke factory method with permissions restricted by acc
                try {
                    result = AccessController.doPrivileged(pa, acc);
                } catch (Throwable x) {
                    if (x instanceof PrivilegedActionException)
                        x = x.getCause();
                    exc = x;
                }
            }
            if (exc != null) {
                if (exc instanceof InvocationTargetException)
                    exc = exc.getCause();
                fail(service, factoryMethod + " failed", exc);
            }
            if (result == null) {
                fail(service, factoryMethod + " returned null");
            }
            @SuppressWarnings("unchecked")
            S p = (S) result;
            return p;
        }

        /**
         调用Constructor：：newInstance实例化提供程序。当使用安全管理器运行时，构造函数的运行权限受创建此加载程序的任何内容的安全上下文的限制。
         */
        private S newInstance() {
            S p = null;
            Throwable exc = null;
            if (acc == null) {
                try {
                    p = ctor.newInstance();
                } catch (Throwable x) {
                    exc = x;
                }
            } else {
                PrivilegedExceptionAction<S> pa = new PrivilegedExceptionAction<>() {
                    @Override
                    public S run() throws Exception {
                        return ctor.newInstance();
                    }
                };
                // invoke constructor with permissions restricted by acc
                try {
                    p = AccessController.doPrivileged(pa, acc);
                } catch (Throwable x) {
                    if (x instanceof PrivilegedActionException)
                        x = x.getCause();
                    exc = x;
                }
            }
            if (exc != null) {
                if (exc instanceof InvocationTargetException)
                    exc = exc.getCause();
                String cn = ctor.getDeclaringClass().getName();
                fail(service,
                     "Provider " + cn + " could not be instantiated", exc);
            }
            return p;
        }

        @Override
        public int hashCode() {
            return Objects.hash(service, type, acc);
        }

        @Override
        public boolean equals(Object ob) {
            if (!(ob instanceof ProviderImpl))
                return false;
            @SuppressWarnings("unchecked")
            ProviderImpl<?> that = (ProviderImpl<?>)ob;
            return this.service == that.service
                    && this.type == that.type
                    && Objects.equals(this.acc, that.acc);
        }
    }

本文作者： 忘忧症
本文链接： https://NepenthesZGW.github.io/2020/08/16/java/java工具类/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！