下面列出了怎么用org.springframework.core.env.Environment的API类实例代码及写法，或者点击链接到github查看源代码。
@Bean
@ConditionalOnBean(DiscoveryClient.class)
@ConditionalOnMissingBean
public ServiceInstanceListSupplier zookeeperDiscoveryClientServiceInstanceListSupplier(
DiscoveryClient discoveryClient, Environment env,
ApplicationContext context,
ZookeeperDependencies zookeeperDependencies) {
DiscoveryClientServiceInstanceListSupplier firstDelegate = new DiscoveryClientServiceInstanceListSupplier(
discoveryClient, env);
ZookeeperServiceInstanceListSupplier secondDelegate = new ZookeeperServiceInstanceListSupplier(firstDelegate,
zookeeperDependencies);
ObjectProvider<LoadBalancerCacheManager> cacheManagerProvider = context
.getBeanProvider(LoadBalancerCacheManager.class);
if (cacheManagerProvider.getIfAvailable() != null) {
return new CachingServiceInstanceListSupplier(secondDelegate,
cacheManagerProvider.getIfAvailable());
}
return secondDelegate;
}
@Test
public void testInitializeConfigs() throws Exception {
Environment environment = Mockito.mock(Environment.class);
DescriptorAccessor baseDescriptorAccessor = Mockito.mock(DescriptorAccessor.class);
ConfigurationAccessor baseConfigurationAccessor = Mockito.mock(ConfigurationAccessor.class);
EncryptionUtility encryptionUtility = Mockito.mock(EncryptionUtility.class);
Mockito.when(encryptionUtility.isInitialized()).thenReturn(Boolean.TRUE);
EncryptionSettingsValidator encryptionValidator = new EncryptionSettingsValidator(encryptionUtility);
ChannelDescriptor channelDescriptor = new EmailDescriptor(EMAIL_CHANNEL_KEY, new EmailGlobalUIConfig(encryptionValidator), null);
List<DescriptorKey> descriptorKeys = List.of(channelDescriptor.getDescriptorKey());
List<ChannelDescriptor> channelDescriptors = List.of(channelDescriptor);
List<ProviderDescriptor> providerDescriptors = List.of();
List<ComponentDescriptor> componentDescriptors = List.of();
EnvironmentVariableUtility environmentVariableUtility = new EnvironmentVariableUtility(environment);
DescriptorMap descriptorMap = new DescriptorMap(descriptorKeys, channelDescriptors, providerDescriptors, componentDescriptors);
ConfigurationFieldModelConverter modelConverter = new ConfigurationFieldModelConverter(encryptionUtility, baseDescriptorAccessor, descriptorMap);
Mockito.when(baseDescriptorAccessor.getFieldsForDescriptor(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.copyOf(channelDescriptor.getAllDefinedFields(ConfigContextEnum.GLOBAL)));
FieldModelProcessor fieldModelProcessor = new FieldModelProcessor(modelConverter, new FieldValidationAction(), new DescriptorProcessor(descriptorMap, baseConfigurationAccessor, List.of(), List.of()));
SettingsUtility settingsUtility = Mockito.mock(SettingsUtility.class);
Mockito.when(settingsUtility.getKey()).thenReturn(new SettingsDescriptorKey());
AlertStartupInitializer initializer = new AlertStartupInitializer(descriptorMap, environmentVariableUtility, baseDescriptorAccessor, baseConfigurationAccessor, modelConverter, fieldModelProcessor, settingsUtility);
initializer.initializeComponent();
Mockito.verify(baseDescriptorAccessor, Mockito.times(3)).getFieldsForDescriptor(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class));
Mockito.verify(baseConfigurationAccessor, Mockito.times(2)).getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class));
}
@Override
public PropertySource<?> locate(Environment environment) {
if (!this.enabled) {
return new MapPropertySource(PROPERTY_SOURCE_NAME, Collections.emptyMap());
}
Map<String, Object> config;
try {
GoogleConfigEnvironment googleConfigEnvironment = getRemoteEnvironment();
Assert.notNull(googleConfigEnvironment, "Configuration not in expected format.");
config = googleConfigEnvironment.getConfig();
}
catch (Exception ex) {
String message = String.format("Error loading configuration for %s/%s_%s", this.projectId,
this.name, this.profile);
throw new RuntimeException(message, ex);
}
return new MapPropertySource(PROPERTY_SOURCE_NAME, config);
}
public OpenIdFormBasedWebSecurity(Environment environment,
UserManager userManager,
RecaptchaService recaptchaService,
ConfigurationManager configurationManager,
CsrfTokenRepository csrfTokenRepository,
DataSource dataSource,
PasswordEncoder passwordEncoder,
OpenIdAuthenticationManager openIdAuthenticationManager,
UserRepository userRepository,
AuthorityRepository authorityRepository,
UserOrganizationRepository userOrganizationRepository,
OrganizationRepository organizationRepository) {
super(environment, userManager, recaptchaService, configurationManager, csrfTokenRepository,
dataSource, passwordEncoder, openIdAuthenticationManager, userRepository, authorityRepository,
userOrganizationRepository, organizationRepository);
}
@Override
public PropertySource<?> locate(Environment environment) {
if (this.name != null) {
then(this.name)
.isEqualTo(environment.getProperty("spring.application.name"));
}
if (this.fail) {
throw new RuntimeException("Planned");
}
CompositePropertySource compositePropertySource = new CompositePropertySource(
"listTestBootstrap");
compositePropertySource.addFirstPropertySource(
new MapPropertySource("testBootstrap1", MAP1));
compositePropertySource.addFirstPropertySource(
new MapPropertySource("testBootstrap2", MAP2));
return compositePropertySource;
}
/**
* Main method, used to run the application.
*
* @param args the command line arguments
* @throws UnknownHostException if the local host name could not be resolved into an address
*/
public static void main(String[] args) throws UnknownHostException {
SpringApplication app = new SpringApplication(BaeldungApp.class);
DefaultProfileUtil.addDefaultProfile(app);
Environment env = app.run(args).getEnvironment();
String protocol = "http";
if (env.getProperty("server.ssl.key-store") != null) {
protocol = "https";
}
log.info("\n----------------------------------------------------------\n\t" +
"Application '{}' is running! Access URLs:\n\t" +
"Local: \t\t{}://localhost:{}\n\t" +
"External: \t{}://{}:{}\n\t" +
"Profile(s): \t{}\n----------------------------------------------------------",
env.getProperty("spring.application.name"),
protocol,
env.getProperty("server.port"),
protocol,
InetAddress.getLocalHost().getHostAddress(),
env.getProperty("server.port"),
env.getActiveProfiles());
}
/**
* test logging.config.{space id} config
* @throws IOException
*/
@Test
public void testLogConfig() throws IOException {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put(Constants.LOG_CONFIG_PREFIX + TEST_SPACE, "logback-test-conf.xml");
SpringApplication springApplication = new SpringApplication(EmptyConfig.class);
springApplication.setDefaultProperties(properties);
ConfigurableApplicationContext applicationContext = springApplication.run(new String[] {});
Environment environment = applicationContext.getEnvironment();
File logFile = getLogbackDefaultFile(environment);
FileUtils.write(logFile, StringUtil.EMPTY_STRING,
environment.getProperty(Constants.LOG_ENCODING_PROP_KEY));
logger.info("info level");
List<String> contents = FileUtils.readLines(logFile,
environment.getProperty(Constants.LOG_ENCODING_PROP_KEY));
Assert.assertEquals(1, contents.size());
Assert.assertTrue(contents.get(0).contains("logback-test-conf"));
LogEnvUtils.processGlobalSystemLogProperties().remove(
Constants.LOG_CONFIG_PREFIX + TEST_SPACE);
}
/**
* match [motan.basicservice.exportPort, motan.basicservice.export] config property
*
* @see org.springframework.context.annotation.Condition#matches(org.springframework.context.annotation.ConditionContext, org.springframework.core.type.AnnotatedTypeMetadata)
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
Environment env = context.getEnvironment();
return (!StringUtils.isEmpty(env.getProperty("motan.basicservice.exportPort"))
|| !StringUtils.isEmpty(env.getProperty("motan.basicservice.export")));
}
private Integer initPlatform(Environment environment, Platform platform) {
String propetyKey = ROOT_VOLUME_SIZE_PROPERTY_PREFIX + platform.value();
if (!environment.containsProperty(propetyKey)) {
LOGGER.debug("{} property is not set. Defaulting its value to 50.", propetyKey);
}
return Integer.valueOf(environment.getProperty(propetyKey, DEFAULT_ROOT_VOLUME_SIZE.toString()));
}
@Override
public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) {
for (String line : BANNER) {
out.println(AnsiOutput.toString(BRIGHT_BLUE, line));
}
String version = Banner.class.getPackage().getImplementationVersion();
version = (version == null ? "" : " (v" + version + ")...");
out.println(AnsiOutput.toString(BRIGHT_YELLOW, SPRING_BOOT, version));
out.println();
}
public static void setDefaultConstants(Environment env, Map<String, Object> defaultConstants) {
// if jndi is set, everything datasource-related is ignored
if (StringUtils.isBlank(env.getProperty(KEY_DATABASE_URL))) {
defaultConstants.put(KEY_DATABASE_URL, getDefaultJDBCUrl());
}
if (StringUtils.isBlank(env.getProperty(KEY_DATABASE_USERNAME))) {
defaultConstants.put(KEY_DATABASE_USERNAME, getDefaultJDBCUsername());
}
if (StringUtils.isBlank(env.getProperty(KEY_DATABASE_PASSWORD))) {
defaultConstants.put(KEY_DATABASE_PASSWORD, getDefaultJDBCPassword());
}
if (StringUtils.isBlank(env.getProperty(KEY_DATABASE_MIGRATION_ROLLBACK_FILE))) {
defaultConstants.put(
KEY_DATABASE_MIGRATION_ROLLBACK_FILE,
getAirsonicHome().toAbsolutePath().resolve("rollback.sql").toFile());
}
if (StringUtils.isBlank(env.getProperty(KEY_DATABASE_MIGRATION_PARAMETER_MYSQL_VARCHAR_MAXLENGTH))) {
defaultConstants.put(
KEY_DATABASE_MIGRATION_PARAMETER_MYSQL_VARCHAR_MAXLENGTH,
DEFAULT_DATABASE_MIGRATION_PARAMETER_MYSQL_VARCHAR_MAXLENGTH.toString());
}
if (StringUtils.isBlank(env.getProperty(KEY_DATABASE_MIGRATION_PARAMETER_USERTABLE_QUOTE))) {
defaultConstants.put(
KEY_DATABASE_MIGRATION_PARAMETER_USERTABLE_QUOTE,
DEFAULT_DATABASE_MIGRATION_PARAMETER_USERTABLE_QUOTE);
}
if (StringUtils.isBlank(env.getProperty(KEY_DATABASE_MIGRATION_PARAMETER_DEFAULT_MUSIC_FOLDER))) {
defaultConstants.put(KEY_DATABASE_MIGRATION_PARAMETER_DEFAULT_MUSIC_FOLDER, Util.getDefaultMusicFolder());
}
}
private synchronized void initializeIfNecessary() {
if (this.loadBalancer == null) {
Environment environment = CompensableBeanRegistry.getInstance().getEnvironment();
String loadBalanceKey = environment.getProperty(CONSTANT_LOADBALANCE_KEY, "default");
ExtensionLoader<ILoadBalancer> extensionLoader = ExtensionLoader.getExtensionLoader(ILoadBalancer.class);
this.loadBalancer = extensionLoader.getExtension(loadBalanceKey);
}
}
public static void main(String[] args) {
new SpringApplicationBuilder(DubboRegistryZooKeeperProviderBootstrap.class)
.listeners((ApplicationListener<ApplicationEnvironmentPreparedEvent>) event -> {
Environment environment = event.getEnvironment();
int port = environment.getProperty("embedded.zookeeper.port", int.class);
new EmbeddedZooKeeper(port, false).start();
})
.run(args);
}
/**
* {@inheritDoc}
* <p>The parent {@linkplain ApplicationContext#getEnvironment() environment} is
* {@linkplain ConfigurableEnvironment#merge(ConfigurableEnvironment) merged} with
* this (child) application context environment if the parent is non-{@code null} and
* its environment is an instance of {@link ConfigurableEnvironment}.
* @see ConfigurableEnvironment#merge(ConfigurableEnvironment)
*/
@Override
public void setParent(ApplicationContext parent) {
this.parent = parent;
if (parent != null) {
Environment parentEnvironment = parent.getEnvironment();
if (parentEnvironment instanceof ConfigurableEnvironment) {
getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
}
}
}
public DefaultLazyPropertyResolver(EncryptablePropertyDetector propertyDetector, StringEncryptor encryptor, String customResolverBeanName, boolean isCustom, BeanFactory bf, Environment environment) {
singleton = new Singleton<>(() ->
Optional.of(customResolverBeanName)
.filter(bf::containsBean)
.map(name -> (EncryptablePropertyResolver) bf.getBean(name))
.map(tap(bean -> log.info("Found Custom Resolver Bean {} with name: {}", bean, customResolverBeanName)))
.orElseGet(() -> {
if (isCustom) {
throw new IllegalStateException(String.format("Property Resolver custom Bean not found with name '%s'", customResolverBeanName));
}
log.info("Property Resolver custom Bean not found with name '{}'. Initializing Default Property Resolver", customResolverBeanName);
return createDefault(propertyDetector, encryptor, environment);
}));
}
@Bean
public Properties hibernateProperties() {
return new Properties() {
{
setProperty(org.hibernate.cfg.Environment.DIALECT, environment.getProperty(org.hibernate.cfg.Environment.DIALECT, HSQLDialect.class.getName()));
setProperty(org.hibernate.cfg.Environment.HBM2DDL_AUTO, environment.getProperty(org.hibernate.cfg.Environment.HBM2DDL_AUTO));
setProperty(org.hibernate.cfg.Environment.ENABLE_LAZY_LOAD_NO_TRANS, environment.getProperty(org.hibernate.cfg.Environment.ENABLE_LAZY_LOAD_NO_TRANS, "true"));
}
};
}
public ConfigClientProperties(Environment environment) {
String[] profiles = environment.getActiveProfiles();
if (profiles.length == 0) {
profiles = environment.getDefaultProfiles();
}
this.setProfile(StringUtils.arrayToCommaDelimitedString(profiles));
}
/**
* @param properties consul discovery properties
* @param env Spring environment
* @return the app name, currently the spring.application.name property
*/
public static String getAppName(ConsulDiscoveryProperties properties,
Environment env) {
final String appName = properties.getServiceName();
if (StringUtils.hasText(appName)) {
return appName;
}
return env.getProperty("spring.application.name", "application");
}
@Async
@Order
@EventListener(WebServerInitializedEvent.class)
public void afterStart(WebServerInitializedEvent event) {
Environment environment = event.getApplicationContext().getEnvironment();
String appName = environment.getProperty("spring.application.name").toUpperCase();
int localPort = event.getWebServer().getPort();
String profile = StringUtils.arrayToCommaDelimitedString(environment.getActiveProfiles());
log.info("---[{}]---启动完成，当前使用的端口:[{}]，环境变量:[{}]---", appName, localPort, profile);
}
@Override
public String[] selectImports(AnnotationMetadata metadata) {
String[] imports = super.selectImports(metadata);
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
metadata.getAnnotationAttributes(getAnnotationClass().getName(), true));
boolean autoRegister = attributes.getBoolean("autoRegister");
if (autoRegister) {
List<String> importsList = new ArrayList<>(Arrays.asList(imports));
importsList.add(
"org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration");
imports = importsList.toArray(new String[0]);
}
else {
Environment env = getEnvironment();
if (ConfigurableEnvironment.class.isInstance(env)) {
ConfigurableEnvironment configEnv = (ConfigurableEnvironment) env;
LinkedHashMap<String, Object> map = new LinkedHashMap<>();
map.put("spring.cloud.service-registry.auto-registration.enabled", false);
MapPropertySource propertySource = new MapPropertySource(
"springCloudDiscoveryClient", map);
configEnv.getPropertySources().addLast(propertySource);
}
}
return imports;
}
/**
* Provide a lazy {@link S3ClientFactory} instance if one is needed by the system.
*
* @param awsCredentialsProvider The {@link AWSCredentialsProvider} to use
* @param awsRegionProvider The {@link AwsRegionProvider} to use
* @param environment The Spring application {@link Environment} to bind properties from
* @return A {@link S3ClientFactory} instance
*/
@Bean
@ConditionalOnMissingBean(S3ClientFactory.class)
public S3ClientFactory s3ClientFactory(
final AWSCredentialsProvider awsCredentialsProvider,
final AwsRegionProvider awsRegionProvider,
final Environment environment
) {
return new S3ClientFactory(awsCredentialsProvider, awsRegionProvider, environment);
}
/**
* Get the Environment from the given registry if possible, otherwise return a new
* StandardEnvironment.
*/
private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry instanceof EnvironmentCapable) {
return ((EnvironmentCapable) registry).getEnvironment();
}
return new StandardEnvironment();
}
@Test
public void simpleService() {
mockVcapServices(readTestDataFile("test-credhub-service.json"));
Environment environment = getEnvironment();
assertThat(environment.getProperty("some.external.service.password")).isEqualTo("p4ssw0rd");
}
public DefaultRootVolumeSizeProvider(CloudPlatformConnectors cloudPlatformConnectors, Environment environment) {
PlatformVariants platformVariants = cloudPlatformConnectors.getPlatformVariants();
platformVolumeSizeMap = Collections.unmodifiableMap(
platformVariants.getDefaultVariants().keySet()
.stream()
.collect(Collectors.toMap(StringType::value, p -> initPlatform(environment, p)))
);
}
/**
* Create a new {@link ConfigurationClassParser} instance that will be used
* to populate the set of configuration classes.
*/
public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader,
BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {
this.metadataReaderFactory = metadataReaderFactory;
this.problemReporter = problemReporter;
this.environment = environment;
this.resourceLoader = resourceLoader;
this.registry = registry;
this.componentScanParser = new ComponentScanAnnotationParser(
environment, resourceLoader, componentScanBeanNameGenerator, registry);
this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
}
@Bean
public RequestBuilder simpleRequestBuilder(Environment environment) {
SimpleRequestBuilder builder = new SimpleRequestBuilder(environment);
if (this.props.getSink().getUrl() != null) {
builder.setTemplateUrl(this.props.getSink().getUrl());
}
builder.setHeaders(this.props.getSink().getHeaders());
return builder;
}
private void setDubboApplicationNameProperty(Environment environment, Map<String, Object> defaultProperties) {
String springApplicationName = environment.getProperty(SPRING_APPLICATION_NAME_PROPERTY);
if (StringUtils.hasLength(springApplicationName)
&& !environment.containsProperty(DUBBO_APPLICATION_NAME_PROPERTY)) {
defaultProperties.put(DUBBO_APPLICATION_NAME_PROPERTY, springApplicationName);
}
}
public AutoUpdateConfigChangeListener(Environment environment, ConfigurableListableBeanFactory beanFactory){
this.typeConverterHasConvertIfNecessaryWithFieldParameter = testTypeConverterHasConvertIfNecessaryWithFieldParameter();
this.beanFactory = beanFactory;
this.typeConverter = this.beanFactory.getTypeConverter();
this.environment = environment;
this.placeholderHelper = SpringInjector.getInstance(PlaceholderHelper.class);
this.springValueRegistry = SpringInjector.getInstance(SpringValueRegistry.class);
this.gson = new Gson();
}
private Environment configureExport(Environment mockEnvironment, boolean enabled) {
doReturn(enabled).when(mockEnvironment)
.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME),
eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED));
return mockEnvironment;
}
private static void logApplicationStartup(Environment env) {
String protocol = "http";
if (env.getProperty("server.ssl.key-store") != null) {
protocol = "https";
}
String serverPort = env.getProperty("server.port");
String contextPath = env.getProperty("server.servlet.context-path");
if (StringUtils.isBlank(contextPath)) {
contextPath = "/";
}
String hostAddress = "localhost";
try {
hostAddress = InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
log.warn("The host name could not be determined, using `localhost` as fallback");
}
log.info("\n----------------------------------------------------------\n\t" +
"Application '{}' is running! Access URLs:\n\t" +
"Local: \t\t{}://localhost:{}{}\n\t" +
"External: \t{}://{}:{}{}\n\t" +
"Profile(s): \t{}\n----------------------------------------------------------",
env.getProperty("spring.application.name"),
protocol,
serverPort,
contextPath,
protocol,
hostAddress,
serverPort,
contextPath,
env.getActiveProfiles());
}