Java 类org.springframework.boot.context.properties.bind.Binder 实例源码

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

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

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

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

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

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

@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");
}

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

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

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

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

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

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

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

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

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

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

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