Java PropertiesConfigurationFactory.setPropertySources方法代码示例

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
public static MangoConfig getMangoConfig(DefaultListableBeanFactory beanFactory,String prefix){
    MangoConfig target = new MangoConfig();
    PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(target);
    factory.setPropertySources(deducePropertySources(beanFactory));
    factory.setConversionService(new DefaultConversionService());
    factory.setIgnoreInvalidFields(false);
    factory.setIgnoreUnknownFields(true);
    factory.setIgnoreNestedProperties(false);
    factory.setTargetName(prefix);
    try {
        factory.bindPropertiesToTarget();
    }
    catch (Exception ex) {
        throw new MangoAutoConfigException(ex);
    }
    return target;
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@Override
public void parse(File file, ContainerCreationContext context) {
    try {
        ContainerSource arg = new ContainerSource();
        PropertySourcesLoader loader = new PropertySourcesLoader();
        loader.load(new FileSystemResource(file));
        MutablePropertySources loaded = loader.getPropertySources();
        PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<>(arg);

        factory.setPropertySources(loaded);
        factory.setConversionService(defaultConversionService);
        factory.bindPropertiesToTarget();
        arg.getInclude().forEach(a -> parse(new File(file.getParent(), a), context));
        context.addCreateContainerArg(arg);
    } catch (Exception e) {
        log.error("can't parse configuration", e.getMessage());
    }
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <T> T resolveSettings(Class<T> settingsClass, String prefix, ConfigurableEnvironment environment) {
    try {
        T newSettings = (T) Class.forName(settingsClass.getName()).newInstance();

        PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(newSettings);
        factory.setTargetName(prefix);
        factory.setPropertySources(environment.getPropertySources());
        factory.setConversionService(environment.getConversionService());
        factory.bindPropertiesToTarget();

        return newSettings;
    } catch (Exception ex) {
        throw new FatalBeanException("Could not bind DataSourceSettings properties", ex);
    }
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
private <T> T getDruidConfig(String prefix, Class<T> claz) {
	PropertiesConfigurationFactory<T> factory = new PropertiesConfigurationFactory<T>(claz);
	factory.setPropertySources(environment.getPropertySources());
	factory.setConversionService(environment.getConversionService());
	factory.setIgnoreInvalidFields(false);
	factory.setIgnoreUnknownFields(true);
	factory.setIgnoreNestedProperties(false);
	factory.setTargetName(prefix);
	try {
		factory.bindPropertiesToTarget();
		return factory.getObject();
	} catch (Exception e) {
		throw new RuntimeException(e);
	}
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    log.debug("in registerBeanDefinitions(..)");
    SolrMltInterestingTermConfiguration config = new SolrMltInterestingTermConfiguration();
    PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(config);
    factory.setTargetName("keyword");
    factory.setPropertySources(environment.getPropertySources());
    factory.setConversionService(environment.getConversionService());
    try {
        factory.bindPropertiesToTarget();
    }
    catch (BindException ex) {
        throw new FatalBeanException("Could not bind DataSourceSettings properties", ex);
    }
    ModifiableSolrParams params = new ModifiableSolrParams();
    params.set(HttpClientUtil.PROP_MAX_CONNECTIONS, 128);
    params.set(HttpClientUtil.PROP_MAX_CONNECTIONS_PER_HOST, 32);
    params.set(HttpClientUtil.PROP_FOLLOW_REDIRECTS, false);
    httpClient = HttpClientUtil.createClient(params);
    config.getSolrmlt().stream().filter(SolrMltConfig::isValid).forEach(mltConfig -> {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(SolrMltInterestingTermExtractor.class);
        ConstructorArgumentValues constructorArguments = new ConstructorArgumentValues();
        beanDefinition.setConstructorArgumentValues(constructorArguments);
        constructorArguments.addIndexedArgumentValue(0, httpClient);
        constructorArguments.addIndexedArgumentValue(1, mltConfig);
        log.debug("register bean definition for {}", mltConfig);
        registry.registerBeanDefinition(mltConfig.getName(), beanDefinition);
    });
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
private void postProcessBeforeInitialization(Object bean, String beanName,
		ConfigurationProperties annotation) {
	Object target = bean;
	PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(
			target);
	if (annotation != null && annotation.locations().length != 0) {
		factory.setPropertySources(
				loadPropertySources(annotation.locations(), annotation.merge()));
	}
	else {
		factory.setPropertySources(this.propertySources);
	}
	factory.setValidator(determineValidator(bean));
	// If no explicit conversion service is provided we add one so that (at least)
	// comma-separated arrays of convertibles can be bound automatically
	factory.setConversionService(this.conversionService == null
			? getDefaultConversionService() : this.conversionService);
	if (annotation != null) {
		factory.setIgnoreInvalidFields(annotation.ignoreInvalidFields());
		factory.setIgnoreUnknownFields(annotation.ignoreUnknownFields());
		factory.setExceptionIfInvalid(annotation.exceptionIfInvalid());
		factory.setIgnoreNestedProperties(annotation.ignoreNestedProperties());
		if (StringUtils.hasLength(annotation.prefix())) {
			factory.setTargetName(annotation.prefix());
		}
	}
	try {
		factory.bindPropertiesToTarget();
	}
	catch (Exception ex) {
		String targetClass = ClassUtils.getShortName(target.getClass());
		throw new BeanCreationException(beanName, "Could not bind properties to "
				+ targetClass + " (" + getAnnotationDetails(annotation) + ")", ex);
	}
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
/**
 * Bind the environment to the {@link SpringApplication}.
 * @param environment the environment to bind
 * @param application the application to bind to
 */
protected void bindToSpringApplication(ConfigurableEnvironment environment,
		SpringApplication application) {
	PropertiesConfigurationFactory<SpringApplication> binder = new PropertiesConfigurationFactory<SpringApplication>(
			application);
	binder.setTargetName("spring.main");
	binder.setConversionService(this.conversionService);
	binder.setPropertySources(environment.getPropertySources());
	try {
		binder.bindPropertiesToTarget();
	}
	catch (BindException ex) {
		throw new IllegalStateException("Cannot bind to SpringApplication", ex);
	}
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@VisibleForTesting
@SneakyThrows
RestSettings getSettings() {
    if (settings == null) {
        final PropertiesConfigurationFactory<RestSettings> factory =
                new PropertiesConfigurationFactory<>(RestSettings.class);

        factory.setTargetName("rest");
        factory.setPropertySources(environment.getPropertySources());
        factory.setConversionService(environment.getConversionService());

        settings = factory.getObject();
    }
    return settings;
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@Bean
public NakadiSettings nakadiSettings() {
    final PropertiesConfigurationFactory<NakadiSettings> propertiesConfigurationFactory =
        new PropertiesConfigurationFactory<>(NakadiSettings.class);
    propertiesConfigurationFactory.setConversionService(environment.getConversionService());
    propertiesConfigurationFactory.setPropertySources(environment.getPropertySources());
    propertiesConfigurationFactory.setTargetName("paradox.nakadi");
    try {
        return propertiesConfigurationFactory.getObject();
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
private void postProcessBeforeInitialization(Object bean, String beanName,
		ConfigurationProperties annotation) {
	Object target = bean;
	PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(
			target);
	if (annotation != null && annotation.locations().length != 0) {
		factory.setPropertySources(
				loadPropertySources(annotation.locations(), annotation.merge()));
	}
	else {
		factory.setPropertySources(this.propertySources);
	}
	factory.setValidator(determineValidator(bean));
	// If no explicit conversion service is provided we add one so that (at least)
	// comma-separated arrays of convertibles can be bound automatically
	factory.setConversionService(this.conversionService == null
			? getDefaultConversionService() : this.conversionService);
	if (annotation != null) {
		factory.setIgnoreInvalidFields(annotation.ignoreInvalidFields());
		factory.setIgnoreUnknownFields(annotation.ignoreUnknownFields());
		factory.setExceptionIfInvalid(annotation.exceptionIfInvalid());
		factory.setIgnoreNestedProperties(annotation.ignoreNestedProperties());
		String targetName = (StringUtils.hasLength(annotation.value())
				? annotation.value() : annotation.prefix());
		if (StringUtils.hasLength(targetName)) {
			factory.setTargetName(targetName);
		}
	}
	try {
		factory.bindPropertiesToTarget();
	}
	catch (Exception ex) {
		String targetClass = ClassUtils.getShortName(target.getClass());
		throw new BeanCreationException(beanName, "Could not bind properties to "
				+ targetClass + " (" + getAnnotationDetails(annotation) + ")", ex);
	}
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
@Override
@SneakyThrows
public void setEnvironment(final Environment env) {
    final ConfigurableEnvironment environment = (ConfigurableEnvironment) env;

    final PropertiesConfigurationFactory<RiptideSettings> factory =
            new PropertiesConfigurationFactory<>(RiptideSettings.class);

    factory.setTargetName("riptide");
    factory.setPropertySources(environment.getPropertySources());
    factory.setConversionService(environment.getConversionService());

    this.settings = factory.getObject();
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
private void postProcessBeforeInitialization(Object bean, String beanName,
		ConfigurationProperties annotation) {
	Object target = (bean instanceof ConfigurationPropertiesHolder
			? ((ConfigurationPropertiesHolder) bean).getTarget() : bean);
	PropertiesConfigurationFactory<Object> factory = new PropertiesConfigurationFactory<Object>(
			target);
	if (annotation != null && annotation.locations().length != 0) {
		factory.setPropertySources(
				loadPropertySources(annotation.locations(), annotation.merge()));
	}
	else {
		factory.setPropertySources(this.propertySources);
	}
	factory.setValidator(determineValidator(bean));
	// If no explicit conversion service is provided we add one so that (at least)
	// comma-separated arrays of convertibles can be bound automatically
	factory.setConversionService(this.conversionService == null
			? getDefaultConversionService() : this.conversionService);
	if (annotation != null) {
		factory.setIgnoreInvalidFields(annotation.ignoreInvalidFields());
		factory.setIgnoreUnknownFields(annotation.ignoreUnknownFields());
		factory.setExceptionIfInvalid(annotation.exceptionIfInvalid());
		factory.setIgnoreNestedProperties(annotation.ignoreNestedProperties());
		String targetName = (StringUtils.hasLength(annotation.value())
				? annotation.value() : annotation.prefix());
		if (StringUtils.hasLength(targetName)) {
			factory.setTargetName(targetName);
		}
	}
	try {
		factory.bindPropertiesToTarget();
	}
	catch (Exception ex) {
		String targetClass = ClassUtils.getShortName(target.getClass());
		throw new BeanCreationException(beanName, "Could not bind properties to "
				+ targetClass + " (" + getAnnotationDetails(annotation) + ")", ex);
	}
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
public Map<String, Object> infoMap() throws Exception {
	PropertiesConfigurationFactory<Map<String, Object>> factory = new PropertiesConfigurationFactory<Map<String, Object>>(
			new LinkedHashMap<String, Object>());
	factory.setTargetName("info");
	factory.setPropertySources(this.environment.getPropertySources());
	return factory.getObject();
}
 

import org.springframework.boot.bind.PropertiesConfigurationFactory; //导入方法依赖的package包/类
private static InitializrProperties load(Resource resource) {
	PropertiesConfigurationFactory<InitializrProperties> factory = new PropertiesConfigurationFactory<>(
			InitializrProperties.class);
	factory.setTargetName("initializr");
	MutablePropertySources sources = new MutablePropertySources();
	sources.addFirst(new PropertiesPropertySource("main", loadProperties(resource)));
	factory.setPropertySources(sources);
	try {
		factory.afterPropertiesSet();
		return factory.getObject();
	}
	catch (Exception e) {
		throw new IllegalStateException("Could not create InitializrProperties", e);
	}
}