Skip to content

S
spring-boot
Commit 36b63eec authored by Stephane Nicoll's avatar Stephane Nicoll
Browse files
Options

Polish "Expose Spring Integration global properties" 

See gh-25377
parent e2df9bce
Hide whitespace changes
Inline Side-by-side
Showing with 316 additions and 225 deletions
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfiguration.java
View file @ 36b63eec
......@@ -36,6 +36,7 @@ import org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration;
import org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration;
import org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.context.properties.PropertyMapper;
import org.springframework.boot.task.TaskSchedulerBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
......@@ -85,15 +86,21 @@ public class IntegrationAutoConfiguration {
public static org.springframework.integration.context.IntegrationProperties integrationGlobalProperties(
IntegrationProperties properties) {
org.springframework.integration.context.IntegrationProperties integrationProperties = new org.springframework.integration.context.IntegrationProperties();
integrationProperties.setChannelsAutoCreate(properties.getChannels().isAutoCreate());
integrationProperties.setChannelsMaxUnicastSubscribers(properties.getChannels().getMaxUnicastSubscribers());
integrationProperties.setChannelsMaxBroadcastSubscribers(properties.getChannels().getMaxBroadcastSubscribers());
integrationProperties.setErrorChannelRequireSubscribers(properties.getChannels().isErrorRequireSubscribers());
integrationProperties.setErrorChannelIgnoreFailures(properties.getChannels().isErrorIgnoreFailures());
integrationProperties
.setMessagingTemplateThrowExceptionOnLateReply(properties.getEndpoints().isThrowExceptionOnLateReply());
integrationProperties.setReadOnlyHeaders(properties.getEndpoints().getReadOnlyHeaders());
integrationProperties.setNoAutoStartupEndpoints(properties.getEndpoints().getNoAutoStartup());
PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
map.from(properties.getChannel().isAutoCreate()).to(integrationProperties::setChannelsAutoCreate);
map.from(properties.getChannel().getMaxUnicastSubscribers())
.to(integrationProperties::setChannelsMaxUnicastSubscribers);
map.from(properties.getChannel().getMaxBroadcastSubscribers())
.to(integrationProperties::setChannelsMaxBroadcastSubscribers);
map.from(properties.getError().isRequireSubscribers())
.to(integrationProperties::setErrorChannelRequireSubscribers);
map.from(properties.getError().isIgnoreFailures()).to(integrationProperties::setErrorChannelIgnoreFailures);
map.from(properties.getEndpoint().isThrowExceptionOnLateReply())
.to(integrationProperties::setMessagingTemplateThrowExceptionOnLateReply);
map.from(properties.getEndpoint().getReadOnlyHeaders()).as(StringUtils::toStringArray)
.to(integrationProperties::setReadOnlyHeaders);
map.from(properties.getEndpoint().getNoAutoStartup()).as(StringUtils::toStringArray)
.to(integrationProperties::setNoAutoStartupEndpoints);
return integrationProperties;
}
......
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/integration/IntegrationProperties.java
View file @ 36b63eec
/*
* Copyright 2012-2020 the original author or authors.
* Copyright 2012-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
......@@ -17,6 +17,8 @@
package org.springframework.boot.autoconfigure.integration;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceInitializationMode;
......@@ -32,20 +34,26 @@ import org.springframework.boot.jdbc.DataSourceInitializationMode;
@ConfigurationProperties(prefix = "spring.integration")
public class IntegrationProperties {
private final Channels channels = new Channels();
private final Channel channel = new Channel();
private final Endpoints endpoints = new Endpoints();
private final Endpoint endpoint = new Endpoint();
private final Error error = new Error();
private final Jdbc jdbc = new Jdbc();
private final RSocket rsocket = new RSocket();
public Channels getChannels() {
return this.channels;
public Channel getChannel() {
return this.channel;
}
public Endpoint getEndpoint() {
return this.endpoint;
}
public Endpoints getEndpoints() {
return this.endpoints;
public Error getError() {
return this.error;
}
public Jdbc getJdbc() {
......@@ -56,33 +64,24 @@ public class IntegrationProperties {
return this.rsocket;
}
public static class Channels {
public static class Channel {
/**
* Whether to create input channels when no respective beans.
* Whether to create input channels if necessary.
*/
private boolean autoCreate = true;
/**
* Default number of max subscribers on unicasting channels.
* Default number of subscribers allowed on, for example, a 'DirectChannel'.
*/
private int maxUnicastSubscribers = Integer.MAX_VALUE;
/**
* Default number of max subscribers on broadcasting channels.
* Default number of subscribers allowed on, for example, a
* 'PublishSubscribeChannel'.
*/
private int maxBroadcastSubscribers = Integer.MAX_VALUE;
/**
* Require subscribers flag for global 'errorChannel'.
*/
private boolean errorRequireSubscribers = true;
/**
* Ignore failures flag for global 'errorChannel'.
*/
private boolean errorIgnoreFailures = true;
public void setAutoCreate(boolean autoCreate) {
this.autoCreate = autoCreate;
}
......@@ -107,40 +106,27 @@ public class IntegrationProperties {
return this.maxBroadcastSubscribers;
}
public void setErrorRequireSubscribers(boolean errorRequireSubscribers) {
this.errorRequireSubscribers = errorRequireSubscribers;
}
public boolean isErrorRequireSubscribers() {
return this.errorRequireSubscribers;
}
public void setErrorIgnoreFailures(boolean errorIgnoreFailures) {
this.errorIgnoreFailures = errorIgnoreFailures;
}
public boolean isErrorIgnoreFailures() {
return this.errorIgnoreFailures;
}
}
public static class Endpoints {
public static class Endpoint {
/**
* Whether throw an exception on late reply for gateways.
* Whether to throw an exception when a reply is not expected anymore by a
* gateway.
*/
private boolean throwExceptionOnLateReply = false;
/**
* Ignored headers during message building.
* A comma-separated list of message header names that should not be populated
* into Message instances during a header copying operation.
*/
private String[] readOnlyHeaders = {};
private List<String> readOnlyHeaders = new ArrayList<>();
/**
* Spring Integration endpoints do not start automatically.
* A comma-separated list of endpoint bean names patterns that should not be
* started automatically during application startup.
*/
private String[] noAutoStartup = {};
private List<String> noAutoStartup = new ArrayList<>();
public void setThrowExceptionOnLateReply(boolean throwExceptionOnLateReply) {
this.throwExceptionOnLateReply = throwExceptionOnLateReply;
......@@ -150,20 +136,52 @@ public class IntegrationProperties {
return this.throwExceptionOnLateReply;
}
public void setReadOnlyHeaders(String[] readOnlyHeaders) {
public List<String> getReadOnlyHeaders() {
return this.readOnlyHeaders;
}
public void setReadOnlyHeaders(List<String> readOnlyHeaders) {
this.readOnlyHeaders = readOnlyHeaders;
}
public String[] getReadOnlyHeaders() {
return this.readOnlyHeaders;
public List<String> getNoAutoStartup() {
return this.noAutoStartup;
}
public void setNoAutoStartup(String[] noAutoStartup) {
public void setNoAutoStartup(List<String> noAutoStartup) {
this.noAutoStartup = noAutoStartup;
}
public String[] getNoAutoStartup() {
return this.noAutoStartup;
}
public static class Error {
/**
* Whether to not silently ignore messages on the global 'errorChannel' when they
* are no subscribers.
*/
private boolean requireSubscribers = true;
/**
* Whether to ignore failures for one or more of the handlers of the global
* 'errorChannel'.
*/
private boolean ignoreFailures = true;
public boolean isRequireSubscribers() {
return this.requireSubscribers;
}
public void setRequireSubscribers(boolean requireSubscribers) {
this.requireSubscribers = requireSubscribers;
}
public boolean isIgnoreFailures() {
return this.ignoreFailures;
}
public void setIgnoreFailures(boolean ignoreFailures) {
this.ignoreFailures = ignoreFailures;
}
}
......
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/integration/IntegrationEnvironmentPostProcessor.java → spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/integration/IntegrationPropertiesEnvironmentPostProcessor.java
View file @ 36b63eec
......@@ -16,8 +16,8 @@
package org.springframework.boot.autoconfigure.integration;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
......@@ -35,12 +35,13 @@ import org.springframework.core.io.Resource;
import org.springframework.integration.context.IntegrationProperties;
/**
* The {@link EnvironmentPostProcessor} for Spring Integration.
* An {@link EnvironmentPostProcessor} that maps the configuration of
* {@code META-INF/spring.integration.properties} in the environment.
*
* @author Artem Bilan
* @since 2.5
* @author Stephane Nicoll
*/
public class IntegrationEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
class IntegrationPropertiesEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
@Override
public int getOrder() {
......@@ -49,65 +50,62 @@ public class IntegrationEnvironmentPostProcessor implements EnvironmentPostProce
@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
registerIntegrationPropertiesFileSource(environment);
Resource resource = new ClassPathResource("META-INF/spring.integration.properties");
if (resource.exists()) {
registerIntegrationPropertiesPropertySource(environment, resource);
}
}
private static void registerIntegrationPropertiesFileSource(ConfigurableEnvironment environment) {
Resource integrationPropertiesResource = new ClassPathResource("META-INF/spring.integration.properties");
protected void registerIntegrationPropertiesPropertySource(ConfigurableEnvironment environment, Resource resource) {
PropertiesPropertySourceLoader loader = new PropertiesPropertySourceLoader();
try {
OriginTrackedMapPropertySource propertyFileSource = (OriginTrackedMapPropertySource) loader
.load("integration-properties-file", integrationPropertiesResource).get(0);
environment.getPropertySources().addLast(new IntegrationPropertySource(propertyFileSource));
}
catch (FileNotFoundException ex) {
// Ignore when no META-INF/spring.integration.properties file in classpath
.load("META-INF/spring.integration.properties", resource).get(0);
environment.getPropertySources().addLast(new IntegrationPropertiesPropertySource(propertyFileSource));
}
catch (IOException ex) {
throw new IllegalStateException(
"Failed to load integration properties from " + integrationPropertiesResource, ex);
throw new IllegalStateException("Failed to load integration properties from " + resource, ex);
}
}
private static final class IntegrationPropertySource extends PropertySource<Map<String, Object>>
private static final class IntegrationPropertiesPropertySource extends PropertySource<Map<String, Object>>
implements OriginLookup<String> {
private static final String PREFIX = "spring.integration.";
private static final Map<String, String> KEYS_MAPPING = new HashMap<>();
private static final Map<String, String> KEYS_MAPPING;
static {
KEYS_MAPPING.put(PREFIX + "channels.auto-create", IntegrationProperties.CHANNELS_AUTOCREATE);
KEYS_MAPPING.put(PREFIX + "channels.max-unicast-subscribers",
Map<String, String> mappings = new HashMap<>();
mappings.put(PREFIX + "channel.auto-create", IntegrationProperties.CHANNELS_AUTOCREATE);
mappings.put(PREFIX + "channel.max-unicast-subscribers",
IntegrationProperties.CHANNELS_MAX_UNICAST_SUBSCRIBERS);
KEYS_MAPPING.put(PREFIX + "channels.max-broadcast-subscribers",
mappings.put(PREFIX + "channel.max-broadcast-subscribers",
IntegrationProperties.CHANNELS_MAX_BROADCAST_SUBSCRIBERS);
KEYS_MAPPING.put(PREFIX + "channels.error-require-subscribers",
IntegrationProperties.ERROR_CHANNEL_REQUIRE_SUBSCRIBERS);
KEYS_MAPPING.put(PREFIX + "channels.error-ignore-failures",
IntegrationProperties.ERROR_CHANNEL_IGNORE_FAILURES);
KEYS_MAPPING.put(PREFIX + "endpoints.throw-exception-on-late-reply",
mappings.put(PREFIX + "error.require-subscribers", IntegrationProperties.ERROR_CHANNEL_REQUIRE_SUBSCRIBERS);
mappings.put(PREFIX + "error.ignore-failures", IntegrationProperties.ERROR_CHANNEL_IGNORE_FAILURES);
mappings.put(PREFIX + "endpoint.throw-exception-on-late-reply",
IntegrationProperties.THROW_EXCEPTION_ON_LATE_REPLY);
KEYS_MAPPING.put(PREFIX + "endpoints.read-only-headers", IntegrationProperties.READ_ONLY_HEADERS);
KEYS_MAPPING.put(PREFIX + "endpoints.no-auto-startup", IntegrationProperties.ENDPOINTS_NO_AUTO_STARTUP);
mappings.put(PREFIX + "endpoint.read-only-headers", IntegrationProperties.READ_ONLY_HEADERS);
mappings.put(PREFIX + "endpoint.no-auto-startup", IntegrationProperties.ENDPOINTS_NO_AUTO_STARTUP);
KEYS_MAPPING = Collections.unmodifiableMap(mappings);
}
private final OriginTrackedMapPropertySource origin;
private final OriginTrackedMapPropertySource delegate;
IntegrationPropertySource(OriginTrackedMapPropertySource origin) {
super("original-integration-properties", origin.getSource());
this.origin = origin;
IntegrationPropertiesPropertySource(OriginTrackedMapPropertySource delegate) {
super("META-INF/spring.integration.properties", delegate.getSource());
this.delegate = delegate;
}
@Override
public Object getProperty(String name) {
return this.origin.getProperty(KEYS_MAPPING.get(name));
return this.delegate.getProperty(KEYS_MAPPING.get(name));
}
@Override
public Origin getOrigin(String key) {
return this.origin.getOrigin(KEYS_MAPPING.get(name));
return this.delegate.getOrigin(KEYS_MAPPING.get(key));
}
}
......
spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories
View file @ 36b63eec
......@@ -9,7 +9,7 @@ org.springframework.boot.autoconfigure.BackgroundPreinitializer
# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.autoconfigure.integration.IntegrationEnvironmentPostProcessor
org.springframework.boot.autoconfigure.integration.IntegrationPropertiesEnvironmentPostProcessor
# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
......
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfigurationTests.java
View file @ 36b63eec
......@@ -16,15 +16,10 @@
package org.springframework.boot.autoconfigure.integration;
import java.io.File;
import java.util.Arrays;
import java.util.List;
import javax.management.MBeanServer;
import io.rsocket.transport.ClientTransport;
import io.rsocket.transport.netty.client.TcpClientTransport;
import org.assertj.core.api.InstanceOfAssertFactories;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Mono;
......@@ -42,25 +37,16 @@ import org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfi
import org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration;
import org.springframework.boot.jdbc.DataSourceInitializationMode;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.annotation.MessagingGateway;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.PublishSubscribeChannel;
import org.springframework.integration.config.IntegrationManagementConfigurer;
import org.springframework.integration.context.IntegrationContextUtils;
import org.springframework.integration.core.MessageSource;
import org.springframework.integration.endpoint.EventDrivenConsumer;
import org.springframework.integration.endpoint.MessageProcessorMessageSource;
import org.springframework.integration.gateway.RequestReplyExchanger;
import org.springframework.integration.handler.LoggingHandler;
import org.springframework.integration.handler.MessageProcessor;
import org.springframework.integration.rsocket.ClientRSocketConnector;
import org.springframework.integration.rsocket.IntegrationRSocketEndpoint;
......@@ -266,111 +252,88 @@ class IntegrationAutoConfigurationTests {
@Test
void integrationGlobalPropertiesAutoConfigured() {
new ApplicationContextRunner(() -> {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.setResourceLoader(
new FilteringResourceLoader(new DefaultResourceLoader(), "META-INF/spring.integration.properties"));
return context;
}).withConfiguration(AutoConfigurations.of(JmxAutoConfiguration.class, IntegrationAutoConfiguration.class))
.withPropertyValues("spring.integration.channels.auto-create=false",
"spring.integration.channels.max-unicast-subscribers=2",
"spring.integration.channels.max-broadcast-subscribers=3",
"spring.integration.channels.error-require-subscribers=false",
"spring.integration.channels.error-ignore-failures=false",
"spring.integration.endpoints.throw-exception-on-late-reply=true",
"spring.integration.endpoints.read-only-headers=ignoredHeader",
"spring.integration.endpoints.no-auto-startup=notStartedEndpoint,_org.springframework.integration.errorLogger")
.withBean("testDirectChannel", DirectChannel.class)
.withInitializer((applicationContext) -> new IntegrationEnvironmentPostProcessor()
.postProcessEnvironment(applicationContext.getEnvironment(), null))
this.contextRunner.withPropertyValues("spring.integration.channel.auto-create=false",
"spring.integration.channel.max-unicast-subscribers=2",
"spring.integration.channel.max-broadcast-subscribers=3",
"spring.integration.error.require-subscribers=false", "spring.integration.error.ignore-failures=false",
"spring.integration.endpoint.throw-exception-on-late-reply=true",
"spring.integration.endpoint.read-only-headers=ignoredHeader",
"spring.integration.endpoint.no-auto-startup=notStartedEndpoint,_org.springframework.integration.errorLogger")
.run((context) -> {
assertThat(context)
.getBean(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME, PublishSubscribeChannel.class)
.hasFieldOrPropertyWithValue("requireSubscribers", false)
.hasFieldOrPropertyWithValue("ignoreFailures", false)
.hasFieldOrPropertyWithValue("maxSubscribers", 3);
assertThat(context).getBean("testDirectChannel", DirectChannel.class)
.hasFieldOrPropertyWithValue("maxSubscribers", 2);
LoggingHandler loggingHandler = context.getBean(LoggingHandler.class);
assertThat(loggingHandler)
.hasFieldOrPropertyWithValue("messageBuilderFactory.readOnlyHeaders",
new String[] { "ignoredHeader" })
.extracting("integrationProperties", InstanceOfAssertFactories.MAP)
.containsEntry(
org.springframework.integration.context.IntegrationProperties.THROW_EXCEPTION_ON_LATE_REPLY,
"true")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.ENDPOINTS_NO_AUTO_STARTUP,
"notStartedEndpoint,_org.springframework.integration.errorLogger");
assertThat(context)
.getBean(IntegrationContextUtils.ERROR_LOGGER_BEAN_NAME, EventDrivenConsumer.class)
.hasFieldOrPropertyWithValue("autoStartup", false);
.hasSingleBean(org.springframework.integration.context.IntegrationProperties.class);
org.springframework.integration.context.IntegrationProperties integrationProperties = context
.getBean(org.springframework.integration.context.IntegrationProperties.class);
assertThat(integrationProperties.isChannelsAutoCreate()).isFalse();
assertThat(integrationProperties.getChannelsMaxUnicastSubscribers()).isEqualTo(2);
assertThat(integrationProperties.getChannelsMaxBroadcastSubscribers()).isEqualTo(3);
assertThat(integrationProperties.isErrorChannelRequireSubscribers()).isFalse();
assertThat(integrationProperties.isErrorChannelIgnoreFailures()).isFalse();
assertThat(integrationProperties.isMessagingTemplateThrowExceptionOnLateReply()).isTrue();
assertThat(integrationProperties.getReadOnlyHeaders()).containsOnly("ignoredHeader");
assertThat(integrationProperties.getNoAutoStartupEndpoints()).containsOnly("notStartedEndpoint",
"_org.springframework.integration.errorLogger");
});
}
@Test
void integrationGlobalPropertiesUseConsistentDefault() {
org.springframework.integration.context.IntegrationProperties defaultIntegrationProperties = new org.springframework.integration.context.IntegrationProperties();
this.contextRunner.run((context) -> {
assertThat(context).hasSingleBean(org.springframework.integration.context.IntegrationProperties.class);
org.springframework.integration.context.IntegrationProperties integrationProperties = context
.getBean(org.springframework.integration.context.IntegrationProperties.class);
assertThat(integrationProperties.isChannelsAutoCreate())
.isEqualTo(defaultIntegrationProperties.isChannelsAutoCreate());
assertThat(integrationProperties.getChannelsMaxUnicastSubscribers())
.isEqualTo(defaultIntegrationProperties.getChannelsMaxBroadcastSubscribers());
assertThat(integrationProperties.getChannelsMaxBroadcastSubscribers())
.isEqualTo(defaultIntegrationProperties.getChannelsMaxBroadcastSubscribers());
assertThat(integrationProperties.isErrorChannelRequireSubscribers())
.isEqualTo(defaultIntegrationProperties.isErrorChannelIgnoreFailures());
assertThat(integrationProperties.isErrorChannelIgnoreFailures())
.isEqualTo(defaultIntegrationProperties.isErrorChannelIgnoreFailures());
assertThat(integrationProperties.isMessagingTemplateThrowExceptionOnLateReply())
.isEqualTo(defaultIntegrationProperties.isMessagingTemplateThrowExceptionOnLateReply());
assertThat(integrationProperties.getReadOnlyHeaders())
.isEqualTo(defaultIntegrationProperties.getReadOnlyHeaders());
assertThat(integrationProperties.getNoAutoStartupEndpoints())
.isEqualTo(defaultIntegrationProperties.getNoAutoStartupEndpoints());
});
}
@Test
void integrationGlobalPropertiesUserBeanOverridesAutoConfiguration() {
this.contextRunner.withPropertyValues("spring.integration.channels.auto-create=false",
"spring.integration.channels.max-unicast-subscribers=2",
"spring.integration.channels.max-broadcast-subscribers=3",
"spring.integration.channels.error-require-subscribers=false",
"spring.integration.channels.error-ignore-failures=false",
"spring.integration.endpoints.throw-exception-on-late-reply=true",
"spring.integration.endpoints.read-only-headers=ignoredHeader",
"spring.integration.endpoints.no-auto-startup=notStartedEndpoint,_org.springframework.integration.errorLogger")
org.springframework.integration.context.IntegrationProperties userIntegrationProperties = new org.springframework.integration.context.IntegrationProperties();
this.contextRunner.withPropertyValues()
.withBean(IntegrationContextUtils.INTEGRATION_GLOBAL_PROPERTIES_BEAN_NAME,
org.springframework.integration.context.IntegrationProperties.class, () -> {
org.springframework.integration.context.IntegrationProperties properties = new org.springframework.integration.context.IntegrationProperties();
properties.setChannelsMaxUnicastSubscribers(5);
return properties;
})
.withInitializer((applicationContext) -> new IntegrationEnvironmentPostProcessor()
.postProcessEnvironment(applicationContext.getEnvironment(), null))
.run((context) -> assertThat(context).getBean(LoggingHandler.class)
.extracting("integrationProperties", InstanceOfAssertFactories.MAP)
.containsEntry(
org.springframework.integration.context.IntegrationProperties.CHANNELS_AUTOCREATE,
"true")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.ERROR_CHANNEL_REQUIRE_SUBSCRIBERS,
"true")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.ERROR_CHANNEL_IGNORE_FAILURES,
"true")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.THROW_EXCEPTION_ON_LATE_REPLY,
"false")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.CHANNELS_MAX_UNICAST_SUBSCRIBERS,
"5")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.CHANNELS_MAX_BROADCAST_SUBSCRIBERS,
"2147483647")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.ENDPOINTS_NO_AUTO_STARTUP,
"")
.containsEntry(org.springframework.integration.context.IntegrationProperties.READ_ONLY_HEADERS,
""));
org.springframework.integration.context.IntegrationProperties.class,
() -> userIntegrationProperties)
.run((context) -> {
assertThat(context)
.hasSingleBean(org.springframework.integration.context.IntegrationProperties.class);
assertThat(context.getBean(org.springframework.integration.context.IntegrationProperties.class))
.isSameAs(userIntegrationProperties);
});
}
@Test
void integrationGlobalPropertiesFromSpringIntegrationPropertiesFile() {
// See META-INF/spring.integration.properties
this.contextRunner
.withPropertyValues("spring.integration.channels.auto-create=false",
"spring.integration.endpoints.read-only-headers=ignoredHeader")
.withInitializer((applicationContext) -> new IntegrationEnvironmentPostProcessor()
.withPropertyValues("spring.integration.channel.auto-create=false",
"spring.integration.endpoint.read-only-headers=ignoredHeader")
.withInitializer((applicationContext) -> new IntegrationPropertiesEnvironmentPostProcessor()
.postProcessEnvironment(applicationContext.getEnvironment(), null))
.run((context) -> assertThat(context).getBean(LoggingHandler.class)
.extracting("integrationProperties", InstanceOfAssertFactories.MAP)
.containsEntry(
org.springframework.integration.context.IntegrationProperties.CHANNELS_AUTOCREATE,
"false")
.containsEntry(org.springframework.integration.context.IntegrationProperties.READ_ONLY_HEADERS,
"ignoredHeader")
.containsEntry(
org.springframework.integration.context.IntegrationProperties.ENDPOINTS_NO_AUTO_STARTUP,
"testService*"));
.run((context) -> {
assertThat(context)
.hasSingleBean(org.springframework.integration.context.IntegrationProperties.class);
org.springframework.integration.context.IntegrationProperties integrationProperties = context
.getBean(org.springframework.integration.context.IntegrationProperties.class);
assertThat(integrationProperties.isChannelsAutoCreate()).isFalse();
assertThat(integrationProperties.getReadOnlyHeaders()).containsOnly("ignoredHeader");
// See META-INF/spring.integration.properties
assertThat(integrationProperties.getNoAutoStartupEndpoints()).containsOnly("testService*");
});
}
@Configuration(proxyBeanMethods = false)
......@@ -427,32 +390,4 @@ class IntegrationAutoConfigurationTests {
}
private static final class FilteringResourceLoader implements ResourceLoader {
private final ResourceLoader delegate;
private final List<String> resourcesToFilter;
FilteringResourceLoader(ResourceLoader delegate, String... resourcesToFilter) {
this.delegate = delegate;
this.resourcesToFilter = Arrays.asList(resourcesToFilter);
}
@Override
public Resource getResource(String location) {
if (!this.resourcesToFilter.contains(location)) {
return this.delegate.getResource(location);
}
else {
return new FileSystemResource(mock(File.class));
}
}
@Override
public ClassLoader getClassLoader() {
return this.delegate.getClassLoader();
}
}
}
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationPropertiesEnvironmentPostProcessorTests.java 0 → 100644
View file @ 36b63eec
/*
* Copyright 2012-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.autoconfigure.integration;
import java.io.FileNotFoundException;
import java.util.Collections;
import java.util.function.Consumer;
import org.junit.jupiter.api.Test;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.origin.Origin;
import org.springframework.boot.origin.OriginLookup;
import org.springframework.boot.origin.TextResourceOrigin;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
/**
* Tests for {@link IntegrationPropertiesEnvironmentPostProcessor}.
*
* @author Stephane Nicoll
*/
class IntegrationPropertiesEnvironmentPostProcessorTests {
@Test
void postProcessEnvironmentAddPropertySource() {
ConfigurableEnvironment environment = new StandardEnvironment();
new IntegrationPropertiesEnvironmentPostProcessor().postProcessEnvironment(environment,
mock(SpringApplication.class));
assertThat(environment.getPropertySources().contains("META-INF/spring.integration.properties")).isTrue();
assertThat(environment.getProperty("spring.integration.endpoint.no-auto-startup")).isEqualTo("testService*");
}
@Test
void postProcessEnvironmentAddPropertySourceLast() {
ConfigurableEnvironment environment = new StandardEnvironment();
environment.getPropertySources().addLast(new MapPropertySource("test",
Collections.singletonMap("spring.integration.endpoint.no-auto-startup", "another*")));
new IntegrationPropertiesEnvironmentPostProcessor().postProcessEnvironment(environment,
mock(SpringApplication.class));
assertThat(environment.getPropertySources().contains("META-INF/spring.integration.properties")).isTrue();
assertThat(environment.getProperty("spring.integration.endpoint.no-auto-startup")).isEqualTo("another*");
}
@Test
void registerIntegrationPropertiesPropertySourceWithUnknownResourceThrowsException() {
ConfigurableEnvironment environment = new StandardEnvironment();
ClassPathResource unknown = new ClassPathResource("does-not-exist.properties", getClass());
assertThatThrownBy(() -> new IntegrationPropertiesEnvironmentPostProcessor()
.registerIntegrationPropertiesPropertySource(environment, unknown))
.isInstanceOf(IllegalStateException.class).hasCauseInstanceOf(FileNotFoundException.class)
.hasMessageContaining(unknown.toString());
}
@Test
void registerIntegrationPropertiesPropertySourceWithResourceAddPropertySource() {
ConfigurableEnvironment environment = new StandardEnvironment();
new IntegrationPropertiesEnvironmentPostProcessor().registerIntegrationPropertiesPropertySource(environment,
new ClassPathResource("spring.integration.properties", getClass()));
assertThat(environment.getProperty("spring.integration.channel.auto-create", Boolean.class)).isFalse();
assertThat(environment.getProperty("spring.integration.channel.max-unicast-subscribers", Integer.class))
.isEqualTo(4);
assertThat(environment.getProperty("spring.integration.channel.max-broadcast-subscribers", Integer.class))
.isEqualTo(6);
assertThat(environment.getProperty("spring.integration.error.require-subscribers", Boolean.class)).isFalse();
assertThat(environment.getProperty("spring.integration.error.ignore-failures", Boolean.class)).isFalse();
assertThat(environment.getProperty("spring.integration.endpoint.throw-exception-on-late-reply", Boolean.class))
.isTrue();
assertThat(environment.getProperty("spring.integration.endpoint.read-only-headers", String.class))
.isEqualTo("header1,header2");
assertThat(environment.getProperty("spring.integration.endpoint.no-auto-startup", String.class))
.isEqualTo("testService,anotherService");
}
@Test
@SuppressWarnings("unchecked")
void registerIntegrationPropertiesPropertySourceWithResourceCanRetrieveOrigin() {
ConfigurableEnvironment environment = new StandardEnvironment();
ClassPathResource resource = new ClassPathResource("spring.integration.properties", getClass());
new IntegrationPropertiesEnvironmentPostProcessor().registerIntegrationPropertiesPropertySource(environment,
resource);
PropertySource<?> ps = environment.getPropertySources().get("META-INF/spring.integration.properties");
assertThat(ps).isNotNull().isInstanceOf(OriginLookup.class);
OriginLookup<String> originLookup = (OriginLookup<String>) ps;
assertThat(originLookup.getOrigin("spring.integration.channel.auto-create"))
.satisfies(textOrigin(resource, 0, 39));
assertThat(originLookup.getOrigin("spring.integration.channel.max-unicast-subscribers"))
.satisfies(textOrigin(resource, 1, 50));
assertThat(originLookup.getOrigin("spring.integration.channel.max-broadcast-subscribers"))
.satisfies(textOrigin(resource, 2, 52));
}
private Consumer<Origin> textOrigin(Resource resource, int line, int column) {
return (origin) -> {
assertThat(origin).isInstanceOf(TextResourceOrigin.class);
TextResourceOrigin textOrigin = (TextResourceOrigin) origin;
assertThat(textOrigin.getResource()).isEqualTo(resource);
assertThat(textOrigin.getLocation().getLine()).isEqualTo(line);
assertThat(textOrigin.getLocation().getColumn()).isEqualTo(column);
};
}
}
spring-boot-project/spring-boot-autoconfigure/src/test/resources/org/springframework/boot/autoconfigure/integration/spring.integration.properties 0 → 100644
View file @ 36b63eec
spring.integration.channels.autoCreate=false
spring.integration.channels.maxUnicastSubscribers=4
spring.integration.channels.maxBroadcastSubscribers=6
spring.integration.channels.error.requireSubscribers=false
spring.integration.channels.error.ignoreFailures=false
spring.integration.messagingTemplate.throwExceptionOnLateReply=true
spring.integration.readOnly.headers=header1,header2
spring.integration.endpoints.noAutoStartup=testService,anotherService
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment