是一个类
public class Observable<T> {

    //一个被观察者

}

public abstract class Subscriber<T> implements Observer<T>, Subscription {
    
    
}

/*
提供接收基于推送的通知的机制。
*/
public interface Observer<T> {
    
     /**
     * 通知观察者{@link Observable}已完成发送基于推送的通知。
     * 如果{@link Observable}调用{@link#onError}，它将不会调用此方法。
     */
    void onCompleted();

    /**
     * 通知观察者{@link Observable}遇到错误情况。
     * <p>
     * 如果{@link Observable}调用此方法，则此后它将不会调用{@link#onNext}或{@link{onCompleted}。
     *
     * @param e 被观察对象遇到的异常
     */
    void onError(Throwable e);

    /**
     * 为观察者提供了一个要观察的新项目。
     * <p>
     *{@linkobservable}可以调用此方法0次或多次。
     * <p>
     *{@code observable}在调用{@link onCompleted}或{@link onError}后将不再调用此方法。
     *
     * @param t 被观察者发射的物品
     */
    void onNext(T t);
}

Subscription从Observable#subscribe（Subscriber）返回以允许取消订阅。
public interface Subscription {

    /**
     * 停止在接收此订阅时注册的{@link Subscriber}上接收通知。
     * 这允许在{@link Subscriber}完成接收所有事件之前（即调用onCompleted之前）注销它。
     */
    void unsubscribe();

    /**
     *指示此{@code Subscription}当前是否已取消订阅。
     * @return {@code true}如果此{@code Subscription}当前未订阅，否则为{@code false}
     */
    boolean isUnsubscribed();

}

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

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

实现延迟服务提供程序查找，其中通过服务配置文件配置服务提供程序。命名模块中的服务提供者被此查找迭代器忽略。
    
    
    这个是通过   "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);
            }
        }
    }

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

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

//表示由{@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);
        }
    }

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.netflix.hystrix.HystrixAutoConfiguration,\
org.springframework.cloud.netflix.hystrix.HystrixCircuitBreakerAutoConfiguration,\
org.springframework.cloud.netflix.hystrix.ReactiveHystrixCircuitBreakerAutoConfiguration,\
org.springframework.cloud.netflix.hystrix.security.HystrixSecurityAutoConfiguration

org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker=\
org.springframework.cloud.netflix.hystrix.HystrixCircuitBreakerConfiguration

public class CommandHelloWorld extends HystrixCommand<String> {

    private final String name;

    public CommandHelloWorld(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));
        this.name = name;
    }

    @Override
    protected String run() {
        return "Hello " + name + "!";
    }
}
This command could be used like this:

String s = new CommandHelloWorld("Bob").execute();
Future<String> s = new CommandHelloWorld("Bob").queue();
Observable<String> s = new CommandHelloWorld("Bob").observe();



可以看到，所有的执行都不是直接调用run方法，而是调用execute，queue，observe，所以不会直接执行，代码也不会阻塞，他会交给别的线程去执行

