All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.activemq.ActiveMQConnectionFactory Maven / Gradle / Ivy

There is a newer version: 6.1.3
Show newest version
/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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
 *
 *      http://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.apache.activemq;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.*;
import java.util.concurrent.RejectedExecutionHandler;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.ExceptionListener;
import javax.jms.JMSException;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.naming.Context;

import org.apache.activemq.blob.BlobTransferPolicy;
import org.apache.activemq.broker.region.policy.RedeliveryPolicyMap;
import org.apache.activemq.jndi.JNDIBaseStorable;
import org.apache.activemq.management.JMSStatsImpl;
import org.apache.activemq.management.StatsCapable;
import org.apache.activemq.management.StatsImpl;
import org.apache.activemq.thread.TaskRunnerFactory;
import org.apache.activemq.transport.Transport;
import org.apache.activemq.transport.TransportFactory;
import org.apache.activemq.transport.TransportListener;
import org.apache.activemq.util.*;
import org.apache.activemq.util.URISupport.CompositeData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A ConnectionFactory is an an Administered object, and is used for creating
 * Connections. 

This class also implements QueueConnectionFactory and * TopicConnectionFactory. You can use this connection to create both * QueueConnections and TopicConnections. * * * @see javax.jms.ConnectionFactory */ public class ActiveMQConnectionFactory extends JNDIBaseStorable implements ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory, StatsCapable, Cloneable { private static final Logger LOG = LoggerFactory.getLogger(ActiveMQConnectionFactory.class); private static final String DEFAULT_BROKER_HOST; private static final int DEFAULT_BROKER_PORT; static{ String host = null; String port = null; try { host = AccessController.doPrivileged(new PrivilegedAction() { @Override public String run() { String result = System.getProperty("org.apache.activemq.AMQ_HOST"); result = (result==null||result.isEmpty()) ? System.getProperty("AMQ_HOST","localhost") : result; return result; } }); port = AccessController.doPrivileged(new PrivilegedAction() { @Override public String run() { String result = System.getProperty("org.apache.activemq.AMQ_PORT"); result = (result==null||result.isEmpty()) ? System.getProperty("AMQ_PORT","61616") : result; return result; } }); }catch(Throwable e){ LOG.debug("Failed to look up System properties for host and port",e); } host = (host == null || host.isEmpty()) ? "localhost" : host; port = (port == null || port.isEmpty()) ? "61616" : port; DEFAULT_BROKER_HOST = host; DEFAULT_BROKER_PORT = Integer.parseInt(port); } public static final String DEFAULT_BROKER_BIND_URL; static{ final String defaultURL = "tcp://" + DEFAULT_BROKER_HOST + ":" + DEFAULT_BROKER_PORT; String bindURL = null; try { bindURL = AccessController.doPrivileged(new PrivilegedAction() { @Override public String run() { String result = System.getProperty("org.apache.activemq.BROKER_BIND_URL"); result = (result==null||result.isEmpty()) ? System.getProperty("BROKER_BIND_URL",defaultURL) : result; return result; } }); }catch(Throwable e){ LOG.debug("Failed to look up System properties for host and port",e); } bindURL = (bindURL == null || bindURL.isEmpty()) ? defaultURL : bindURL; DEFAULT_BROKER_BIND_URL = bindURL; } public static final String DEFAULT_BROKER_URL = "failover://"+DEFAULT_BROKER_BIND_URL; public static final String DEFAULT_USER = null; public static final String DEFAULT_PASSWORD = null; public static final int DEFAULT_PRODUCER_WINDOW_SIZE = 0; protected URI brokerURL; protected String userName; protected String password; protected String clientID; protected boolean dispatchAsync=true; protected boolean alwaysSessionAsync=true; JMSStatsImpl factoryStats = new JMSStatsImpl(); private IdGenerator clientIdGenerator; private String clientIDPrefix; private IdGenerator connectionIdGenerator; private String connectionIDPrefix; // client policies private ActiveMQPrefetchPolicy prefetchPolicy = new ActiveMQPrefetchPolicy(); private RedeliveryPolicyMap redeliveryPolicyMap = new RedeliveryPolicyMap(); { redeliveryPolicyMap.setDefaultEntry(new RedeliveryPolicy()); } private BlobTransferPolicy blobTransferPolicy = new BlobTransferPolicy(); private MessageTransformer transformer; private boolean disableTimeStampsByDefault; private boolean optimizedMessageDispatch = true; private long optimizeAcknowledgeTimeOut = 300; private long optimizedAckScheduledAckInterval = 0; private boolean copyMessageOnSend = true; private boolean useCompression; private boolean objectMessageSerializationDefered; private boolean useAsyncSend; private boolean optimizeAcknowledge; private int closeTimeout = 15000; private boolean useRetroactiveConsumer; private boolean exclusiveConsumer; private boolean nestedMapAndListEnabled = true; private boolean alwaysSyncSend; private boolean watchTopicAdvisories = true; private int producerWindowSize = DEFAULT_PRODUCER_WINDOW_SIZE; private long warnAboutUnstartedConnectionTimeout = 500L; private int sendTimeout = 0; private int connectResponseTimeout = 0; private boolean sendAcksAsync=true; private TransportListener transportListener; private ExceptionListener exceptionListener; private int auditDepth = ActiveMQMessageAudit.DEFAULT_WINDOW_SIZE; private int auditMaximumProducerNumber = ActiveMQMessageAudit.MAXIMUM_PRODUCER_COUNT; private boolean useDedicatedTaskRunner; private long consumerFailoverRedeliveryWaitPeriod = 0; private boolean checkForDuplicates = true; private ClientInternalExceptionListener clientInternalExceptionListener; private boolean messagePrioritySupported = false; private boolean transactedIndividualAck = false; private boolean nonBlockingRedelivery = false; private int maxThreadPoolSize = ActiveMQConnection.DEFAULT_THREAD_POOL_SIZE; private TaskRunnerFactory sessionTaskRunner; private RejectedExecutionHandler rejectedTaskHandler = null; protected int xaAckMode = -1; // ensure default init before setting via brokerUrl introspection in sub class private boolean rmIdFromConnectionId = false; private boolean consumerExpiryCheckEnabled = true; private List trustedPackages = Arrays.asList(ClassLoadingAwareObjectInputStream.serializablePackages); private boolean trustAllPackages = false; // ///////////////////////////////////////////// // // ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory Methods // // ///////////////////////////////////////////// public ActiveMQConnectionFactory() { this(DEFAULT_BROKER_URL); } public ActiveMQConnectionFactory(String brokerURL) { this(createURI(brokerURL)); } public ActiveMQConnectionFactory(URI brokerURL) { setBrokerURL(brokerURL.toString()); } public ActiveMQConnectionFactory(String userName, String password, URI brokerURL) { setUserName(userName); setPassword(password); setBrokerURL(brokerURL.toString()); } public ActiveMQConnectionFactory(String userName, String password, String brokerURL) { setUserName(userName); setPassword(password); setBrokerURL(brokerURL); } /** * Returns a copy of the given connection factory */ public ActiveMQConnectionFactory copy() { try { return (ActiveMQConnectionFactory)super.clone(); } catch (CloneNotSupportedException e) { throw new RuntimeException("This should never happen: " + e, e); } } /*boolean* * @param brokerURL * @return * @throws URISyntaxException */ private static URI createURI(String brokerURL) { try { return new URI(brokerURL); } catch (URISyntaxException e) { throw (IllegalArgumentException)new IllegalArgumentException("Invalid broker URI: " + brokerURL).initCause(e); } } /** * @return Returns the Connection. */ @Override public Connection createConnection() throws JMSException { return createActiveMQConnection(); } /** * @return Returns the Connection. */ @Override public Connection createConnection(String userName, String password) throws JMSException { return createActiveMQConnection(userName, password); } /** * @return Returns the QueueConnection. * @throws JMSException */ @Override public QueueConnection createQueueConnection() throws JMSException { return createActiveMQConnection().enforceQueueOnlyConnection(); } /** * @return Returns the QueueConnection. */ @Override public QueueConnection createQueueConnection(String userName, String password) throws JMSException { return createActiveMQConnection(userName, password).enforceQueueOnlyConnection(); } /** * @return Returns the TopicConnection. * @throws JMSException */ @Override public TopicConnection createTopicConnection() throws JMSException { return createActiveMQConnection(); } /** * @return Returns the TopicConnection. */ @Override public TopicConnection createTopicConnection(String userName, String password) throws JMSException { return createActiveMQConnection(userName, password); } /** * @return the StatsImpl associated with this ConnectionFactory. */ @Override public StatsImpl getStats() { return this.factoryStats; } // ///////////////////////////////////////////// // // Implementation methods. // // ///////////////////////////////////////////// protected ActiveMQConnection createActiveMQConnection() throws JMSException { return createActiveMQConnection(userName, password); } /** * Creates a Transport based on this object's connection settings. Separated * from createActiveMQConnection to allow for subclasses to override. * * @return The newly created Transport. * @throws JMSException If unable to create trasnport. */ protected Transport createTransport() throws JMSException { try { URI connectBrokerUL = brokerURL; String scheme = brokerURL.getScheme(); if (scheme == null) { throw new IOException("Transport not scheme specified: [" + brokerURL + "]"); } if (scheme.equals("auto")) { connectBrokerUL = new URI(brokerURL.toString().replace("auto", "tcp")); } else if (scheme.equals("auto+ssl")) { connectBrokerUL = new URI(brokerURL.toString().replace("auto+ssl", "ssl")); } else if (scheme.equals("auto+nio")) { connectBrokerUL = new URI(brokerURL.toString().replace("auto+nio", "nio")); } else if (scheme.equals("auto+nio+ssl")) { connectBrokerUL = new URI(brokerURL.toString().replace("auto+nio+ssl", "nio+ssl")); } return TransportFactory.connect(connectBrokerUL); } catch (Exception e) { throw JMSExceptionSupport.create("Could not create Transport. Reason: " + e, e); } } /** * @return Returns the Connection. */ protected ActiveMQConnection createActiveMQConnection(String userName, String password) throws JMSException { if (brokerURL == null) { throw new ConfigurationException("brokerURL not set."); } ActiveMQConnection connection = null; try { Transport transport = createTransport(); connection = createActiveMQConnection(transport, factoryStats); connection.setUserName(userName); connection.setPassword(password); configureConnection(connection); transport.start(); if (clientID != null) { connection.setDefaultClientID(clientID); } return connection; } catch (JMSException e) { // Clean up! try { connection.close(); } catch (Throwable ignore) { } throw e; } catch (Exception e) { // Clean up! try { connection.close(); } catch (Throwable ignore) { } throw JMSExceptionSupport.create("Could not connect to broker URL: " + brokerURL + ". Reason: " + e, e); } } protected ActiveMQConnection createActiveMQConnection(Transport transport, JMSStatsImpl stats) throws Exception { ActiveMQConnection connection = new ActiveMQConnection(transport, getClientIdGenerator(), getConnectionIdGenerator(), stats); return connection; } protected void configureConnection(ActiveMQConnection connection) throws JMSException { connection.setPrefetchPolicy(getPrefetchPolicy()); connection.setDisableTimeStampsByDefault(isDisableTimeStampsByDefault()); connection.setOptimizedMessageDispatch(isOptimizedMessageDispatch()); connection.setCopyMessageOnSend(isCopyMessageOnSend()); connection.setUseCompression(isUseCompression()); connection.setObjectMessageSerializationDefered(isObjectMessageSerializationDefered()); connection.setDispatchAsync(isDispatchAsync()); connection.setUseAsyncSend(isUseAsyncSend()); connection.setAlwaysSyncSend(isAlwaysSyncSend()); connection.setAlwaysSessionAsync(isAlwaysSessionAsync()); connection.setOptimizeAcknowledge(isOptimizeAcknowledge()); connection.setOptimizeAcknowledgeTimeOut(getOptimizeAcknowledgeTimeOut()); connection.setOptimizedAckScheduledAckInterval(getOptimizedAckScheduledAckInterval()); connection.setUseRetroactiveConsumer(isUseRetroactiveConsumer()); connection.setExclusiveConsumer(isExclusiveConsumer()); connection.setRedeliveryPolicyMap(getRedeliveryPolicyMap()); connection.setTransformer(getTransformer()); connection.setBlobTransferPolicy(getBlobTransferPolicy().copy()); connection.setWatchTopicAdvisories(isWatchTopicAdvisories()); connection.setProducerWindowSize(getProducerWindowSize()); connection.setWarnAboutUnstartedConnectionTimeout(getWarnAboutUnstartedConnectionTimeout()); connection.setSendTimeout(getSendTimeout()); connection.setCloseTimeout(getCloseTimeout()); connection.setSendAcksAsync(isSendAcksAsync()); connection.setAuditDepth(getAuditDepth()); connection.setAuditMaximumProducerNumber(getAuditMaximumProducerNumber()); connection.setUseDedicatedTaskRunner(isUseDedicatedTaskRunner()); connection.setConsumerFailoverRedeliveryWaitPeriod(getConsumerFailoverRedeliveryWaitPeriod()); connection.setCheckForDuplicates(isCheckForDuplicates()); connection.setMessagePrioritySupported(isMessagePrioritySupported()); connection.setTransactedIndividualAck(isTransactedIndividualAck()); connection.setNonBlockingRedelivery(isNonBlockingRedelivery()); connection.setMaxThreadPoolSize(getMaxThreadPoolSize()); connection.setSessionTaskRunner(getSessionTaskRunner()); connection.setRejectedTaskHandler(getRejectedTaskHandler()); connection.setNestedMapAndListEnabled(isNestedMapAndListEnabled()); connection.setRmIdFromConnectionId(isRmIdFromConnectionId()); connection.setConsumerExpiryCheckEnabled(isConsumerExpiryCheckEnabled()); connection.setTrustedPackages(getTrustedPackages()); connection.setTrustAllPackages(isTrustAllPackages()); connection.setConnectResponseTimeout(getConnectResponseTimeout()); if (transportListener != null) { connection.addTransportListener(transportListener); } if (exceptionListener != null) { connection.setExceptionListener(exceptionListener); } if (clientInternalExceptionListener != null) { connection.setClientInternalExceptionListener(clientInternalExceptionListener); } } // ///////////////////////////////////////////// // // Property Accessors // // ///////////////////////////////////////////// public String getBrokerURL() { return brokerURL == null ? null : brokerURL.toString(); } /** * Sets the connection * URL used to connect to the ActiveMQ broker. */ public void setBrokerURL(String brokerURL) { this.brokerURL = createURI(brokerURL); // Use all the properties prefixed with 'jms.' to set the connection // factory // options. if (this.brokerURL.getQuery() != null) { // It might be a standard URI or... try { Map map = URISupport.parseQuery(this.brokerURL.getQuery()); Map jmsOptionsMap = IntrospectionSupport.extractProperties(map, "jms."); if (buildFromMap(jmsOptionsMap)) { if (!jmsOptionsMap.isEmpty()) { String msg = "There are " + jmsOptionsMap.size() + " jms options that couldn't be set on the ConnectionFactory." + " Check the options are spelled correctly." + " Unknown parameters=[" + jmsOptionsMap + "]." + " This connection factory cannot be started."; throw new IllegalArgumentException(msg); } this.brokerURL = URISupport.createRemainingURI(this.brokerURL, map); } } catch (URISyntaxException e) { } } else { // It might be a composite URI. try { CompositeData data = URISupport.parseComposite(this.brokerURL); Map jmsOptionsMap = IntrospectionSupport.extractProperties(data.getParameters(), "jms."); if (buildFromMap(jmsOptionsMap)) { if (!jmsOptionsMap.isEmpty()) { String msg = "There are " + jmsOptionsMap.size() + " jms options that couldn't be set on the ConnectionFactory." + " Check the options are spelled correctly." + " Unknown parameters=[" + jmsOptionsMap + "]." + " This connection factory cannot be started."; throw new IllegalArgumentException(msg); } this.brokerURL = data.toURI(); } } catch (URISyntaxException e) { } } } public String getClientID() { return clientID; } /** * Sets the JMS clientID to use for the created connection. Note that this * can only be used by one connection at once so generally its a better idea * to set the clientID on a Connection */ public void setClientID(String clientID) { this.clientID = clientID; } public boolean isCopyMessageOnSend() { return copyMessageOnSend; } /** * Should a JMS message be copied to a new JMS Message object as part of the * send() method in JMS. This is enabled by default to be compliant with the * JMS specification. You can disable it if you do not mutate JMS messages * after they are sent for a performance boost */ public void setCopyMessageOnSend(boolean copyMessageOnSend) { this.copyMessageOnSend = copyMessageOnSend; } public boolean isDisableTimeStampsByDefault() { return disableTimeStampsByDefault; } /** * Sets whether or not timestamps on messages should be disabled or not. If * you disable them it adds a small performance boost. */ public void setDisableTimeStampsByDefault(boolean disableTimeStampsByDefault) { this.disableTimeStampsByDefault = disableTimeStampsByDefault; } public boolean isOptimizedMessageDispatch() { return optimizedMessageDispatch; } /** * If this flag is set then an larger prefetch limit is used - only * applicable for durable topic subscribers. */ public void setOptimizedMessageDispatch(boolean optimizedMessageDispatch) { this.optimizedMessageDispatch = optimizedMessageDispatch; } public String getPassword() { return password; } /** * Sets the JMS password used for connections created from this factory */ public void setPassword(String password) { this.password = password; } public ActiveMQPrefetchPolicy getPrefetchPolicy() { return prefetchPolicy; } /** * Sets the prefetch * policy for consumers created by this connection. */ public void setPrefetchPolicy(ActiveMQPrefetchPolicy prefetchPolicy) { this.prefetchPolicy = prefetchPolicy; } public boolean isUseAsyncSend() { return useAsyncSend; } public BlobTransferPolicy getBlobTransferPolicy() { return blobTransferPolicy; } /** * Sets the policy used to describe how out-of-band BLOBs (Binary Large * OBjects) are transferred from producers to brokers to consumers */ public void setBlobTransferPolicy(BlobTransferPolicy blobTransferPolicy) { this.blobTransferPolicy = blobTransferPolicy; } /** * Forces the use of Async Sends which * adds a massive performance boost; but means that the send() method will * return immediately whether the message has been sent or not which could * lead to message loss. */ public void setUseAsyncSend(boolean useAsyncSend) { this.useAsyncSend = useAsyncSend; } public synchronized boolean isWatchTopicAdvisories() { return watchTopicAdvisories; } public synchronized void setWatchTopicAdvisories(boolean watchTopicAdvisories) { this.watchTopicAdvisories = watchTopicAdvisories; } /** * @return true if always sync send messages */ public boolean isAlwaysSyncSend() { return this.alwaysSyncSend; } /** * Set true if always require messages to be sync sent * * @param alwaysSyncSend */ public void setAlwaysSyncSend(boolean alwaysSyncSend) { this.alwaysSyncSend = alwaysSyncSend; } public String getUserName() { return userName; } /** * Sets the JMS userName used by connections created by this factory */ public void setUserName(String userName) { this.userName = userName; } public boolean isUseRetroactiveConsumer() { return useRetroactiveConsumer; } /** * Sets whether or not retroactive consumers are enabled. Retroactive * consumers allow non-durable topic subscribers to receive old messages * that were published before the non-durable subscriber started. */ public void setUseRetroactiveConsumer(boolean useRetroactiveConsumer) { this.useRetroactiveConsumer = useRetroactiveConsumer; } public boolean isExclusiveConsumer() { return exclusiveConsumer; } /** * Enables or disables whether or not queue consumers should be exclusive or * not for example to preserve ordering when not using Message Groups * * @param exclusiveConsumer */ public void setExclusiveConsumer(boolean exclusiveConsumer) { this.exclusiveConsumer = exclusiveConsumer; } public RedeliveryPolicy getRedeliveryPolicy() { return redeliveryPolicyMap.getDefaultEntry(); } /** * Sets the global default redelivery policy to be used when a message is delivered * but the session is rolled back */ public void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy) { this.redeliveryPolicyMap.setDefaultEntry(redeliveryPolicy); } public RedeliveryPolicyMap getRedeliveryPolicyMap() { return this.redeliveryPolicyMap; } /** * Sets the global redelivery policy mapping to be used when a message is delivered * but the session is rolled back */ public void setRedeliveryPolicyMap(RedeliveryPolicyMap redeliveryPolicyMap) { this.redeliveryPolicyMap = redeliveryPolicyMap; } public MessageTransformer getTransformer() { return transformer; } /** * @return the sendTimeout (in milliseconds) */ public int getSendTimeout() { return sendTimeout; } /** * @param sendTimeout the sendTimeout to set (in milliseconds) */ public void setSendTimeout(int sendTimeout) { this.sendTimeout = sendTimeout; } /** * @return the sendAcksAsync */ public boolean isSendAcksAsync() { return sendAcksAsync; } /** * @param sendAcksAsync the sendAcksAsync to set */ public void setSendAcksAsync(boolean sendAcksAsync) { this.sendAcksAsync = sendAcksAsync; } /** * @return the messagePrioritySupported */ public boolean isMessagePrioritySupported() { return this.messagePrioritySupported; } /** * @param messagePrioritySupported the messagePrioritySupported to set */ public void setMessagePrioritySupported(boolean messagePrioritySupported) { this.messagePrioritySupported = messagePrioritySupported; } /** * Sets the transformer used to transform messages before they are sent on * to the JMS bus or when they are received from the bus but before they are * delivered to the JMS client */ public void setTransformer(MessageTransformer transformer) { this.transformer = transformer; } @SuppressWarnings({ "unchecked", "rawtypes" }) @Override public void buildFromProperties(Properties properties) { if (properties == null) { properties = new Properties(); } String temp = properties.getProperty(Context.PROVIDER_URL); if (temp == null || temp.length() == 0) { temp = properties.getProperty("brokerURL"); } if (temp != null && temp.length() > 0) { setBrokerURL(temp); } Map p = new HashMap(properties); buildFromMap(p); } public boolean buildFromMap(Map properties) { boolean rc = false; ActiveMQPrefetchPolicy p = new ActiveMQPrefetchPolicy(); if (IntrospectionSupport.setProperties(p, properties, "prefetchPolicy.")) { setPrefetchPolicy(p); rc = true; } RedeliveryPolicy rp = new RedeliveryPolicy(); if (IntrospectionSupport.setProperties(rp, properties, "redeliveryPolicy.")) { setRedeliveryPolicy(rp); rc = true; } BlobTransferPolicy blobTransferPolicy = new BlobTransferPolicy(); if (IntrospectionSupport.setProperties(blobTransferPolicy, properties, "blobTransferPolicy.")) { setBlobTransferPolicy(blobTransferPolicy); rc = true; } rc |= IntrospectionSupport.setProperties(this, properties); return rc; } @Override public void populateProperties(Properties props) { props.setProperty("dispatchAsync", Boolean.toString(isDispatchAsync())); if (getBrokerURL() != null) { props.setProperty(Context.PROVIDER_URL, getBrokerURL()); props.setProperty("brokerURL", getBrokerURL()); } if (getClientID() != null) { props.setProperty("clientID", getClientID()); } IntrospectionSupport.getProperties(getPrefetchPolicy(), props, "prefetchPolicy."); IntrospectionSupport.getProperties(getRedeliveryPolicy(), props, "redeliveryPolicy."); IntrospectionSupport.getProperties(getBlobTransferPolicy(), props, "blobTransferPolicy."); props.setProperty("copyMessageOnSend", Boolean.toString(isCopyMessageOnSend())); props.setProperty("disableTimeStampsByDefault", Boolean.toString(isDisableTimeStampsByDefault())); props.setProperty("objectMessageSerializationDefered", Boolean.toString(isObjectMessageSerializationDefered())); props.setProperty("optimizedMessageDispatch", Boolean.toString(isOptimizedMessageDispatch())); if (getPassword() != null) { props.setProperty("password", getPassword()); } props.setProperty("useAsyncSend", Boolean.toString(isUseAsyncSend())); props.setProperty("useCompression", Boolean.toString(isUseCompression())); props.setProperty("useRetroactiveConsumer", Boolean.toString(isUseRetroactiveConsumer())); props.setProperty("watchTopicAdvisories", Boolean.toString(isWatchTopicAdvisories())); if (getUserName() != null) { props.setProperty("userName", getUserName()); } props.setProperty("closeTimeout", Integer.toString(getCloseTimeout())); props.setProperty("alwaysSessionAsync", Boolean.toString(isAlwaysSessionAsync())); props.setProperty("optimizeAcknowledge", Boolean.toString(isOptimizeAcknowledge())); props.setProperty("statsEnabled", Boolean.toString(isStatsEnabled())); props.setProperty("alwaysSyncSend", Boolean.toString(isAlwaysSyncSend())); props.setProperty("producerWindowSize", Integer.toString(getProducerWindowSize())); props.setProperty("sendTimeout", Integer.toString(getSendTimeout())); props.setProperty("connectResponseTimeout", Integer.toString(getConnectResponseTimeout())); props.setProperty("sendAcksAsync",Boolean.toString(isSendAcksAsync())); props.setProperty("auditDepth", Integer.toString(getAuditDepth())); props.setProperty("auditMaximumProducerNumber", Integer.toString(getAuditMaximumProducerNumber())); props.setProperty("checkForDuplicates", Boolean.toString(isCheckForDuplicates())); props.setProperty("messagePrioritySupported", Boolean.toString(isMessagePrioritySupported())); props.setProperty("transactedIndividualAck", Boolean.toString(isTransactedIndividualAck())); props.setProperty("nonBlockingRedelivery", Boolean.toString(isNonBlockingRedelivery())); props.setProperty("maxThreadPoolSize", Integer.toString(getMaxThreadPoolSize())); props.setProperty("nestedMapAndListEnabled", Boolean.toString(isNestedMapAndListEnabled())); props.setProperty("consumerFailoverRedeliveryWaitPeriod", Long.toString(getConsumerFailoverRedeliveryWaitPeriod())); props.setProperty("rmIdFromConnectionId", Boolean.toString(isRmIdFromConnectionId())); props.setProperty("consumerExpiryCheckEnabled", Boolean.toString(isConsumerExpiryCheckEnabled())); } public boolean isUseCompression() { return useCompression; } /** * Enables the use of compression of the message bodies */ public void setUseCompression(boolean useCompression) { this.useCompression = useCompression; } public boolean isObjectMessageSerializationDefered() { return objectMessageSerializationDefered; } /** * When an object is set on an ObjectMessage, the JMS spec requires the * object to be serialized by that set method. Enabling this flag causes the * object to not get serialized. The object may subsequently get serialized * if the message needs to be sent over a socket or stored to disk. */ public void setObjectMessageSerializationDefered(boolean objectMessageSerializationDefered) { this.objectMessageSerializationDefered = objectMessageSerializationDefered; } public boolean isDispatchAsync() { return dispatchAsync; } /** * Enables or disables the default setting of whether or not consumers have * their messages dispatched * synchronously or asynchronously by the broker. For non-durable * topics for example we typically dispatch synchronously by default to * minimize context switches which boost performance. However sometimes its * better to go slower to ensure that a single blocked consumer socket does * not block delivery to other consumers. * * @param asyncDispatch If true then consumers created on this connection * will default to having their messages dispatched * asynchronously. The default value is true. */ public void setDispatchAsync(boolean asyncDispatch) { this.dispatchAsync = asyncDispatch; } /** * @return Returns the closeTimeout. */ public int getCloseTimeout() { return closeTimeout; } /** * Sets the timeout before a close is considered complete. Normally a * close() on a connection waits for confirmation from the broker; this * allows that operation to timeout to save the client hanging if there is * no broker */ public void setCloseTimeout(int closeTimeout) { this.closeTimeout = closeTimeout; } /** * @return Returns the alwaysSessionAsync. */ public boolean isAlwaysSessionAsync() { return alwaysSessionAsync; } /** * If this flag is not set then a separate thread is not used for dispatching messages for each Session in * the Connection. However, a separate thread is always used if there is more than one session, or the session * isn't in auto acknowledge or duplicates ok mode. By default this value is set to true and session dispatch * happens asynchronously. */ public void setAlwaysSessionAsync(boolean alwaysSessionAsync) { this.alwaysSessionAsync = alwaysSessionAsync; } /** * @return Returns the optimizeAcknowledge. */ public boolean isOptimizeAcknowledge() { return optimizeAcknowledge; } /** * @param optimizeAcknowledge The optimizeAcknowledge to set. */ public void setOptimizeAcknowledge(boolean optimizeAcknowledge) { this.optimizeAcknowledge = optimizeAcknowledge; } /** * The max time in milliseconds between optimized ack batches * @param optimizeAcknowledgeTimeOut */ public void setOptimizeAcknowledgeTimeOut(long optimizeAcknowledgeTimeOut) { this.optimizeAcknowledgeTimeOut = optimizeAcknowledgeTimeOut; } public long getOptimizeAcknowledgeTimeOut() { return optimizeAcknowledgeTimeOut; } public boolean isNestedMapAndListEnabled() { return nestedMapAndListEnabled; } /** * Enables/disables whether or not Message properties and MapMessage entries * support Nested * Structures of Map and List objects */ public void setNestedMapAndListEnabled(boolean structuredMapsEnabled) { this.nestedMapAndListEnabled = structuredMapsEnabled; } public String getClientIDPrefix() { return clientIDPrefix; } /** * Sets the prefix used by autogenerated JMS Client ID values which are used * if the JMS client does not explicitly specify on. * * @param clientIDPrefix */ public void setClientIDPrefix(String clientIDPrefix) { this.clientIDPrefix = clientIDPrefix; } protected synchronized IdGenerator getClientIdGenerator() { if (clientIdGenerator == null) { if (clientIDPrefix != null) { clientIdGenerator = new IdGenerator(clientIDPrefix); } else { clientIdGenerator = new IdGenerator(); } } return clientIdGenerator; } protected void setClientIdGenerator(IdGenerator clientIdGenerator) { this.clientIdGenerator = clientIdGenerator; } /** * Sets the prefix used by connection id generator * @param connectionIDPrefix */ public void setConnectionIDPrefix(String connectionIDPrefix) { this.connectionIDPrefix = connectionIDPrefix; } protected synchronized IdGenerator getConnectionIdGenerator() { if (connectionIdGenerator == null) { if (connectionIDPrefix != null) { connectionIdGenerator = new IdGenerator(connectionIDPrefix); } else { connectionIdGenerator = new IdGenerator(); } } return connectionIdGenerator; } protected void setConnectionIdGenerator(IdGenerator connectionIdGenerator) { this.connectionIdGenerator = connectionIdGenerator; } /** * @return the statsEnabled */ public boolean isStatsEnabled() { return this.factoryStats.isEnabled(); } /** * @param statsEnabled the statsEnabled to set */ public void setStatsEnabled(boolean statsEnabled) { this.factoryStats.setEnabled(statsEnabled); } public synchronized int getProducerWindowSize() { return producerWindowSize; } public synchronized void setProducerWindowSize(int producerWindowSize) { this.producerWindowSize = producerWindowSize; } public long getWarnAboutUnstartedConnectionTimeout() { return warnAboutUnstartedConnectionTimeout; } /** * Enables the timeout from a connection creation to when a warning is * generated if the connection is not properly started via * {@link Connection#start()} and a message is received by a consumer. It is * a very common gotcha to forget to start * the connection so this option makes the default case to create a * warning if the user forgets. To disable the warning just set the value to < * 0 (say -1). */ public void setWarnAboutUnstartedConnectionTimeout(long warnAboutUnstartedConnectionTimeout) { this.warnAboutUnstartedConnectionTimeout = warnAboutUnstartedConnectionTimeout; } public TransportListener getTransportListener() { return transportListener; } /** * Allows a listener to be configured on the ConnectionFactory so that when this factory is used * with frameworks which don't expose the Connection such as Spring JmsTemplate, you can still register * a transport listener. * * @param transportListener sets the listener to be registered on all connections * created by this factory */ public void setTransportListener(TransportListener transportListener) { this.transportListener = transportListener; } public ExceptionListener getExceptionListener() { return exceptionListener; } /** * Allows an {@link ExceptionListener} to be configured on the ConnectionFactory so that when this factory * is used by frameworks which don't expose the Connection such as Spring JmsTemplate, you can register * an exception listener. *

Note: access to this exceptionLinstener will not be serialized if it is associated with more than * on connection (as it will be if more than one connection is subsequently created by this connection factory) * @param exceptionListener sets the exception listener to be registered on all connections * created by this factory */ public void setExceptionListener(ExceptionListener exceptionListener) { this.exceptionListener = exceptionListener; } public int getAuditDepth() { return auditDepth; } public void setAuditDepth(int auditDepth) { this.auditDepth = auditDepth; } public int getAuditMaximumProducerNumber() { return auditMaximumProducerNumber; } public void setAuditMaximumProducerNumber(int auditMaximumProducerNumber) { this.auditMaximumProducerNumber = auditMaximumProducerNumber; } public void setUseDedicatedTaskRunner(boolean useDedicatedTaskRunner) { this.useDedicatedTaskRunner = useDedicatedTaskRunner; } public boolean isUseDedicatedTaskRunner() { return useDedicatedTaskRunner; } public void setConsumerFailoverRedeliveryWaitPeriod(long consumerFailoverRedeliveryWaitPeriod) { this.consumerFailoverRedeliveryWaitPeriod = consumerFailoverRedeliveryWaitPeriod; } public long getConsumerFailoverRedeliveryWaitPeriod() { return consumerFailoverRedeliveryWaitPeriod; } public ClientInternalExceptionListener getClientInternalExceptionListener() { return clientInternalExceptionListener; } /** * Allows an {@link ClientInternalExceptionListener} to be configured on the ConnectionFactory so that when this factory * is used by frameworks which don't expose the Connection such as Spring JmsTemplate, you can register * an exception listener. *

Note: access to this clientInternalExceptionListener will not be serialized if it is associated with more than * on connection (as it will be if more than one connection is subsequently created by this connection factory) * @param clientInternalExceptionListener sets the exception listener to be registered on all connections * created by this factory */ public void setClientInternalExceptionListener( ClientInternalExceptionListener clientInternalExceptionListener) { this.clientInternalExceptionListener = clientInternalExceptionListener; } /** * @return the checkForDuplicates */ public boolean isCheckForDuplicates() { return this.checkForDuplicates; } /** * @param checkForDuplicates the checkForDuplicates to set */ public void setCheckForDuplicates(boolean checkForDuplicates) { this.checkForDuplicates = checkForDuplicates; } public boolean isTransactedIndividualAck() { return transactedIndividualAck; } /** * when true, submit individual transacted acks immediately rather than with transaction completion. * This allows the acks to represent delivery status which can be persisted on rollback * Used in conjunction with org.apache.activemq.store.kahadb.KahaDBPersistenceAdapter#setRewriteOnRedelivery(boolean) true */ public void setTransactedIndividualAck(boolean transactedIndividualAck) { this.transactedIndividualAck = transactedIndividualAck; } public boolean isNonBlockingRedelivery() { return nonBlockingRedelivery; } /** * When true a MessageConsumer will not stop Message delivery before re-delivering Messages * from a rolled back transaction. This implies that message order will not be preserved and * also will result in the TransactedIndividualAck option to be enabled. */ public void setNonBlockingRedelivery(boolean nonBlockingRedelivery) { this.nonBlockingRedelivery = nonBlockingRedelivery; } public int getMaxThreadPoolSize() { return maxThreadPoolSize; } public void setMaxThreadPoolSize(int maxThreadPoolSize) { this.maxThreadPoolSize = maxThreadPoolSize; } public TaskRunnerFactory getSessionTaskRunner() { return sessionTaskRunner; } public void setSessionTaskRunner(TaskRunnerFactory sessionTaskRunner) { this.sessionTaskRunner = sessionTaskRunner; } public RejectedExecutionHandler getRejectedTaskHandler() { return rejectedTaskHandler; } public void setRejectedTaskHandler(RejectedExecutionHandler rejectedTaskHandler) { this.rejectedTaskHandler = rejectedTaskHandler; } /** * Gets the configured time interval that is used to force all MessageConsumers that have optimizedAcknowledge enabled * to send an ack for any outstanding Message Acks. By default this value is set to zero meaning that the consumers * will not do any background Message acknowledgment. * * @return the scheduledOptimizedAckInterval */ public long getOptimizedAckScheduledAckInterval() { return optimizedAckScheduledAckInterval; } /** * Sets the amount of time between scheduled sends of any outstanding Message Acks for consumers that * have been configured with optimizeAcknowledge enabled. * * @param optimizedAckScheduledAckInterval the scheduledOptimizedAckInterval to set */ public void setOptimizedAckScheduledAckInterval(long optimizedAckScheduledAckInterval) { this.optimizedAckScheduledAckInterval = optimizedAckScheduledAckInterval; } public boolean isRmIdFromConnectionId() { return rmIdFromConnectionId; } /** * uses the connection id as the resource identity for XAResource.isSameRM * ensuring join will only occur on a single connection */ public void setRmIdFromConnectionId(boolean rmIdFromConnectionId) { this.rmIdFromConnectionId = rmIdFromConnectionId; } /** * @return true if MessageConsumer instance will check for expired messages before dispatch. */ public boolean isConsumerExpiryCheckEnabled() { return consumerExpiryCheckEnabled; } /** * Controls whether message expiration checking is done in each MessageConsumer * prior to dispatching a message. Disabling this check can lead to consumption * of expired messages. * * @param consumerExpiryCheckEnabled * controls whether expiration checking is done prior to dispatch. */ public void setConsumerExpiryCheckEnabled(boolean consumerExpiryCheckEnabled) { this.consumerExpiryCheckEnabled = consumerExpiryCheckEnabled; } public List getTrustedPackages() { return trustedPackages; } public void setTrustedPackages(List trustedPackages) { this.trustedPackages = trustedPackages; } public boolean isTrustAllPackages() { return trustAllPackages; } public void setTrustAllPackages(boolean trustAllPackages) { this.trustAllPackages = trustAllPackages; } public int getConnectResponseTimeout() { return connectResponseTimeout; } public void setConnectResponseTimeout(int connectResponseTimeout) { this.connectResponseTimeout = connectResponseTimeout; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy