From d31f68380a57840c74da22d67eac85186415f250 Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Tue, 31 Jul 2018 16:17:43 +0200 Subject: [PATCH] Deprecate PooledConnectionFactory properties This commit deprecated the properties of `PooledConnectionFactory` that are no longer supported by an alternative that is a JMS 2 compliant. This commit also adds a note to warn users that this pool implementation is not JMS 2 compliant. Closes gh-13956 --- .../jms/activemq/ActiveMQProperties.java | 4 ++ .../ActiveMQAutoConfigurationTests.java | 51 ++++++++++++++----- .../appendix-application-properties.adoc | 3 -- .../main/asciidoc/spring-boot-features.adoc | 2 + 4 files changed, 45 insertions(+), 15 deletions(-) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQProperties.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQProperties.java index 2a6b696de5..ae53b0244b 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQProperties.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQProperties.java @@ -21,6 +21,7 @@ import java.util.ArrayList; import java.util.List; import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.DeprecatedConfigurationProperty; /** * Configuration properties for ActiveMQ. @@ -228,6 +229,7 @@ public class ActiveMQProperties { this.blockIfFullTimeout = blockIfFullTimeout; } + @DeprecatedConfigurationProperty public boolean isCreateConnectionOnStartup() { return this.createConnectionOnStartup; } @@ -236,6 +238,7 @@ public class ActiveMQProperties { this.createConnectionOnStartup = createConnectionOnStartup; } + @DeprecatedConfigurationProperty(reason = "Use idle-timeout instead") public Duration getExpiryTimeout() { return this.expiryTimeout; } @@ -269,6 +272,7 @@ public class ActiveMQProperties { this.maximumActiveSessionPerConnection = maximumActiveSessionPerConnection; } + @DeprecatedConfigurationProperty(reason = "Disabling this option will likely lead to broken connections in the pool.") public boolean isReconnectOnException() { return this.reconnectOnException; } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfigurationTests.java index 17ac223972..b47c6abb5f 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfigurationTests.java @@ -138,10 +138,6 @@ public class ActiveMQAutoConfigurationTests { assertThat(connectionFactory.getBlockIfSessionPoolIsFullTimeout()) .isEqualTo( defaultFactory.getBlockIfSessionPoolIsFullTimeout()); - assertThat(connectionFactory.isCreateConnectionOnStartup()) - .isEqualTo(defaultFactory.isCreateConnectionOnStartup()); - assertThat(connectionFactory.getExpiryTimeout()) - .isEqualTo(defaultFactory.getExpiryTimeout()); assertThat(connectionFactory.getIdleTimeout()) .isEqualTo(defaultFactory.getIdleTimeout()); assertThat(connectionFactory.getMaxConnections()) @@ -149,8 +145,6 @@ public class ActiveMQAutoConfigurationTests { assertThat(connectionFactory.getMaximumActiveSessionPerConnection()) .isEqualTo(defaultFactory .getMaximumActiveSessionPerConnection()); - assertThat(connectionFactory.isReconnectOnException()) - .isEqualTo(defaultFactory.isReconnectOnException()); assertThat(connectionFactory.getTimeBetweenExpirationCheckMillis()) .isEqualTo( defaultFactory.getTimeBetweenExpirationCheckMillis()); @@ -159,18 +153,35 @@ public class ActiveMQAutoConfigurationTests { }); } + @Test + @Deprecated + public void defaultPooledConnectionFactoryIsAppliedWithDeprecatedSettings() { + this.contextRunner.withUserConfiguration(EmptyConfiguration.class) + .withPropertyValues("spring.activemq.pool.enabled=true") + .run((context) -> { + assertThat(context.getBeansOfType(PooledConnectionFactory.class)) + .hasSize(1); + PooledConnectionFactory connectionFactory = context + .getBean(PooledConnectionFactory.class); + PooledConnectionFactory defaultFactory = new PooledConnectionFactory(); + assertThat(connectionFactory.isCreateConnectionOnStartup()) + .isEqualTo(defaultFactory.isCreateConnectionOnStartup()); + assertThat(connectionFactory.getExpiryTimeout()) + .isEqualTo(defaultFactory.getExpiryTimeout()); + assertThat(connectionFactory.isReconnectOnException()) + .isEqualTo(defaultFactory.isReconnectOnException()); + }); + } + @Test public void customPooledConnectionFactoryIsApplied() { this.contextRunner.withUserConfiguration(EmptyConfiguration.class) .withPropertyValues("spring.activemq.pool.enabled=true", "spring.activemq.pool.blockIfFull=false", "spring.activemq.pool.blockIfFullTimeout=64", - "spring.activemq.pool.createConnectionOnStartup=false", - "spring.activemq.pool.expiryTimeout=4096", "spring.activemq.pool.idleTimeout=512", "spring.activemq.pool.maxConnections=256", "spring.activemq.pool.maximumActiveSessionPerConnection=1024", - "spring.activemq.pool.reconnectOnException=false", "spring.activemq.pool.timeBetweenExpirationCheck=2048", "spring.activemq.pool.useAnonymousProducers=false") .run((context) -> { @@ -181,19 +192,35 @@ public class ActiveMQAutoConfigurationTests { assertThat(connectionFactory.isBlockIfSessionPoolIsFull()).isFalse(); assertThat(connectionFactory.getBlockIfSessionPoolIsFullTimeout()) .isEqualTo(64); - assertThat(connectionFactory.isCreateConnectionOnStartup()).isFalse(); - assertThat(connectionFactory.getExpiryTimeout()).isEqualTo(4096); assertThat(connectionFactory.getIdleTimeout()).isEqualTo(512); assertThat(connectionFactory.getMaxConnections()).isEqualTo(256); assertThat(connectionFactory.getMaximumActiveSessionPerConnection()) .isEqualTo(1024); - assertThat(connectionFactory.isReconnectOnException()).isFalse(); assertThat(connectionFactory.getTimeBetweenExpirationCheckMillis()) .isEqualTo(2048); assertThat(connectionFactory.isUseAnonymousProducers()).isFalse(); }); } + @Test + @Deprecated + public void customPooledConnectionFactoryIsAppliedWithDeprecatedSettings() { + this.contextRunner.withUserConfiguration(EmptyConfiguration.class) + .withPropertyValues("spring.activemq.pool.enabled=true", + "spring.activemq.pool.createConnectionOnStartup=false", + "spring.activemq.pool.expiryTimeout=4096", + "spring.activemq.pool.reconnectOnException=false") + .run((context) -> { + assertThat(context.getBeansOfType(PooledConnectionFactory.class)) + .hasSize(1); + PooledConnectionFactory connectionFactory = context + .getBean(PooledConnectionFactory.class); + assertThat(connectionFactory.isCreateConnectionOnStartup()).isFalse(); + assertThat(connectionFactory.getExpiryTimeout()).isEqualTo(4096); + assertThat(connectionFactory.isReconnectOnException()).isFalse(); + }); + } + @Test public void pooledConnectionFactoryConfiguration() { this.contextRunner.withUserConfiguration(EmptyConfiguration.class) diff --git a/spring-boot-project/spring-boot-docs/src/main/asciidoc/appendix-application-properties.adoc b/spring-boot-project/spring-boot-docs/src/main/asciidoc/appendix-application-properties.adoc index 9a796c4b10..0873761c7d 100644 --- a/spring-boot-project/spring-boot-docs/src/main/asciidoc/appendix-application-properties.adoc +++ b/spring-boot-project/spring-boot-docs/src/main/asciidoc/appendix-application-properties.adoc @@ -941,13 +941,10 @@ content into your application. Rather, pick only the properties that you need. spring.activemq.packages.trusted= # Comma-separated list of specific packages to trust (when not trusting all packages). spring.activemq.pool.block-if-full=true # Whether to block when a connection is requested and the pool is full. Set it to false to throw a "JMSException" instead. spring.activemq.pool.block-if-full-timeout=-1ms # Blocking period before throwing an exception if the pool is still full. - spring.activemq.pool.create-connection-on-startup=true # Whether to create a connection on startup. Can be used to warm up the pool on startup. spring.activemq.pool.enabled=false # Whether a PooledConnectionFactory should be created, instead of a regular ConnectionFactory. - spring.activemq.pool.expiry-timeout=0ms # Connection expiration timeout. spring.activemq.pool.idle-timeout=30s # Connection idle timeout. spring.activemq.pool.max-connections=1 # Maximum number of pooled connections. spring.activemq.pool.maximum-active-session-per-connection=500 # Maximum number of active sessions per connection. - spring.activemq.pool.reconnect-on-exception=true # Reset the connection when a "JMSException" occurs. spring.activemq.pool.time-between-expiration-check=-1ms # Time to sleep between runs of the idle connection eviction thread. When negative, no idle connection eviction thread runs. spring.activemq.pool.use-anonymous-producers=true # Whether to use only one anonymous "MessageProducer" instance. Set it to false to create one "MessageProducer" every time one is required. diff --git a/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc b/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc index eb330050bd..e63875c256 100644 --- a/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc +++ b/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc @@ -5049,6 +5049,8 @@ accordingly, as shown in the following example: spring.activemq.pool.max-connections=50 ---- +WARNING: `PooledConnectionFactory` is not JMS 2.0 compliant + TIP: See {sc-spring-boot-autoconfigure}/jms/activemq/ActiveMQProperties.{sc-ext}[`ActiveMQProperties`] for more of the supported options. You can also register an arbitrary number of beans