public Observable<R> toObservable() {
      final AbstractCommand<R> _cmd = this;

      //doOnCompleted handler already did all of the SUCCESS work
      //doOnError handler already did all of the FAILURE/TIMEOUT/REJECTION/BAD_REQUEST work
    
    //设置一个终止命令
      final Action0 terminateCommandCleanup = new Action0() {

          @Override
          public void call() {
              if (_cmd.commandState.compareAndSet(CommandState.OBSERVABLE_CHAIN_CREATED, CommandState.TERMINAL)) {
                  handleCommandEnd(false); //user code never ran
              } else if (_cmd.commandState.compareAndSet(CommandState.USER_CODE_EXECUTED, CommandState.TERMINAL)) {
                  handleCommandEnd(true); //user code did run
              }
          }
      };

      //mark the command as CANCELLED and store the latency (in addition to standard cleanup)
    //设置一个取消订阅的命令
      final Action0 unsubscribeCommandCleanup = new Action0() {
          @Override
          public void call() {
              if (_cmd.commandState.compareAndSet(CommandState.OBSERVABLE_CHAIN_CREATED, CommandState.UNSUBSCRIBED)) {
                  if (!_cmd.executionResult.containsTerminalEvent()) {
                      _cmd.eventNotifier.markEvent(HystrixEventType.CANCELLED, _cmd.commandKey);
                      try {
                          executionHook.onUnsubscribe(_cmd);
                      } catch (Throwable hookEx) {
                          logger.warn("Error calling HystrixCommandExecutionHook.onUnsubscribe", hookEx);
                      }
                      _cmd.executionResultAtTimeOfCancellation = _cmd.executionResult
                              .addEvent((int) (System.currentTimeMillis() - _cmd.commandStartTimestamp), HystrixEventType.CANCELLED);
                  }
                  handleCommandEnd(false); //user code never ran
              } else if (_cmd.commandState.compareAndSet(CommandState.USER_CODE_EXECUTED, CommandState.UNSUBSCRIBED)) {
                  if (!_cmd.executionResult.containsTerminalEvent()) {
                      _cmd.eventNotifier.markEvent(HystrixEventType.CANCELLED, _cmd.commandKey);
                      try {
                          executionHook.onUnsubscribe(_cmd);
                      } catch (Throwable hookEx) {
                          logger.warn("Error calling HystrixCommandExecutionHook.onUnsubscribe", hookEx);
                      }
                      _cmd.executionResultAtTimeOfCancellation = _cmd.executionResult
                              .addEvent((int) (System.currentTimeMillis() - _cmd.commandStartTimestamp), HystrixEventType.CANCELLED);
                  }
                  handleCommandEnd(true); //user code did run
              }
          }
      };

    
    //应用Hystrix语义
      final Func0<Observable<R>> applyHystrixSemantics = new Func0<Observable<R>>() {
          @Override
          public Observable<R> call() {
              if (commandState.get().equals(CommandState.UNSUBSCRIBED)) {
                  return Observable.never();
              }
              return applyHystrixSemantics(_cmd);
          }
      };

    //包装所有的 钩子
      final Func1<R, R> wrapWithAllOnNextHooks = new Func1<R, R>() {
          @Override
          public R call(R r) {
              R afterFirstApplication = r;

              try {
                  afterFirstApplication = executionHook.onComplete(_cmd, r);
              } catch (Throwable hookEx) {
                  logger.warn("Error calling HystrixCommandExecutionHook.onComplete", hookEx);
              }

              try {
                  return executionHook.onEmit(_cmd, afterFirstApplication);
              } catch (Throwable hookEx) {
                  logger.warn("Error calling HystrixCommandExecutionHook.onEmit", hookEx);
                  return afterFirstApplication;
              }
          }
      };

    //完成时发射的钩子
      final Action0 fireOnCompletedHook = new Action0() {
          @Override
          public void call() {
              try {
                  executionHook.onSuccess(_cmd);
              } catch (Throwable hookEx) {
                  logger.warn("Error calling HystrixCommandExecutionHook.onSuccess", hookEx);
              }
          }
      };

    //返回一个可观察调用可观察到的工厂来创建可观察到的每一个新的观察员，订阅。 也就是说，用于每个用户，实际可观察​​的是订户观察由工厂函数来确定。
      return Observable.defer(new Func0<Observable<R>>() {
          
          //推迟调用，就是通过返回的Observable来交给 订阅者处理
          @Override
          public Observable<R> call() {
               /* 这是一个有状态的对象，因此只能使用一次 */
              if (!commandState.compareAndSet(CommandState.NOT_STARTED, CommandState.OBSERVABLE_CHAIN_CREATED)) {
                  IllegalStateException ex = new IllegalStateException("This instance can only be executed once. Please instantiate a new instance.");
                  //TODO make a new error type for this
                  throw new HystrixRuntimeException(FailureType.BAD_REQUEST_EXCEPTION, _cmd.getClass(), getLogMessagePrefix() + " command executed multiple times - this is not permitted.", ex, null);
              }

              
              commandStartTimestamp = System.currentTimeMillis();

              if (properties.requestLogEnabled().get()) {
                  // log this command execution regardless of what happened
                  if (currentRequestLog != null) {
                      currentRequestLog.addExecutedCommand(_cmd);
                  }
              }

              final boolean requestCacheEnabled = isRequestCachingEnabled();
              final String cacheKey = getCacheKey();

              /* try from cache first */
              if (requestCacheEnabled) {
                  HystrixCommandResponseFromCache<R> fromCache = (HystrixCommandResponseFromCache<R>) requestCache.get(cacheKey);
                  if (fromCache != null) {
                      isResponseFromCache = true;
                      return handleRequestCacheHitAndEmitValues(fromCache, _cmd);
                  }
              }
              ---上面缓存获取
              

                 // --推迟应用 applyHystrixSemantics
              Observable<R> hystrixObservable =
                      Observable.defer(applyHystrixSemantics)
                              .map(wrapWithAllOnNextHooks);

              Observable<R> afterCache;

              // put in cache
              if (requestCacheEnabled && cacheKey != null) {
                  // wrap it for caching
                  HystrixCachedObservable<R> toCache = HystrixCachedObservable.from(hystrixObservable, _cmd);
                  HystrixCommandResponseFromCache<R> fromCache = (HystrixCommandResponseFromCache<R>) requestCache.putIfAbsent(cacheKey, toCache);
                  if (fromCache != null) {
                      // another thread beat us so we'll use the cached value instead
                      toCache.unsubscribe();
                      isResponseFromCache = true;
                      return handleRequestCacheHitAndEmitValues(fromCache, _cmd);
                  } else {
                      // we just created an ObservableCommand so we cast and return it
                      afterCache = toCache.toObservable();
                  }
              } else {
                  afterCache = hystrixObservable;
              }

              
              //最后使用缓存进行最 终止，取消订阅和 完成设置 回调钩子
              return afterCache
                      .doOnTerminate(terminateCommandCleanup)     // perform cleanup once (either on normal terminal state (this line), or unsubscribe (next line))
                      .doOnUnsubscribe(unsubscribeCommandCleanup) // perform cleanup once
                      .doOnCompleted(fireOnCompletedHook);
          }
      });
  }

