org.springframework.cloud.config.client.ConfigServicePropertySourceLocator Java Examples

@Override
public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
    RestTemplate configServerClient = new RestTemplate();
    MockRestServiceServer mockConfigServer = MockRestServiceServer.bindTo(configServerClient).build();
    configServerClient.getInterceptors().add(0, new LoggingHttpInterceptor());
    // {@code putIfAbsent} here is important as we do not want to override values when context is refreshed
    ConfigServerValues configServerValues = new ConfigServerValues(mockConfigServer)
        .putIfAbsent(ConfigClient.USER_ROLE_KEY, "admin");

    ConfigurableListableBeanFactory beanFactory = configurableApplicationContext.getBeanFactory();

    try {
        beanFactory
            .getBean(ConfigServicePropertySourceLocator.class)
            .setRestTemplate(configServerClient);

        beanFactory.registerSingleton("configServerClient", configServerClient);
        beanFactory.registerSingleton("mockConfigServer", mockConfigServer);
        beanFactory.registerSingleton("configServerValues", configServerValues);

    } catch (NoSuchBeanDefinitionException e) {
        // too soon, ConfigServicePropertySourceLocator is not defined
    }
}
 

@Test
public void configServicePropertySourceLocatorHasOAuth2AuthorizedClientHttpRequestInterceptor() throws Exception {
	this.contextRunner.withPropertyValues("spring.cloud.config.client.oauth2.client-id=" + CLIENT_ID,
			"spring.cloud.config.client.oauth2.client-secret=" + CLIENT_SECRET,
			"spring.cloud.config.client.oauth2.access-token-uri=" + TOKEN_URI).run(context -> {
				assertThat(context).hasSingleBean(ConfigServicePropertySourceLocator.class);
				ConfigServicePropertySourceLocator locator = context
						.getBean(ConfigServicePropertySourceLocator.class);
				RestTemplate restTemplate = (RestTemplate) ReflectionTestUtils.getField(locator, "restTemplate");
				assertThat(restTemplate).isNotNull();
				assertThat(restTemplate.getInterceptors()).hasSize(1);
				assertThat(restTemplate.getInterceptors().get(0))
						.isInstanceOf(OAuth2AuthorizedClientHttpRequestInterceptor.class);
				OAuth2AuthorizedClientHttpRequestInterceptor interceptor = (OAuth2AuthorizedClientHttpRequestInterceptor) restTemplate
						.getInterceptors().get(0);
				ClientRegistration clientRegistration = interceptor.clientRegistration;
				assertThat(clientRegistration.getClientId()).isEqualTo(CLIENT_ID);
				assertThat(clientRegistration.getClientSecret()).isEqualTo(CLIENT_SECRET);
				assertThat(clientRegistration.getProviderDetails().getTokenUri()).isEqualTo(TOKEN_URI);
				assertThat(clientRegistration.getAuthorizationGrantType())
						.isEqualTo(AuthorizationGrantType.CLIENT_CREDENTIALS);
			});
}
 

@Bean
@ConditionalOnMissingBean
public PeriodCheckRefreshEventEmitter refreshEventEmitter(ConfigServicePropertySourceLocator locator,
                                                          ContextRefresher refresher, Environment environment) {
    return new PeriodCheckRefreshEventEmitter((MultiModuleConfigServicePropertySourceLocator) locator,
            refresher, environment);
}
 

@Bean
@ConditionalOnMissingBean(ConfigServicePropertySourceLocator.class)
@ConditionalOnProperty(value = "spring.cloud.config.enabled", matchIfMissing = true)
public ConfigServicePropertySourceLocator configServicePropertySource(
        ConfigClientProperties client, ObjectProvider<ConfigEnvironmentPreprocessor> preprocessorObjectProvider) {
    MultiModuleConfigServicePropertySourceLocator l = new MultiModuleConfigServicePropertySourceLocator(client);
    preprocessorObjectProvider.ifAvailable(l::setPreprocessor);
    return l;
}
 

@Bean
@ConditionalOnProperty(value = "spring.cloud.config.enabled", matchIfMissing = true)
public ConfigServicePropertySourceLocator configServicePropertySource(ConfigClientProperties properties) {
	ConfigServicePropertySourceLocator locator = new ConfigServicePropertySourceLocator(properties);
	RestTemplate restTemplate = getSecureRestTemplate(properties);
	restTemplate.setMessageConverters(Arrays.asList(new ExtJackson2HttpMessageConverter()));
	locator.setRestTemplate(restTemplate);
	return locator;
}
 

@Autowired
public ConfigClientOAuth2Configurer(ConfigServicePropertySourceLocator locator, ConfigClientOAuth2ResourceDetails configClientOAuth2ResourceDetails) {
	Assert.notNull(locator, "Error injecting ConfigServicePropertySourceLocator, this can occur" +
			"using self signed certificates in Cloud Foundry without setting the TRUST_CERTS environment variable");
	this.locator = locator;
	this.configClientOAuth2ResourceDetails = configClientOAuth2ResourceDetails;
}
 

public ConfigClientOAuth2BootstrapConfiguration(ConfigServicePropertySourceLocator locator,
		ConfigClientOAuth2Properties configClientOAuth2Properties) {
	Assert.notNull(locator, "Error injecting ConfigServicePropertySourceLocator, this can occur"
			+ "using self signed certificates in Cloud Foundry without setting the TRUST_CERTS environment variable");
	this.locator = locator;
	this.configClientOAuth2Properties = configClientOAuth2Properties;
}
 

@Test
public void configServicePropertySourceLocatorIsUnchanged() throws Exception {
	this.contextRunner.run(context -> {
		assertThat(context).hasSingleBean(ConfigServicePropertySourceLocator.class);
		ConfigServicePropertySourceLocator locator = context.getBean(ConfigServicePropertySourceLocator.class);
		Field restTemplateField = ReflectionUtils.findField(ConfigServicePropertySourceLocator.class,
				"restTemplate");
		restTemplateField.setAccessible(true);
		assertThat(ReflectionUtils.getField(restTemplateField, locator)).isNull();
	});
}
 

public RefreshEventEmitter(ConfigServicePropertySourceLocator locator, ContextRefresher refresher, Environment environment) {
    this.locator = locator;
    this.refresher = refresher;
    this.environment = environment;
}
 

ConfigServicePropertySourceLocator getLocator() {
    return locator;
}
 

@Test
public void configClientEnabled() throws Exception {
	assertThat(BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.context,
			ConfigServicePropertySourceLocator.class).length).isEqualTo(1);
}
 

@Test
public void configClientDisabled() throws Exception {
	assertThat(BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.context,
			ConfigServicePropertySourceLocator.class).length).isEqualTo(0);
}