获取当前的Provider全部列表（包括连上和没连上的），比较费性能，慎用

@return 当前的Provider列表
182949
public Collection<ProviderInfo> currentProviderList() {
        List<ProviderInfo> providerInfos = new ArrayList<ProviderInfo>();
        List<ProviderGroup> providerGroups = addressHolder.getProviderGroups();
        if (CommonUtils.isNotEmpty(providerGroups)) {
            for (ProviderGroup entry : providerGroups) {
                providerInfos.addAll(entry.getProviderInfos());
            }
        }
        return providerInfos;
    }
881818
function Provider() {
            var _this = this;
            this._providers = [];
            this._exports = [];
            /**
             * Parse Provider name from path
             *
             * @test BootProviderTest
             *
             * @param providerPath
             * @returns {*}
             */
            this.parseNameFromPath = function (providerPath) {
                var fileName = providerPath
                    .split(/[\\/]+/)
                    .pop()
                    .replace(/\.[^/.]+$/, "");
                return fileName;
            };
            /**
             * Initializing Provider object by path
             *
             * @param providerPath
             */
            this.initProvider = function (providerPath, providerName) {
                if (!providerName) {
                    providerName = _this.parseNameFromPath(providerPath);
                }
                var providerSource = require(providerPath);
                var providerObject;
                // TODO
                // Non case sensitive provider key find
                for (var indexSource in providerSource) {
                    // Convert index to lower case
                    var lowerSource = indexSource.toLowerCase();
                    if (indexSource.toLowerCase() === lowerSource) {
                        providerObject = providerSource[indexSource];
                        break;
                    }
                }
                if (!providerObject) {
                    throw new Error("Provider object problem: " + providerPath);
                }
                _this.initProviderObject(providerObject, providerName);
            };
            /**
             * Initializing Provider object by required object
             *
             * @param providesObject
             */
            this.initProviderObject = function (providerObject, providerName) {
                //
                debug("Initializing Provider object: %s", providerName);
                var val = {
                    source: null,
                    instance: null,
                    booted: false,
                    bootedFiles: false,
                    loadedFiles: false,
                    manualBoot: false,
                    exportName: null,
                    exportNamespace: false,
                    //defineNamespace : null,
                    objects: {}
                };
                val.source = providerObject;
                val.instance = typeof val.source === "function" ? new val.source() : val.source;
                _this.validateProviderObject(val.instance);
                val.manualBoot = !!(typeof val.instance.manualBoot === "function" && val.instance.manualBoot() === true);
                val.exportName = val.instance.exportName();
                val.exportNamespace = val.instance.exportNamespace();
                //val.defineNamespace =
                // Call "register" in provider
                val.instance.register();
                debug("Provider register called: %s", providerName);
                if (val.exportName && typeof val.exportName === "string") {
                    // Convert export name to lower case
                    val.exportName = val.exportName.toLowerCase();
                    _this._providers[providerName] = _this._exports[val.exportName] = val;
                }
                else {
                    _this._providers[providerName] = val;
                }
            };
            //
        }