private Observable<R> applyHystrixSemantics(final AbstractCommand<R> _cmd) {
        // mark that we're starting execution on the ExecutionHook
        // if this hook throws an exception, then a fast-fail occurs with no fallback.  No state is left inconsistent
    
    //执行钩子回调onStart方法
        executionHook.onStart(_cmd);

        /* determine if we're allowed to execute */
    
    //查看断路器是否允许执行
        if (circuitBreaker.allowRequest()) {
            
            
            final TryableSemaphore executionSemaphore = getExecutionSemaphore();
            final AtomicBoolean semaphoreHasBeenReleased = new AtomicBoolean(false);
            final Action0 singleSemaphoreRelease = new Action0() {
                @Override
                public void call() {
                    if (semaphoreHasBeenReleased.compareAndSet(false, true)) {
                        executionSemaphore.release();
                    }
                }
            };

            final Action1<Throwable> markExceptionThrown = new Action1<Throwable>() {
                @Override
                public void call(Throwable t) {
                    eventNotifier.markEvent(HystrixEventType.EXCEPTION_THROWN, commandKey);
                }
            };

            if (executionSemaphore.tryAcquire()) {
                try {
                    /* used to track userThreadExecutionTime */
                    executionResult = executionResult.setInvocationStartTime(System.currentTimeMillis());
                    return executeCommandAndObserve(_cmd)
                            .doOnError(markExceptionThrown)
                            .doOnTerminate(singleSemaphoreRelease)
                            .doOnUnsubscribe(singleSemaphoreRelease);
                } catch (RuntimeException e) {
                    return Observable.error(e);
                }
            } else {
                return handleSemaphoreRejectionViaFallback();
            }
        } else {
            return handleShortCircuitViaFallback();
        }
    }

