import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
private void reinitializeLoggingSystem(ConfigurableEnvironment environment,
		String oldLogConfig, LogFile oldLogFile) {
	Map<String, Object> props = Binder.get(environment)
			.bind("logging", Bindable.mapOf(String.class, Object.class)).orElseGet(Collections::emptyMap);
	if (!props.isEmpty()) {
		String logConfig = environment.resolvePlaceholders("${logging.config:}");
		LogFile logFile = LogFile.get(environment);
		LoggingSystem system = LoggingSystem
				.get(LoggingSystem.class.getClassLoader());
		try {
			ResourceUtils.getURL(logConfig).openStream().close();
			// Three step initialization that accounts for the clean up of the logging
			// context before initialization. Spring Boot doesn't initialize a logging
			// system that hasn't had this sequence applied (since 1.4.1).
			system.cleanUp();
			system.beforeInitialize();
			system.initialize(new LoggingInitializationContext(environment),
					logConfig, logFile);
		}
		catch (Exception ex) {
			PropertySourceBootstrapConfiguration.logger
					.warn("Logging config file location '" + logConfig
							+ "' cannot be opened and will be ignored");
		}
	}
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context,
    AnnotatedTypeMetadata metadata) {
  String prefix = (String) attribute(metadata, "prefix");
  Class<?> value = (Class<?>) attribute(metadata, "value");
  ConfigurableEnvironment environment = (ConfigurableEnvironment) context.getEnvironment();
  try {
    new Binder(ConfigurationPropertySources.from(environment.getPropertySources()))
        .bind(prefix, Bindable.of(value))
        .orElseThrow(
            () -> new FatalBeanException("Could not bind DataSourceSettings properties"));
    return new ConditionOutcome(true, String.format("Map property [%s] is not empty", prefix));
  } catch (Exception e) {
    //ignore
  }
  return new ConditionOutcome(false, String.format("Map property [%s] is empty", prefix));
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
private Map<String, String> bindProperties() {
	Map<String, String> target;
	BindResult<Map<String, String>> bindResult = Binder.get(environment).bind("", STRING_STRING_MAP);
	if (bindResult.isBound()) {
		target = bindResult.get();
	}
	else {
		target = new HashMap<>();
	}
	return target;
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
private Map<String, String> bindProperties(String namepace, Environment environment) {
	Map<String, String> target;
	BindResult<Map<String, String>> bindResult = Binder.get(environment).bind(namepace, STRING_STRING_MAP);
	if (bindResult.isBound()) {
		target = bindResult.get();
	}
	else {
		target = new HashMap<>();
	}
	return target;
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@Override
public T get(Object key) {
	if (!this.delegate.containsKey(key) && key instanceof String) {
		T entry = BeanUtils.instantiateClass(entryClass);
		Binder binder = new Binder(ConfigurationPropertySources.get(environment),new PropertySourcesPlaceholdersResolver(environment),this.conversionService);
		binder.bind(defaultsPrefix, Bindable.ofInstance(entry));
		this.delegate.put((String) key, entry);
	}
	return this.delegate.get(key);
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@Override
public T put(String key, T value) {
	// boot 2 call this first
	Binder binder = new Binder(ConfigurationPropertySources.get(environment),new PropertySourcesPlaceholdersResolver(environment),this.conversionService);
	binder.bind(defaultsPrefix, Bindable.ofInstance(value));
	return this.delegate.put(key, value);
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
	Map<String, String> subProperties = Binder.get(context.getEnvironment())
			.bind(ZOOKEEPER_DEPENDENCIES_PROP, STRING_STRING_MAP).orElseGet(Collections::emptyMap);
	if (!subProperties.isEmpty()) {
		return ConditionOutcome.match("Dependencies are defined in configuration");
	}
	Boolean dependenciesEnabled = context.getEnvironment()
			.getProperty("spring.cloud.zookeeper.dependency.enabled", Boolean.class, false);
	if (dependenciesEnabled) {
		return ConditionOutcome.match("Dependencies are not defined in configuration, but switch is turned on");
	}
	return ConditionOutcome.noMatch("No dependencies have been passed for the service");
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
protected void setLogLevels(LoggingSystem system, Environment environment) {
	Map<String, String> levels = Binder.get(environment)
			.bind("logging.level", STRING_STRING_MAP).orElseGet(Collections::emptyMap);
	for (Entry<String, String> entry : levels.entrySet()) {
		setLogLevel(system, environment, entry.getKey(), entry.getValue().toString());
	}
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
private void insertPropertySources(MutablePropertySources propertySources,
		CompositePropertySource composite) {
	MutablePropertySources incoming = new MutablePropertySources();
	incoming.addFirst(composite);
	PropertySourceBootstrapProperties remoteProperties = new PropertySourceBootstrapProperties();
	Binder.get(environment(incoming)).bind("spring.cloud.config", Bindable.ofInstance(remoteProperties));
	if (!remoteProperties.isAllowOverride() || (!remoteProperties.isOverrideNone()
			&& remoteProperties.isOverrideSystemProperties())) {
		propertySources.addFirst(composite);
		return;
	}
	if (remoteProperties.isOverrideNone()) {
		propertySources.addLast(composite);
		return;
	}
	if (propertySources
			.contains(StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME)) {
		if (!remoteProperties.isOverrideSystemProperties()) {
			propertySources.addAfter(
					StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
					composite);
		}
		else {
			propertySources.addBefore(
					StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
					composite);
		}
	}
	else {
		propertySources.addLast(composite);
	}
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
private HostInfo getFirstNonLoopbackHostInfo(ConfigurableEnvironment environment) {
	InetUtilsProperties target = new InetUtilsProperties();
	ConfigurationPropertySources.attach(environment);
	Binder.get(environment).bind(InetUtilsProperties.PREFIX,
			Bindable.ofInstance(target));
	try (InetUtils utils = new InetUtils(target)) {
		return utils.findFirstNonLoopbackHostInfo();
	}
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private Map<String, Map<String, String>> getDbInstanceConfigurations() {
    Map<String, Object> subProperties = Binder.get(this.environment)
            .bind(PREFIX, Bindable.mapOf(String.class, Object.class)).orElseGet(Collections::emptyMap);
    Map<String, Map<String, String>> dbConfigurationMap = new HashMap<>(subProperties.keySet().size());
    for (Map.Entry<String, Object> subProperty : subProperties.entrySet()) {
        String instanceName = subProperty.getKey();
        if (!dbConfigurationMap.containsKey(instanceName)) {
            dbConfigurationMap.put(instanceName, new HashMap<>());
        }

        Object value = subProperty.getValue();

        if (value instanceof Map) {
            Map<String, String> map = (Map) value;
            for (Map.Entry<String, String> entry : map.entrySet()) {
                dbConfigurationMap.get(instanceName).put(entry.getKey(), entry.getValue());
            }
        } else if (value instanceof String) {
            String subPropertyName = extractConfigurationSubPropertyName(subProperty.getKey());
            if (StringUtils.hasText(subPropertyName)) {
                dbConfigurationMap.get(instanceName).put(subPropertyName, (String) subProperty.getValue());
            }
        }
    }
    return dbConfigurationMap;
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@Test
public void noop() {
	this.listener.postProcessEnvironment(this.environment, new SpringApplication());
	Map<String, Object> properties = Binder.get(environment)
			.bind("security.oauth2", STRING_OBJECT_MAP).orElseGet(Collections::emptyMap);
	assertTrue(properties.isEmpty());
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context,
		AnnotatedTypeMetadata metadata) {
	ConditionMessage.Builder message = ConditionMessage
			.forCondition("OAuth ResourceServer Condition");
	Environment environment = context.getEnvironment();
	if (!(environment instanceof ConfigurableEnvironment)) {
		return ConditionOutcome
				.noMatch(message.didNotFind("A ConfigurableEnvironment").atAll());
	}
	if (hasOAuthClientId(environment)) {
		return ConditionOutcome.match(message.foundExactly("client-id property"));
	}
	Binder binder = Binder.get(environment);
	String prefix = "security.oauth2.resource.";
	if (binder.bind(prefix + "jwt", STRING_OBJECT_MAP).isBound()) {
		return ConditionOutcome
				.match(message.foundExactly("JWT resource configuration"));
	}
	if (binder.bind(prefix + "jwk", STRING_OBJECT_MAP).isBound()) {
		return ConditionOutcome
				.match(message.foundExactly("JWK resource configuration"));
	}
	if (StringUtils.hasText(environment.getProperty(prefix + "user-info-uri"))) {
		return ConditionOutcome
				.match(message.foundExactly("user-info-uri property"));
	}
	if (StringUtils.hasText(environment.getProperty(prefix + "token-info-uri"))) {
		return ConditionOutcome
				.match(message.foundExactly("token-info-uri property"));
	}
	if (ClassUtils.isPresent(AUTHORIZATION_ANNOTATION, null)) {
		if (AuthorizationServerEndpointsConfigurationBeanCondition
				.matches(context)) {
			return ConditionOutcome.match(
					message.found("class").items(AUTHORIZATION_ANNOTATION));
		}
	}
	return ConditionOutcome.noMatch(
			message.didNotFind("client ID, JWT resource or authorization server")
					.atAll());
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
protected <T> T resolverSetting(Class<T> clazz, MutablePropertySources propertySources) {
  return new Binder(ConfigurationPropertySources.from(propertySources))
      .bind("loc", Bindable.of(clazz))
      .orElseThrow(() -> new FatalBeanException("Could not bind DataSourceSettings properties"));
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
public static Map<String, String> getSubProperties(Environment environment,
		String keyPrefix) {
	return Binder.get(environment)
			.bind(keyPrefix, Bindable.mapOf(String.class, String.class))
			.orElseGet(Collections::emptyMap);
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
private ClientProperties getClientProperties(ConditionContext context) {
    Iterable<ConfigurationPropertySource> sources = ConfigurationPropertySources.get(context.getEnvironment());
    ClientProperties clientProperties = new ClientProperties();
    new Binder(sources).bind("spring.boot.admin.client", Bindable.ofInstance(clientProperties));
    return clientProperties;
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
@Override
public void postProcessEnvironment(ConfigurableEnvironment environment,
		SpringApplication application) {
	Binder.get(environment).bind("vcap.services", STRING_OBJECT_MAP)
			.orElseGet(Collections::emptyMap);
	if (!hasChildProperties(environment, "vcap.services")) {
		return;
	}
	Map<String, Object> source = new HashMap<>();
	String serviceId;
	if (hasChildProperties(environment, "security.oauth2.resource")) {
		serviceId = environment.getProperty("security.oauth2.resource.service-id",
				"resource");
	}
	else {
		serviceId = environment.getProperty("security.oauth2.sso.service-id", "sso");
	}
	String authDomain = environment
			.getProperty("vcap.services." + serviceId + ".credentials.auth-domain");
	if (authDomain != null) {
		source.put("security.oauth2.resource.user-info-uri",
				authDomain + "/userinfo");
		source.put("security.oauth2.resource.jwt.key-uri", authDomain + "/token_key");
		source.put("security.oauth2.client.access-token-uri",
				authDomain + "/oauth/token");
		source.put("security.oauth2.client.user-authorization-uri",
				authDomain + "/oauth/authorize");
	}
	else {
		addProperty(source, environment, serviceId, "resource", "user-info-uri");
		addProperty(source, environment, serviceId, "resource", "token-info-uri");
		addProperty(source, environment, serviceId, "resource.jwt", "key-uri");
		addProperty(source, environment, serviceId, "resource", "key-value");
		addProperty(source, environment, serviceId, "client", "access-token-uri",
				"token-uri");
		addProperty(source, environment, serviceId, "client",
				"user-authorization-uri", "authorization-uri");
	}
	addProperty(source, environment, serviceId, "client", "client-id");
	addProperty(source, environment, serviceId, "client", "client-secret");
	addProperty(source, environment, serviceId, "client", "scope");
	String resourceId = environment
			.getProperty("vcap.services." + serviceId + ".credentials.id", "");
	if (StringUtils.hasText(resourceId)) {
		source.put("security.oauth2.resource.id", resourceId);
	}
	environment.getPropertySources()
			.addLast(new MapPropertySource("cloudDefaultSecurityBindings", source));
}
 

import org.springframework.boot.context.properties.bind.Binder; //导入依赖的package包/类
private boolean hasChildProperties(ConfigurableEnvironment environment, String name) {
	Map<String, Object> properties = Binder.get(environment)
			.bind(name, STRING_OBJECT_MAP).orElseGet(Collections::emptyMap);
	return !properties.isEmpty();
}