Reintroduce support for ActiveMQ

spring-boot-project/spring-boot-actuator-autoconfigure/build.gradle

@@ -77,6 +77,7 @@ dependencies {
 	optional("jakarta.persistence:jakarta.persistence-api")
 	optional("jakarta.servlet:jakarta.servlet-api")
 	optional("javax.cache:cache-api")
+	optional("org.apache.activemq:activemq-client-jakarta")
 	optional("org.apache.commons:commons-dbcp2") {
 		exclude group: "commons-logging", module: "commons-logging"
 	}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/jms/JmsHealthContributorAutoConfiguration.java

@@ -29,6 +29,7 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration;
 import org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration;
 import org.springframework.context.annotation.Bean;
 
@@ -38,7 +39,7 @@
  * @author Stephane Nicoll
  * @since 2.0.0
  */
-@AutoConfiguration(after = ArtemisAutoConfiguration.class)
+@AutoConfiguration(after = { ActiveMQAutoConfiguration.class, ArtemisAutoConfiguration.class })
 @ConditionalOnClass(ConnectionFactory.class)
 @ConditionalOnBean(ConnectionFactory.class)
 @ConditionalOnEnabledHealthIndicator("jms")

spring-boot-project/spring-boot-autoconfigure/build.gradle

@@ -48,6 +48,7 @@ dependencies {
 	optional("jakarta.ws.rs:jakarta.ws.rs-api")
 	optional("javax.cache:cache-api")
 	optional("javax.money:money-api")
+	optional("org.apache.activemq:activemq-client-jakarta")
 	optional("org.apache.activemq:artemis-jakarta-client") {
 		exclude group: "commons-logging", module: "commons-logging"
 	}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfiguration.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012-2019 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.jms.activemq;
+
+import jakarta.jms.ConnectionFactory;
+import org.apache.activemq.ActiveMQConnectionFactory;
+
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.AutoConfigureBefore;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration;
+import org.springframework.boot.autoconfigure.jms.JmsProperties;
+import org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+/**
+ * {@link EnableAutoConfiguration Auto-configuration} to integrate with an ActiveMQ
+ * broker. Validates that the classpath contain the necessary classes before starting an
+ * embedded broker.
+ *
+ * @author Stephane Nicoll
+ * @author Phillip Webb
+ * @since 1.1.0
+ */
+@Configuration(proxyBeanMethods = false)
+@AutoConfigureBefore(JmsAutoConfiguration.class)
+@AutoConfigureAfter({ JndiConnectionFactoryAutoConfiguration.class })
+@ConditionalOnClass({ ConnectionFactory.class, ActiveMQConnectionFactory.class })
+@ConditionalOnMissingBean(ConnectionFactory.class)
+@EnableConfigurationProperties({ ActiveMQProperties.class, JmsProperties.class })
+@Import({ ActiveMQXAConnectionFactoryConfiguration.class, ActiveMQConnectionFactoryConfiguration.class })
+public class ActiveMQAutoConfiguration {
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQConnectionFactoryConfiguration.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2012-2020 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.jms.activemq;
+
+import java.util.stream.Collectors;
+
+import jakarta.jms.ConnectionFactory;
+import org.apache.activemq.ActiveMQConnectionFactory;
+import org.apache.commons.pool2.PooledObject;
+import org.messaginghub.pooled.jms.JmsPoolConnectionFactory;
+
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.jms.JmsPoolConnectionFactoryFactory;
+import org.springframework.boot.autoconfigure.jms.JmsProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jms.connection.CachingConnectionFactory;
+
+/**
+ * Configuration for ActiveMQ {@link ConnectionFactory}.
+ *
+ * @author Greg Turnquist
+ * @author Stephane Nicoll
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ * @author Aurélien Leboulanger
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnMissingBean(ConnectionFactory.class)
+class ActiveMQConnectionFactoryConfiguration {
+
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnProperty(prefix = "spring.activemq.pool", name = "enabled", havingValue = "false",
+			matchIfMissing = true)
+	static class SimpleConnectionFactoryConfiguration {
+
+		@Bean
+		@ConditionalOnProperty(prefix = "spring.jms.cache", name = "enabled", havingValue = "false")
+		ActiveMQConnectionFactory jmsConnectionFactory(ActiveMQProperties properties,
+				ObjectProvider<ActiveMQConnectionFactoryCustomizer> factoryCustomizers) {
+			return createJmsConnectionFactory(properties, factoryCustomizers);
+		}
+
+		private static ActiveMQConnectionFactory createJmsConnectionFactory(ActiveMQProperties properties,
+				ObjectProvider<ActiveMQConnectionFactoryCustomizer> factoryCustomizers) {
+			return new ActiveMQConnectionFactoryFactory(properties,
+					factoryCustomizers.orderedStream().collect(Collectors.toList()))
+				.createConnectionFactory(ActiveMQConnectionFactory.class);
+		}
+
+		@Configuration(proxyBeanMethods = false)
+		@ConditionalOnClass(CachingConnectionFactory.class)
+		@ConditionalOnProperty(prefix = "spring.jms.cache", name = "enabled", havingValue = "true",
+				matchIfMissing = true)
+		static class CachingConnectionFactoryConfiguration {
+
+			@Bean
+			CachingConnectionFactory jmsConnectionFactory(JmsProperties jmsProperties, ActiveMQProperties properties,
+					ObjectProvider<ActiveMQConnectionFactoryCustomizer> factoryCustomizers) {
+				JmsProperties.Cache cacheProperties = jmsProperties.getCache();
+				CachingConnectionFactory connectionFactory = new CachingConnectionFactory(
+						createJmsConnectionFactory(properties, factoryCustomizers));
+				connectionFactory.setCacheConsumers(cacheProperties.isConsumers());
+				connectionFactory.setCacheProducers(cacheProperties.isProducers());
+				connectionFactory.setSessionCacheSize(cacheProperties.getSessionCacheSize());
+				return connectionFactory;
+			}
+
+		}
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass({ JmsPoolConnectionFactory.class, PooledObject.class })
+	static class PooledConnectionFactoryConfiguration {
+
+		@Bean(destroyMethod = "stop")
+		@ConditionalOnProperty(prefix = "spring.activemq.pool", name = "enabled", havingValue = "true")
+		JmsPoolConnectionFactory jmsConnectionFactory(ActiveMQProperties properties,
+				ObjectProvider<ActiveMQConnectionFactoryCustomizer> factoryCustomizers) {
+			ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactoryFactory(properties,
+					factoryCustomizers.orderedStream().collect(Collectors.toList()))
+				.createConnectionFactory(ActiveMQConnectionFactory.class);
+			return new JmsPoolConnectionFactoryFactory(properties.getPool())
+				.createPooledConnectionFactory(connectionFactory);
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQConnectionFactoryCustomizer.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012-2019 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.jms.activemq;
+
+import org.apache.activemq.ActiveMQConnectionFactory;
+
+/**
+ * Callback interface that can be implemented by beans wishing to customize the
+ * {@link ActiveMQConnectionFactory} whilst retaining default auto-configuration.
+ *
+ * @author Stephane Nicoll
+ * @since 1.5.5
+ */
+@FunctionalInterface
+public interface ActiveMQConnectionFactoryCustomizer {
+
+	/**
+	 * Customize the {@link ActiveMQConnectionFactory}.
+	 * @param factory the factory to customize
+	 */
+	void customize(ActiveMQConnectionFactory factory);
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQConnectionFactoryFactory.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2012-2019 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.jms.activemq;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.activemq.ActiveMQConnectionFactory;
+
+import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQProperties.Packages;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+/**
+ * Factory to create a {@link ActiveMQConnectionFactory} instance from properties defined
+ * in {@link ActiveMQProperties}.
+ *
+ * @author Phillip Webb
+ * @author Venil Noronha
+ */
+class ActiveMQConnectionFactoryFactory {
+
+	private static final String DEFAULT_NETWORK_BROKER_URL = "tcp://localhost:61616";
+
+	private final ActiveMQProperties properties;
+
+	private final List<ActiveMQConnectionFactoryCustomizer> factoryCustomizers;
+
+	ActiveMQConnectionFactoryFactory(ActiveMQProperties properties,
+			List<ActiveMQConnectionFactoryCustomizer> factoryCustomizers) {
+		Assert.notNull(properties, "Properties must not be null");
+		this.properties = properties;
+		this.factoryCustomizers = (factoryCustomizers != null) ? factoryCustomizers : Collections.emptyList();
+	}
+
+	<T extends ActiveMQConnectionFactory> T createConnectionFactory(Class<T> factoryClass) {
+		try {
+			return doCreateConnectionFactory(factoryClass);
+		}
+		catch (Exception ex) {
+			throw new IllegalStateException("Unable to create ActiveMQConnectionFactory", ex);
+		}
+	}
+
+	private <T extends ActiveMQConnectionFactory> T doCreateConnectionFactory(Class<T> factoryClass) throws Exception {
+		T factory = createConnectionFactoryInstance(factoryClass);
+		if (this.properties.getCloseTimeout() != null) {
+			factory.setCloseTimeout((int) this.properties.getCloseTimeout().toMillis());
+		}
+		factory.setNonBlockingRedelivery(this.properties.isNonBlockingRedelivery());
+		if (this.properties.getSendTimeout() != null) {
+			factory.setSendTimeout((int) this.properties.getSendTimeout().toMillis());
+		}
+		Packages packages = this.properties.getPackages();
+		if (packages.getTrustAll() != null) {
+			factory.setTrustAllPackages(packages.getTrustAll());
+		}
+		if (!packages.getTrusted().isEmpty()) {
+			factory.setTrustedPackages(packages.getTrusted());
+		}
+		customize(factory);
+		return factory;
+	}
+
+	private <T extends ActiveMQConnectionFactory> T createConnectionFactoryInstance(Class<T> factoryClass)
+			throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+		String brokerUrl = determineBrokerUrl();
+		String user = this.properties.getUser();
+		String password = this.properties.getPassword();
+		if (StringUtils.hasLength(user) && StringUtils.hasLength(password)) {
+			return factoryClass.getConstructor(String.class, String.class, String.class)
+				.newInstance(user, password, brokerUrl);
+		}
+		return factoryClass.getConstructor(String.class).newInstance(brokerUrl);
+	}
+
+	private void customize(ActiveMQConnectionFactory connectionFactory) {
+		for (ActiveMQConnectionFactoryCustomizer factoryCustomizer : this.factoryCustomizers) {
+			factoryCustomizer.customize(connectionFactory);
+		}
+	}
+
+	String determineBrokerUrl() {
+		if (this.properties.getBrokerUrl() != null) {
+			return this.properties.getBrokerUrl();
+		}
+		return DEFAULT_NETWORK_BROKER_URL;
+	}
+
+}