private Observable<R> executeCommandAndObserve(final AbstractCommand<R> _cmd) {
       final HystrixRequestContext currentRequestContext = HystrixRequestContext.getContextForCurrentThread();

    
    //设置  发射的标记
       final Action1<R> markEmits = new Action1<R>() {
           @Override
           public void call(R r) {
               if (shouldOutputOnNextEvents()) {
                   executionResult = executionResult.addEvent(HystrixEventType.EMIT);
                   eventNotifier.markEvent(HystrixEventType.EMIT, commandKey);
               }
               if (commandIsScalar()) {
                   long latency = System.currentTimeMillis() - executionResult.getStartTimestamp();
                   eventNotifier.markCommandExecution(getCommandKey(), properties.executionIsolationStrategy().get(), (int) latency, executionResult.getOrderedList());
                   eventNotifier.markEvent(HystrixEventType.SUCCESS, commandKey);
                   executionResult = executionResult.addEvent((int) latency, HystrixEventType.SUCCESS);
                   circuitBreaker.markSuccess();
               }
           }
       };

    //设置 完成时的标记处理
       final Action0 markOnCompleted = new Action0() {
           @Override
           public void call() {
               if (!commandIsScalar()) {
                   long latency = System.currentTimeMillis() - executionResult.getStartTimestamp();
                   eventNotifier.markCommandExecution(getCommandKey(), properties.executionIsolationStrategy().get(), (int) latency, executionResult.getOrderedList());
                   eventNotifier.markEvent(HystrixEventType.SUCCESS, commandKey);
                   executionResult = executionResult.addEvent((int) latency, HystrixEventType.SUCCESS);
                   circuitBreaker.markSuccess();
               }
           }
       };

    
    //设置 后备逻辑处理
       final Func1<Throwable, Observable<R>> handleFallback = new Func1<Throwable, Observable<R>>() {
           @Override
           public Observable<R> call(Throwable t) {
               Exception e = getExceptionFromThrowable(t);
               executionResult = executionResult.setExecutionException(e);
               if (e instanceof RejectedExecutionException) {
                   return handleThreadPoolRejectionViaFallback(e);
               } else if (t instanceof HystrixTimeoutException) {
                   return handleTimeoutViaFallback();
               } else if (t instanceof HystrixBadRequestException) {
                   return handleBadRequestByEmittingError(e);
               } else {
                   /*
                    * Treat HystrixBadRequestException from ExecutionHook like a plain HystrixBadRequestException.
                    */
                   if (e instanceof HystrixBadRequestException) {
                       eventNotifier.markEvent(HystrixEventType.BAD_REQUEST, commandKey);
                       return Observable.error(e);
                   }

                   return handleFailureViaFallback(e);
               }
           }
       };

    
    //设置 请求的上下文处理
       final Action1<Notification<? super R>> setRequestContext = new Action1<Notification<? super R>>() {
           @Override
           public void call(Notification<? super R> rNotification) {
               setRequestContextIfNeeded(currentRequestContext);
           }
       };

    //是否开启超时
       Observable<R> execution;
       if (properties.executionTimeoutEnabled().get()) {
           
           //超时处理
           execution = executeCommandWithSpecifiedIsolation(_cmd)
                   .lift(new HystrixObservableTimeoutOperator<R>(_cmd));
       } else {
           execution = executeCommandWithSpecifiedIsolation(_cmd);
       }

       return execution.doOnNext(markEmits)
               .doOnCompleted(markOnCompleted)
               .onErrorResumeNext(handleFallback)
               .doOnEach(setRequestContext);
   }