28965
public static String[] getByJNDI() {
        try {
            Class<?> dirContext =
                    Class.forName("javax.naming.directory.DirContext");
            Hashtable<String, String> env = new Hashtable<String, String>();
            env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory");
            Class<?> initialDirContext =
                    Class.forName("javax.naming.directory.InitialDirContext");
            Constructor<?> constructor = initialDirContext.getConstructor(Hashtable.class);

            Object obj = constructor.newInstance(env);
            Method m = dirContext.getMethod("getEnvironment");
            Hashtable newEnv = (Hashtable) m.invoke(obj);
            String dns = (String) newEnv.get("java.naming.provider.url");
            String dnsTrim = dns.replace("dns://", "");
            return dnsTrim.split(" ");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
548137
@Override
    public String getProviderEndpoints() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getProviderEndpoints");
        String providerEndpoints = jcaConnectionFactory.getProviderEndpoints();
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getProviderEndpoints", providerEndpoints);
        return providerEndpoints;
    }
637540
protected final URI getProviderURI() throws JMSException
    {
        String providerURL = getProviderURL();
        URI parsedURL;
        try
        {
            parsedURL = new URI(providerURL);
        }
        catch (URISyntaxException e)
        {
            throw new FFMQException("Malformed provider URL : "+providerURL,"INVALID_PROVIDER_URL");
        }
        if (!parsedURL.isAbsolute())
            throw new FFMQException("Invalid provider URL : "+providerURL,"INVALID_PROVIDER_URL");
        
        return parsedURL;
    }
237897
synchronized Provider getProvider() {
        // volatile variable load
        Provider p = provider;
        if (p != null) {
            return p;
        }
        if (shouldLoad() == false) {
            return null;
        }
        if (isLoading) {
            // because this method is synchronized, this can only
            // happen if there is recursion.
//            if (debug != null) {
//                debug.println("Recursion loading provider: " + this);
//                new Exception("Call trace").printStackTrace();
//            }
            return null;
        }
        try {
            isLoading = true;
            tries++;
            p = doLoadProvider();
        } finally {
            isLoading = false;
        }
        provider = p;
        return p;
    }
742245
public static String getProviderInfo() {

        StringBuilder sb = new StringBuilder(128);
        sb.append(Timezone.class.getName());
        sb.append(":[default-provider=");
        sb.append(DEFAULT_PROVIDER.getName());
        sb.append(", registered={");

        for (String key : PROVIDERS.keySet()) {
            ZoneModelProvider provider = PROVIDERS.get(key);
            if (provider != null) { // defensive against parallel threads
                sb.append("(name=");
                sb.append(provider.getName());

                String location = provider.getLocation();

                if (!location.isEmpty()) {
                    sb.append(",location=");
                    sb.append(location);
                }

                String version = provider.getVersion();

                if (!version.isEmpty()) {
                    sb.append(",version=");
                    sb.append(version);
                }

                sb.append(')');
            }
        }

        sb.append("}]");
        return sb.toString();

    }
1232891
public static ProviderContext of(String provider) {
        return ProviderContextBuilder.of(provider, RateType.ANY).build();
    }
1013181
public static String getCurrentId()
  {
    SystemManager system = getCurrent();

    if (system == null) {
      ClassLoader loader = Thread.currentThread().getContextClassLoader();

      throw new IllegalStateException(L.l("{0} is not available in this context.\n  {1}",
                                          SystemManager.class.getSimpleName(),
                                          loader));
    }

    return system.getId();
  }
408435
@Override
    public List<String> getDefaultProviderChain() {
        List<String> list = new ArrayList<>(getProviderNames());
        Collections.sort(list);
        return list;
    }
617547
public static function getCurrentProviderId()
    {
        try {
            $optionValue = Option::get(self::CURRENT_PROVIDER_OPTION_NAME);
        } catch (\Exception $e) {
            $optionValue = false;
        }
        return $optionValue === false ? DefaultProvider::ID : $optionValue;
    }
129519
Provider getProvider(int index) {
        Provider p = configs[index].getProvider();
        return (p != null) ? p : EMPTY_PROVIDER;
    }
1296944
public B setProviderNames(List<String> providers) {
        Objects.requireNonNull(providers);
        return set(AbstractQuery.KEY_QUERY_PROVIDERS, providers);
    }
224276
public String getReqId(){
        if(this.headers!=null && this.headers.containsKey(ViSearchHttpConstants.X_LOG_ID)){
            return headers.get(ViSearchHttpConstants.X_LOG_ID);
        }
        return ViSearchHttpConstants.X_LOG_ID_EMPTY;
    }
981191
private static Provider getAndroidSecurityProvider() {
    Provider[] providers = Security.getProviders();
    for (Provider availableProvider : providers) {
      for (String providerClassName : ANDROID_SECURITY_PROVIDERS) {
        if (providerClassName.equals(availableProvider.getClass().getName())) {
          logger.log(Level.FINE, "Found registered provider {0}", providerClassName);
          return availableProvider;
        }
      }
    }
    logger.log(Level.WARNING, "Unable to find Conscrypt");
    return null;
  }
1075689
public List<Component> getIndexProviders() {
        Problems problems = new SimpleProblems();
        List<Component> components = readComponents(doc, FieldName.INDEX_PROVIDERS, FieldName.CLASSNAME, INDEX_PROVIDER_ALIASES,
                                                    problems);
        assert !problems.hasErrors();
        return components;
    }
1095209
public Map<String, T> getMuiltServiceClients() {
		if (this.thriftConnection instanceof MulitServiceThriftConnecion) {
			MulitServiceThriftConnecion<T> connection = (MulitServiceThriftConnecion<T>) thriftConnection;
			return connection.getMuiltServiceClients();
		}
		throw new IllegalStateException("单服务运行模式下不允许调用该方法");
	}