private Observable<R> executeCommandWithSpecifiedIsolation(final AbstractCommand<R> _cmd) {
      if (properties.executionIsolationStrategy().get() == ExecutionIsolationStrategy.THREAD) {
          // mark that we are executing in a thread (even if we end up being rejected we still were a THREAD execution and not SEMAPHORE)
          //标记我们正在线程中执行（即使我们最终被拒绝，我们仍然是线程执行而不是信号量）
          return Observable.defer(new Func0<Observable<R>>() {
              @Override
              public Observable<R> call() {
                  executionResult = executionResult.setExecutionOccurred();
                  if (!commandState.compareAndSet(CommandState.OBSERVABLE_CHAIN_CREATED, CommandState.USER_CODE_EXECUTED)) {
                      return Observable.error(new IllegalStateException("execution attempted while in state : " + commandState.get().name()));
                  }

                  metrics.markCommandStart(commandKey, threadPoolKey, ExecutionIsolationStrategy.THREAD);

                  if (isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT) {
                      // the command timed out in the wrapping thread so we will return immediately
                      // and not increment any of the counters below or other such logic
                      return Observable.error(new RuntimeException("timed out before executing run()"));
                  }
                  if (threadState.compareAndSet(ThreadState.NOT_USING_THREAD, ThreadState.STARTED)) {
                      //we have not been unsubscribed, so should proceed
                      HystrixCounters.incrementGlobalConcurrentThreads();
                      threadPool.markThreadExecution();
                      // store the command that is being run
                      endCurrentThreadExecutingCommand = Hystrix.startCurrentThreadExecutingCommand(getCommandKey());
                      executionResult = executionResult.setExecutedInThread();
                      /**
                       * If any of these hooks throw an exception, then it appears as if the actual execution threw an error
                       */
                      try {
                          executionHook.onThreadStart(_cmd);
                          executionHook.onRunStart(_cmd);
                          executionHook.onExecutionStart(_cmd);
                          return getUserExecutionObservable(_cmd);
                      } catch (Throwable ex) {
                          return Observable.error(ex);
                      }
                  } else {
                      //command has already been unsubscribed, so return immediately
                      return Observable.error(new RuntimeException("unsubscribed before executing run()"));
                  }
              }
          }).doOnTerminate(new Action0() {
              @Override
              public void call() {
                  if (threadState.compareAndSet(ThreadState.STARTED, ThreadState.TERMINAL)) {
                      handleThreadEnd(_cmd);
                  }
                  if (threadState.compareAndSet(ThreadState.NOT_USING_THREAD, ThreadState.TERMINAL)) {
                      //if it was never started and received terminal, then no need to clean up (I don't think this is possible)
                  }
                  //if it was unsubscribed, then other cleanup handled it
              }
          }).doOnUnsubscribe(new Action0() {
              @Override
              public void call() {
                  if (threadState.compareAndSet(ThreadState.STARTED, ThreadState.UNSUBSCRIBED)) {
                      handleThreadEnd(_cmd);
                  }
                  if (threadState.compareAndSet(ThreadState.NOT_USING_THREAD, ThreadState.UNSUBSCRIBED)) {
                      //if it was never started and was cancelled, then no need to clean up
                  }
                  //if it was terminal, then other cleanup handled it
              }
          }).subscribeOn(threadPool.getScheduler(new Func0<Boolean>() {
              @Override
              public Boolean call() {
                  return properties.executionIsolationThreadInterruptOnTimeout().get() && _cmd.isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT;
              }
          }));
      } else {
          return Observable.defer(new Func0<Observable<R>>() {
              @Override
              public Observable<R> call() {
                  executionResult = executionResult.setExecutionOccurred();
                  if (!commandState.compareAndSet(CommandState.OBSERVABLE_CHAIN_CREATED, CommandState.USER_CODE_EXECUTED)) {
                      return Observable.error(new IllegalStateException("execution attempted while in state : " + commandState.get().name()));
                  }

                  metrics.markCommandStart(commandKey, threadPoolKey, ExecutionIsolationStrategy.SEMAPHORE);
                  //信号量隔离存储正在运行的命令
                  endCurrentThreadExecutingCommand = Hystrix.startCurrentThreadExecutingCommand(getCommandKey());
                  try {
                      executionHook.onRunStart(_cmd);
                      executionHook.onExecutionStart(_cmd);
                      return getUserExecutionObservable(_cmd);  //getUserExecutionObservable方法已经包装了同步异常，因此不应引发
                  } catch (Throwable ex) {
                      //If the above hooks throw, then use that as the result of the run method
                      return Observable.error(ex);
                  }
              }
          });
      }
  }

private Observable<R> getUserExecutionObservable(final AbstractCommand<R> _cmd) {
    Observable<R> userObservable;

    try {
        userObservable = getExecutionObservable();
    } catch (Throwable ex) {
        // the run() method is a user provided implementation so can throw instead of using Observable.onError
        // so we catch it here and turn it into Observable.error
        userObservable = Observable.error(ex);
    }

    return userObservable
            .lift(new ExecutionHookApplication(_cmd))
            .lift(new DeprecatedOnRunHookApplication(_cmd));
}

@Override
   final protected Observable<R> getExecutionObservable() {
       return Observable.defer(new Func0<Observable<R>>() {
           @Override
           public Observable<R> call() {
               try {
                   //最终 这里 是一个初始的被观察者，一层一层包着 装饰
                   return Observable.just(run());
               } catch (Throwable ex) {
                   return Observable.error(ex);
               }
           }
       }).doOnSubscribe(new Action0() {
           @Override
           public void call() {
               // Save thread on which we get subscribed so that we can interrupt it later if needed
               executionThread.set(Thread.currentThread());
           }
       });
   }

/*
创建 客户端，负载平衡器和客户端配置 实例 的工厂。它为每个客户端名称创建一个Spring ApplicationContext，并从中提取它所需的beans。
A factory that creates client, load balancer and client configuration instances. It creates a Spring ApplicationContext per client name, and extracts the beans that it needs from there.
*/

这个工厂会为每一个 不同名字的客户端创建一个上下文对象
    
    例如一个服务名 service-file 那么他就对应一个容器
    
    
protected AnnotationConfigApplicationContext createContext(String name) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		if (this.configurations.containsKey(name)) {
			for (Class<?> configuration : this.configurations.get(name)
					.getConfiguration()) {
				context.register(configuration);
			}
		}
		for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
			if (entry.getKey().startsWith("default.")) {
				for (Class<?> configuration : entry.getValue().getConfiguration()) {
					context.register(configuration);
				}
			}
		}
		context.register(PropertyPlaceholderAutoConfiguration.class,
				this.defaultConfigType);
		context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
				this.propertySourceName,
				Collections.<String, Object>singletonMap(this.propertyName, name)));
		if (this.parent != null) {
			// Uses Environment from parent as well as beans
			context.setParent(this.parent);
			// jdk11 issue
			// https://github.com/spring-cloud/spring-cloud-netflix/issues/3101
			context.setClassLoader(this.parent.getClassLoader());
		}
		context.setDisplayName(generateDisplayName(name));
		context.refresh();
		return context;
	}

/*
 Factory for {@link ClientHttpRequest} objects.
 * Requests are created by the {@link #createRequest(URI, HttpMethod)} method.
 
 是一个ClientHttpRequest对象的工厂，通过createRequest(URI, HttpMethod)方法来创建 request
 
 
*/

ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException;

RibbonClientHttpRequestFactory 实现ClientHttpRequestFactory
    
  private final SpringClientFactory clientFactory;  
public ClientHttpRequest createRequest(URI originalUri, HttpMethod httpMethod)
			throws IOException {
		String serviceId = originalUri.getHost();
		if (serviceId == null) {
			throw new IOException(
					"Invalid hostname in the URI [" + originalUri.toASCIIString() + "]");
		}
		IClientConfig clientConfig = this.clientFactory.getClientConfig(serviceId);
		RestClient client = this.clientFactory.getClient(serviceId, RestClient.class);
		HttpRequest.Verb verb = HttpRequest.Verb.valueOf(httpMethod.name());

		return new RibbonHttpRequest(originalUri, verb, client, clientConfig);
	}

/*
定义了各种API用于初始化客户端或负载平衡器以及执行方法的客户端配置。默认实现是{@link Defaultclientconfigimpl}。

 Defines the client configuration used by various APIs to initialize clients or load balancers and for method execution. The default implementation is {@link DefaultClientConfigImpl}.
*/

/*
接口，用于定义负载平衡器的“规则”。规则可以被认为是载荷平衡的策略。众所周知的负载平衡策略包括循环，基于响应时间的等。

Interface that defines a "Rule" for a LoadBalancer. A Rule can be thought of as a Strategy for loadbalacing. Well known loadbalancing strategies include Round Robin, Response Time based etc.

*/
    public Server choose(Object key);
    
    public void setLoadBalancer(ILoadBalancer lb);
    
    public ILoadBalancer getLoadBalancer();

/*
定义软件loadbalancer操作的接口。典型的loadbalancer最少需要一组服务器来进行loadbalance，一种标记特定服务器旋转不良的方法以及一个将从现有服务器列表中选择服务器的调用。

Interface that defines the operations for a software loadbalancer. A typical loadbalancer minimally need a set of servers to loadbalance for, a method to mark a particular server to be out of rotation and a call that will choose a server from the existing list of server.

*/

接口，定义了我们如何“ping”一个服务器来检查它是否还活着
public interface IPing {
    
    /**
     * Checks whether the given <code>Server</code> is "alive" i.e. should be
     * considered a candidate while loadbalancing
     * 
     */
    public boolean isAlive(Server server);
}

/*
这个注解继承了一个@Qualifier注解
*/


所以后续有一个配置类使用@LoadBalanced放在属性上面要去注入时就会把加了@LoadBalanced的bean注入

HttpAccessor:{@link org.springframework.web.client.RestTemplate}和其他HTTP访问网关助手的基础类，定义要操作的常见属性，例如{@link clientHttpRequestFactory}。不打算直接使用。

InterceptingHttpAccessor:  RestTemplate和其他HTTP访问网关助手的基础类，将interceptor相关属性添加到{@link HttpAccessor}的公共属性中。
     
RestOperations：接口指定一组基本的RESTful操作。由{@link RestTemplate}实现。不经常直接使用，而是增强可测试性的有用选项，因为它可以很容易地被模仿或残茬。
    
    
public class RestTemplate extends InterceptingHttpAccessor implements RestOperations {
    /*
    同步客户端执行HTTP请求，在底层HTTP客户端库（如JDK{@code HttpURLConnection}，Apache httpComponents等）上暴露一个简单的模板方法API。
	除了支持频率较低的情况的通用{@code exchange}和{@code execute}方法之外，RestTemplate还通过HTTP方法为常见场景提供模板。
    注意：截至5.0，本课程处于维护模式，只有少量请求更改和错误才能被接受。请考虑使用具有更现代化API并支持同步，异步和流式场景的WebClient。
    
 
    
}

String url="http://service-file/get";
restTemplate.postForEntity(url,"",String.class);



	@Override
	public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request,
			Class<T> responseType, Object... uriVariables) throws RestClientException {

        //把请求体request和返回类型包装成一个requestCallback
		RequestCallback requestCallback = httpEntityCallback(request, responseType);
        //把返回类型包装成一个 responseExtractor （返回结果的提取器）
		ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
        //然后执行，方法时post
		return nonNull(execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables));
	}


public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback,
			@Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {

    //把url和uriVariables包装在一起得到一个URI类的对象
		URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    //前面都是包装方便给后面调用
    //开始真正的处理
		return doExecute(expanded, method, requestCallback, responseExtractor);
	}


protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
			@Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {

		Assert.notNull(url, "URI is required");
		Assert.notNull(method, "HttpMethod is required");
		ClientHttpResponse response = null;
		try {
            //通过url和请求方法创建一个ClientHttpRequest
			ClientHttpRequest request = createRequest(url, method);
			if (requestCallback != null) {
				requestCallback.doWithRequest(request);
			}
            //有这个request进行处理
			response = request.execute();
			handleResponse(url, method, response);
			return (responseExtractor != null ? responseExtractor.extractData(response) : null);
		}
		catch (IOException ex) {
			String resource = url.toString();
			String query = url.getRawQuery();
			resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
			throw new ResourceAccessException("I/O error on " + method.name() +
					" request for \"" + resource + "\": " + ex.getMessage(), ex);
		}
		finally {
			if (response != null) {
				response.close();
			}
		}
	}




@Override
	public final ClientHttpResponse execute() throws IOException {
		assertNotExecuted();
		ClientHttpResponse result = executeInternal(this.headers);
		this.executed = true;
		return result;
	}


	@Override
	protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException {
		byte[] bytes = this.bufferedOutput.toByteArray();
		if (headers.getContentLength() < 0) {
			headers.setContentLength(bytes.length);
		}
		ClientHttpResponse result = executeInternal(headers, bytes);
		this.bufferedOutput = new ByteArrayOutputStream(0);
		return result;
	}


	protected final ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException {
		InterceptingRequestExecution requestExecution = new InterceptingRequestExecution();
		return requestExecution.execute(this, bufferedOutput);
	}


public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException {
			if (this.iterator.hasNext()) {
                //看有没有拦截器，有就进行拦截处理，注意，多个拦截器是可以执行的，因为this被当作参数传过去了
				ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
				return nextInterceptor.intercept(request, body, this);
			}
			else {
                //最后会执行这里，拦截器都执行完了，，传进来的requestFactory就作用了
				HttpMethod method = request.getMethod();
				Assert.state(method != null, "No standard HTTP method");
                
                //这个是真正执行的ClientHttpRequest
				ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), method);
				request.getHeaders().forEach((key, value) -> delegate.getHeaders().addAll(key, value));
				if (body.length > 0) {
					if (delegate instanceof StreamingHttpOutputMessage) {
						StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) delegate;
						streamingOutputMessage.setBody(outputStream -> StreamUtils.copy(body, outputStream));
					}
					else {
						StreamUtils.copy(body, delegate.getBody());
					}
				}
                //执行
				return delegate.execute();
			}
		}



//最后
	private final HttpURLConnection connection;
this.connection.connect();
		if (this.connection.getDoOutput()) {
			FileCopyUtils.copy(bufferedOutput, this.connection.getOutputStream());
		}