org.apache.activemq
Class ActiveMQConnection

java.lang.Object
  extended by org.apache.activemq.ActiveMQConnection
All Implemented Interfaces:
Connection, QueueConnection, TopicConnection, Closeable, EnhancedConnection, StatsCapable, StreamConnection, TransportListener
Direct Known Subclasses:
ActiveMQXAConnection, CamelConnection

public class ActiveMQConnection
extends Object
implements Connection, TopicConnection, QueueConnection, StatsCapable, Closeable, StreamConnection, TransportListener, EnhancedConnection


Field Summary
 ConcurrentHashMap<ActiveMQTempDestination,ActiveMQTempDestination> activeTempDestinations
           
protected  boolean alwaysSessionAsync
           
static String DEFAULT_BROKER_URL
           
static String DEFAULT_PASSWORD
           
static int DEFAULT_THREAD_POOL_SIZE
           
static String DEFAULT_USER
           
protected  boolean dispatchAsync
           
protected  AtomicInteger transportInterruptionProcessingComplete
           
 
Constructor Summary
protected ActiveMQConnection(Transport transport, IdGenerator clientIdGenerator, IdGenerator connectionIdGenerator, JMSStatsImpl factoryStats)
          Construct an ActiveMQConnection
 
Method Summary
protected  void addConnectionConsumer(ActiveMQConnectionConsumer connectionConsumer)
          Add a ConnectionConsumer
 void addDispatcher(ConsumerId consumerId, ActiveMQDispatcher dispatcher)
           
 void addInputStream(ActiveMQInputStream stream)
           
 void addOutputStream(ActiveMQOutputStream stream)
           
 void addProducer(ProducerId producerId, ActiveMQMessageProducer producer)
           
protected  void addSession(ActiveMQSession session)
          Used internally for adding Sessions to the Connection
 void addTransportListener(TransportListener transportListener)
          Adds a transport listener so that a client can be notified of events in the underlying transport
 void asyncSendPacket(Command command)
          send a Packet through the Connection - for internal use only
 void changeUserInfo(String userName, String password)
          Changes the associated username/password that is associated with this connection.
 void checkClientIDWasManuallySpecified()
          Ensures that the clientID was manually specified and not auto-generated.
protected  void checkClosed()
          simply throws an exception if the Connection is already closed
protected  void checkClosedOrFailed()
          simply throws an exception if the Connection is already closed or the Transport has failed
 void cleanup()
          Cleans up this connection so that it's state is as if the connection was just created.
 void cleanUpTempDestinations()
          Removes any TempDestinations that this connection has cached, ignoring any exceptions generated because the destination is in use as they should not be removed.
 void close()
          Closes the connection.
protected  BlobTransferPolicy createBlobTransferPolicy()
           
 ConnectionConsumer createConnectionConsumer(Destination destination, String messageSelector, ServerSessionPool sessionPool, int maxMessages)
          Creates a connection consumer for this connection (optional operation).
 ConnectionConsumer createConnectionConsumer(Destination destination, String messageSelector, ServerSessionPool sessionPool, int maxMessages, boolean noLocal)
           
 ConnectionConsumer createConnectionConsumer(Queue queue, String messageSelector, ServerSessionPool sessionPool, int maxMessages)
          Creates a connection consumer for this connection (optional operation).
 ConnectionConsumer createConnectionConsumer(Topic topic, String messageSelector, ServerSessionPool sessionPool, int maxMessages)
          Creates a connection consumer for this connection (optional operation).
 ConnectionConsumer createDurableConnectionConsumer(Topic topic, String subscriptionName, String messageSelector, ServerSessionPool sessionPool, int maxMessages)
          Create a durable connection consumer for this connection (optional operation).
 ConnectionConsumer createDurableConnectionConsumer(Topic topic, String subscriptionName, String messageSelector, ServerSessionPool sessionPool, int maxMessages, boolean noLocal)
          Create a durable connection consumer for this connection (optional operation).
 InputStream createDurableInputStream(Topic dest, String name)
           
 InputStream createDurableInputStream(Topic dest, String name, String messageSelector)
           
 InputStream createDurableInputStream(Topic dest, String name, String messageSelector, boolean noLocal)
           
 InputStream createDurableInputStream(Topic dest, String name, String messageSelector, boolean noLocal, long timeout)
           
 InputStream createInputStream(Destination dest)
           
 InputStream createInputStream(Destination dest, String messageSelector)
           
 InputStream createInputStream(Destination dest, String messageSelector, boolean noLocal)
           
 InputStream createInputStream(Destination dest, String messageSelector, boolean noLocal, long timeout)
           
 OutputStream createNonPersistentOutputStream(Destination dest)
          Creates a non persistent output stream; messages will not be written to disk
 OutputStream createOutputStream(Destination dest)
          Creates a persistent output stream; individual messages will be written to disk/database by the broker
 OutputStream createOutputStream(Destination dest, Map<String,Object> streamProperties, int deliveryMode, int priority, long timeToLive)
          Creates an output stream allowing full control over the delivery mode, the priority and time to live of the messages and the properties added to messages on the stream.
 QueueSession createQueueSession(boolean transacted, int acknowledgeMode)
          Creates a QueueSession object.
 Session createSession(boolean transacted, int acknowledgeMode)
          Creates a Session object.
protected  ActiveMQTempDestination createTempDestination(boolean topic)
          Create the DestinationInfo object for the temporary destination.
 TopicSession createTopicSession(boolean transacted, int acknowledgeMode)
          Creates a TopicSession object.
 void deleteTempDestination(ActiveMQTempDestination destination)
           
 void destroyDestination(ActiveMQDestination destination)
           
protected  void ensureConnectionInfoSent()
          Send the ConnectionInfo to the Broker
 void finalize()
           
 BlobTransferPolicy getBlobTransferPolicy()
           
 BrokerInfo getBrokerInfo()
          Returns the broker information if it is available or null if it is not available yet.
 String getBrokerName()
          Returns the broker name if one is available or null if one is not available yet.
 String getClientID()
          Gets the client identifier for this connection.
 ClientInternalExceptionListener getClientInternalExceptionListener()
          Gets the ClientInternalExceptionListener object for this connection.
 int getCloseTimeout()
           
 ConnectionInfo getConnectionInfo()
           
 JMSConnectionStatsImpl getConnectionStats()
           
 long getConsumerFailoverRedeliveryWaitPeriod()
           
 DestinationSource getDestinationSource()
          Returns the DestinationSource object which can be used to listen to destinations being created or destroyed or to enquire about the current destinations available on the broker
 ExceptionListener getExceptionListener()
          Gets the ExceptionListener object for this connection.
protected  ThreadPoolExecutor getExecutor()
           
 IOException getFirstFailureError()
           
 String getInitializedClientID()
           
 LongSequenceGenerator getLocalTransactionIdGenerator()
           
 int getMaxThreadPoolSize()
           
 ConnectionMetaData getMetaData()
          Gets the metadata for this connection.
protected  SessionId getNextSessionId()
           
 long getOptimizeAcknowledgeTimeOut()
           
 long getOptimizedAckScheduledAckInterval()
          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.
 ActiveMQPrefetchPolicy getPrefetchPolicy()
           
 int getProducerWindowSize()
           
 int getProtocolVersion()
           
 RedeliveryPolicy getRedeliveryPolicy()
           
 RedeliveryPolicyMap getRedeliveryPolicyMap()
          Gets the Connection's configured RedeliveryPolicyMap which will be used by all the Consumers when dealing with transaction messages that have been rolled back.
 RejectedExecutionHandler getRejectedTaskHandler()
           
 String getResourceManagerId()
           
protected  Scheduler getScheduler()
           
 int getSendTimeout()
           
 TaskRunnerFactory getSessionTaskRunner()
           
 StatsImpl getStats()
           
 long getTimeCreated()
          Returns the time this connection was created
 MessageTransformer getTransformer()
           
 Transport getTransport()
           
 Transport getTransportChannel()
           
 long getWarnAboutUnstartedConnectionTimeout()
           
 boolean isAlwaysSessionAsync()
           
 boolean isAlwaysSyncSend()
           
 boolean isCheckForDuplicates()
           
 boolean isClosed()
          Returns true if the connection is closed
 boolean isClosing()
          Returns true if the connection is in the process of being closed
 boolean isCopyMessageOnSend()
           
 boolean isDeleted(ActiveMQDestination dest)
           
 boolean isDisableTimeStampsByDefault()
           
 boolean isDispatchAsync()
           
protected  boolean isDuplicate(ActiveMQDispatcher dispatcher, Message message)
           
 boolean isExclusiveConsumer()
           
 boolean isMessagePrioritySupported()
           
 boolean isNestedMapAndListEnabled()
           
 boolean isNonBlockingRedelivery()
           
 boolean isObjectMessageSerializationDefered()
           
 boolean isOptimizeAcknowledge()
           
 boolean isOptimizedMessageDispatch()
           
 boolean isSendAcksAsync()
           
 boolean isStarted()
          Returns true if this connection has been started
 boolean isStatsEnabled()
           
 boolean isTransactedIndividualAck()
           
 boolean isTransportFailed()
          Returns true if the underlying transport has failed
 boolean isUseAsyncSend()
           
 boolean isUseCompression()
           
 boolean isUseDedicatedTaskRunner()
           
 boolean isUseRetroactiveConsumer()
           
 boolean isWatchTopicAdvisories()
           
static ActiveMQConnection makeConnection()
          A static helper method to create a new connection
static ActiveMQConnection makeConnection(String uri)
          A static helper method to create a new connection
static ActiveMQConnection makeConnection(String user, String password, String uri)
          A static helper method to create a new connection
 void onAsyncException(Throwable error)
          Used for handling async exceptions
 void onClientInternalException(Throwable error)
          Handles async client internal exceptions.
 void onCommand(Object o)
          called to process a command
protected  void onConnectionControl(ConnectionControl command)
           
protected  void onConsumerControl(ConsumerControl command)
           
protected  void onControlCommand(ControlCommand command)
           
 void onException(IOException error)
          An unrecoverable exception has occured on the transport
protected  void onWireFormatInfo(WireFormatInfo info)
           
protected  void removeConnectionConsumer(ActiveMQConnectionConsumer connectionConsumer)
          Remove a ConnectionConsumer
protected  void removeDispatcher(ActiveMQDispatcher dispatcher)
           
 void removeDispatcher(ConsumerId consumerId)
           
 void removeInputStream(ActiveMQInputStream stream)
           
 void removeOutputStream(ActiveMQOutputStream stream)
           
 void removeProducer(ProducerId producerId)
           
protected  void removeSession(ActiveMQSession session)
          Used interanlly for removing Sessions from a Connection
 void removeTransportListener(TransportListener transportListener)
           
protected  void rollbackDuplicate(ActiveMQDispatcher dispatcher, Message message)
           
 void setAlwaysSessionAsync(boolean alwaysSessionAsync)
          If this flag is not set then a separate thread is not used for dispatching messages for each Session in the Connection.
 void setAlwaysSyncSend(boolean alwaysSyncSend)
          Set true if always require messages to be sync sent
 void setAuditDepth(int auditDepth)
           
 void setAuditMaximumProducerNumber(int auditMaximumProducerNumber)
           
 void setBlobTransferPolicy(BlobTransferPolicy blobTransferPolicy)
          Sets the policy used to describe how out-of-band BLOBs (Binary Large OBjects) are transferred from producers to brokers to consumers
 void setCheckForDuplicates(boolean checkForDuplicates)
           
 void setClientID(String newClientID)
          Sets the client identifier for this connection.
 void setClientInternalExceptionListener(ClientInternalExceptionListener listener)
          Sets a client internal exception listener for this connection.
 void setCloseTimeout(int closeTimeout)
          Sets the timeout before a close is considered complete.
 void setConsumerFailoverRedeliveryWaitPeriod(long consumerFailoverRedeliveryWaitPeriod)
           
 void setCopyMessageOnSend(boolean copyMessageOnSend)
          Should a JMS message be copied to a new JMS Message object as part of the send() method in JMS.
 void setDefaultClientID(String clientID)
          Sets the default client id that the connection will use if explicitly not set with the setClientId() call.
 void setDisableTimeStampsByDefault(boolean timeStampsDisableByDefault)
          Sets whether or not timestamps on messages should be disabled or not.
 void setDispatchAsync(boolean asyncDispatch)
          Enables or disables the default setting of whether or not consumers have their messages dispatched synchronously or asynchronously by the broker.
 void setExceptionListener(ExceptionListener listener)
          Sets an exception listener for this connection.
 void setExclusiveConsumer(boolean exclusiveConsumer)
          Enables or disables whether or not queue consumers should be exclusive or not for example to preserve ordering when not using Message Groups
 void setMaxThreadPoolSize(int maxThreadPoolSize)
           
 void setMessagePrioritySupported(boolean messagePrioritySupported)
           
 void setNestedMapAndListEnabled(boolean structuredMapsEnabled)
          Enables/disables whether or not Message properties and MapMessage entries support Nested Structures of Map and List objects
 void setNonBlockingRedelivery(boolean nonBlockingRedelivery)
           
 void setObjectMessageSerializationDefered(boolean objectMessageSerializationDefered)
          When an object is set on an ObjectMessage, the JMS spec requires the object to be serialized by that set method.
 void setOptimizeAcknowledge(boolean optimizeAcknowledge)
          Enables an optimised acknowledgement mode where messages are acknowledged in batches rather than individually
 void setOptimizeAcknowledgeTimeOut(long optimizeAcknowledgeTimeOut)
          The max time in milliseconds between optimized ack batches
 void setOptimizedAckScheduledAckInterval(long optimizedAckScheduledAckInterval)
          Sets the amount of time between scheduled sends of any outstanding Message Acks for consumers that have been configured with optimizeAcknowledge enabled.
 void setOptimizedMessageDispatch(boolean dispatchOptimizedMessage)
          If this flag is set then an larger prefetch limit is used - only applicable for durable topic subscribers.
protected  void setPassword(String password)
           
 void setPrefetchPolicy(ActiveMQPrefetchPolicy prefetchPolicy)
          Sets the prefetch policy for consumers created by this connection.
 void setProducerWindowSize(int producerWindowSize)
           
 void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy)
          Sets the redelivery policy to be used when messages are rolled back
 void setRedeliveryPolicyMap(RedeliveryPolicyMap redeliveryPolicyMap)
          Sets the Connection wide RedeliveryPolicyMap for handling messages that are being rolled back.
 void setRejectedTaskHandler(RejectedExecutionHandler rejectedTaskHandler)
           
 void setSendAcksAsync(boolean sendAcksAsync)
           
 void setSendTimeout(int sendTimeout)
           
 void setSessionTaskRunner(TaskRunnerFactory sessionTaskRunner)
           
 void setStatsEnabled(boolean statsEnabled)
           
 void setTransactedIndividualAck(boolean transactedIndividualAck)
           
 void setTransformer(MessageTransformer transformer)
          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
 void setUseAsyncSend(boolean useAsyncSend)
          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.
 void setUseCompression(boolean useCompression)
          Enables the use of compression of the message bodies
 void setUseDedicatedTaskRunner(boolean useDedicatedTaskRunner)
           
 void setUseRetroactiveConsumer(boolean useRetroactiveConsumer)
          Sets whether or not retroactive consumers are enabled.
protected  void setUserName(String userName)
           
 void setWarnAboutUnstartedConnectionTimeout(long warnAboutUnstartedConnectionTimeout)
          Enables the timeout from a connection creation to when a warning is generated if the connection is not properly started via start() and a message is received by a consumer.
 void setWatchTopicAdvisories(boolean watchTopicAdvisories)
           
 void start()
          Starts (or restarts) a connection's delivery of incoming messages.
 void stop()
          Temporarily stops a connection's delivery of incoming messages.
 Response syncSendPacket(Command command)
           
 void syncSendPacket(Command command, AsyncCallback onComplete)
          Send a packet through a Connection - for internal use only
 Response syncSendPacket(Command command, int timeout)
          Send a packet through a Connection - for internal use only
 String toString()
           
protected  void transportFailed(IOException error)
           
protected  void transportInterruptionProcessingComplete()
           
 void transportInterupted()
          The transport has suffered an interuption from which it hopes to recover
 void transportResumed()
          The transport has resumed after an interuption
 void unsubscribe(String name)
          Unsubscribes a durable subscription that has been created by a client.
protected  void waitForTransportInterruptionProcessingToComplete()
           
 
Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

DEFAULT_USER

public static final String DEFAULT_USER

DEFAULT_PASSWORD

public static final String DEFAULT_PASSWORD

DEFAULT_BROKER_URL

public static final String DEFAULT_BROKER_URL
See Also:
Constant Field Values

DEFAULT_THREAD_POOL_SIZE

public static int DEFAULT_THREAD_POOL_SIZE

activeTempDestinations

public final ConcurrentHashMap<ActiveMQTempDestination,ActiveMQTempDestination> activeTempDestinations

dispatchAsync

protected boolean dispatchAsync

alwaysSessionAsync

protected boolean alwaysSessionAsync

transportInterruptionProcessingComplete

protected AtomicInteger transportInterruptionProcessingComplete
Constructor Detail

ActiveMQConnection

protected ActiveMQConnection(Transport transport,
                             IdGenerator clientIdGenerator,
                             IdGenerator connectionIdGenerator,
                             JMSStatsImpl factoryStats)
                      throws Exception
Construct an ActiveMQConnection

Parameters:
transport -
factoryStats -
Throws:
Exception
Method Detail

setUserName

protected void setUserName(String userName)

setPassword

protected void setPassword(String password)

makeConnection

public static ActiveMQConnection makeConnection()
                                         throws JMSException
A static helper method to create a new connection

Returns:
an ActiveMQConnection
Throws:
JMSException

makeConnection

public static ActiveMQConnection makeConnection(String uri)
                                         throws JMSException,
                                                URISyntaxException
A static helper method to create a new connection

Parameters:
uri -
Returns:
and ActiveMQConnection
Throws:
JMSException
URISyntaxException

makeConnection

public static ActiveMQConnection makeConnection(String user,
                                                String password,
                                                String uri)
                                         throws JMSException,
                                                URISyntaxException
A static helper method to create a new connection

Parameters:
user -
password -
uri -
Returns:
an ActiveMQConnection
Throws:
JMSException
URISyntaxException

getConnectionStats

public JMSConnectionStatsImpl getConnectionStats()
Returns:
a number unique for this connection

createSession

public Session createSession(boolean transacted,
                             int acknowledgeMode)
                      throws JMSException
Creates a Session object.

Specified by:
createSession in interface Connection
Parameters:
transacted - indicates whether the session is transacted
acknowledgeMode - indicates whether the consumer or the client will acknowledge any messages it receives; ignored if the session is transacted. Legal values are Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, and Session.DUPS_OK_ACKNOWLEDGE.
Returns:
a newly created session
Throws:
JMSException - if the Connection object fails to create a session due to some internal error or lack of support for the specific transaction and acknowledgement mode.
Since:
1.1
See Also:
Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, Session.DUPS_OK_ACKNOWLEDGE

getNextSessionId

protected SessionId getNextSessionId()
Returns:
sessionId

getClientID

public String getClientID()
                   throws JMSException
Gets the client identifier for this connection.

This value is specific to the JMS provider. It is either preconfigured by an administrator in a ConnectionFactory object or assigned dynamically by the application by calling the setClientID method.

Specified by:
getClientID in interface Connection
Returns:
the unique client identifier
Throws:
JMSException - if the JMS provider fails to return the client ID for this connection due to some internal error.

setClientID

public void setClientID(String newClientID)
                 throws JMSException
Sets the client identifier for this connection.

The preferred way to assign a JMS client's client identifier is for it to be configured in a client-specific ConnectionFactory object and transparently assigned to the Connection object it creates.

Alternatively, a client can set a connection's client identifier using a provider-specific value. The facility to set a connection's client identifier explicitly is not a mechanism for overriding the identifier that has been administratively configured. It is provided for the case where no administratively specified identifier exists. If one does exist, an attempt to change it by setting it must throw an IllegalStateException. If a client sets the client identifier explicitly, it must do so immediately after it creates the connection and before any other action on the connection is taken. After this point, setting the client identifier is a programming error that should throw an IllegalStateException.

The purpose of the client identifier is to associate a connection and its objects with a state maintained on behalf of the client by a provider. The only such state identified by the JMS API is that required to support durable subscriptions.

If another connection with the same clientID is already running when this method is called, the JMS provider should detect the duplicate ID and throw an InvalidClientIDException.

Specified by:
setClientID in interface Connection
Parameters:
newClientID - the unique client identifier
Throws:
JMSException - if the JMS provider fails to set the client ID for this connection due to some internal error.
InvalidClientIDException - if the JMS client specifies an invalid or duplicate client ID.
IllegalStateException - if the JMS client attempts to set a connection's client ID at the wrong time or when it has been administratively configured.

setDefaultClientID

public void setDefaultClientID(String clientID)
                        throws JMSException
Sets the default client id that the connection will use if explicitly not set with the setClientId() call.

Throws:
JMSException

getMetaData

public ConnectionMetaData getMetaData()
                               throws JMSException
Gets the metadata for this connection.

Specified by:
getMetaData in interface Connection
Returns:
the connection metadata
Throws:
JMSException - if the JMS provider fails to get the connection metadata for this connection.
See Also:
ConnectionMetaData

getExceptionListener

public ExceptionListener getExceptionListener()
                                       throws JMSException
Gets the ExceptionListener object for this connection. Not every Connection has an ExceptionListener associated with it.

Specified by:
getExceptionListener in interface Connection
Returns:
the ExceptionListener for this connection, or null, if no ExceptionListener is associated with this connection.
Throws:
JMSException - if the JMS provider fails to get the ExceptionListener for this connection.
See Also:
Connection.setExceptionListener(ExceptionListener)

setExceptionListener

public void setExceptionListener(ExceptionListener listener)
                          throws JMSException
Sets an exception listener for this connection.

If a JMS provider detects a serious problem with a connection, it informs the connection's ExceptionListener, if one has been registered. It does this by calling the listener's onException method, passing it a JMSException object describing the problem.

An exception listener allows a client to be notified of a problem asynchronously. Some connections only consume messages, so they would have no other way to learn their connection has failed.

A connection serializes execution of its ExceptionListener.

A JMS provider should attempt to resolve connection problems itself before it notifies the client of them.

Specified by:
setExceptionListener in interface Connection
Parameters:
listener - the exception listener
Throws:
JMSException - if the JMS provider fails to set the exception listener for this connection.

getClientInternalExceptionListener

public ClientInternalExceptionListener getClientInternalExceptionListener()
Gets the ClientInternalExceptionListener object for this connection. Not every ActiveMQConnectionn has a ClientInternalExceptionListener associated with it.

Returns:
the listener or null if no listener is registered with the connection.

setClientInternalExceptionListener

public void setClientInternalExceptionListener(ClientInternalExceptionListener listener)
Sets a client internal exception listener for this connection. The connection will notify the listener, if one has been registered, of exceptions thrown by container components (e.g. an EJB container in case of Message Driven Beans) during asynchronous processing of a message. It does this by calling the listener's onException() method passing it a Throwable describing the problem.

Parameters:
listener - the exception listener

start

public void start()
           throws JMSException
Starts (or restarts) a connection's delivery of incoming messages. A call to start on a connection that has already been started is ignored.

Specified by:
start in interface Connection
Throws:
JMSException - if the JMS provider fails to start message delivery due to some internal error.
See Also:
Connection.stop()

stop

public void stop()
          throws JMSException
Temporarily stops a connection's delivery of incoming messages. Delivery can be restarted using the connection's start method. When the connection is stopped, delivery to all the connection's message consumers is inhibited: synchronous receives block, and messages are not delivered to message listeners.

This call blocks until receives and/or message listeners in progress have completed.

Stopping a connection has no effect on its ability to send messages. A call to stop on a connection that has already been stopped is ignored.

A call to stop must not return until delivery of messages has paused. This means that a client can rely on the fact that none of its message listeners will be called and that all threads of control waiting for receive calls to return will not return with a message until the connection is restarted. The receive timers for a stopped connection continue to advance, so receives may time out while the connection is stopped.

If message listeners are running when stop is invoked, the stop call must wait until all of them have returned before it may return. While these message listeners are completing, they must have the full services of the connection available to them.

Specified by:
stop in interface Connection
Throws:
JMSException - if the JMS provider fails to stop message delivery due to some internal error.
See Also:
Connection.start()

close

public void close()
           throws JMSException
Closes the connection.

Since a provider typically allocates significant resources outside the JVM on behalf of a connection, clients should close these resources when they are not needed. Relying on garbage collection to eventually reclaim these resources may not be timely enough.

There is no need to close the sessions, producers, and consumers of a closed connection.

Closing a connection causes all temporary destinations to be deleted.

When this method is invoked, it should not return until message processing has been shut down in an orderly fashion. This means that all message listeners that may have been running have returned, and that all pending receives have returned. A close terminates all pending message receives on the connection's sessions' consumers. The receives may return with a message or with null, depending on whether there was a message available at the time of the close. If one or more of the connection's sessions' message listeners is processing a message at the time when connection close is invoked, all the facilities of the connection and its sessions must remain available to those listeners until they return control to the JMS provider.

Closing a connection causes any of its sessions' transactions in progress to be rolled back. In the case where a session's work is coordinated by an external transaction manager, a session's commit and rollback methods are not used and the result of a closed session's work is determined later by the transaction manager. Closing a connection does NOT force an acknowledgment of client-acknowledged sessions.

Invoking the acknowledge method of a received message from a closed connection's session must throw an IllegalStateException. Closing a closed connection must NOT throw an exception.

Specified by:
close in interface Connection
Specified by:
close in interface Closeable
Throws:
JMSException - if the JMS provider fails to close the connection due to some internal error. For example, a failure to release resources or to close a socket connection can cause this exception to be thrown.

createDurableConnectionConsumer

public ConnectionConsumer createDurableConnectionConsumer(Topic topic,
                                                          String subscriptionName,
                                                          String messageSelector,
                                                          ServerSessionPool sessionPool,
                                                          int maxMessages)
                                                   throws JMSException
Create a durable connection consumer for this connection (optional operation). This is an expert facility not used by regular JMS clients.

Specified by:
createDurableConnectionConsumer in interface Connection
Specified by:
createDurableConnectionConsumer in interface TopicConnection
Parameters:
topic - topic to access
subscriptionName - durable subscription name
messageSelector - only messages with properties matching the message selector expression are delivered. A value of null or an empty string indicates that there is no message selector for the message consumer.
sessionPool - the server session pool to associate with this durable connection consumer
maxMessages - the maximum number of messages that can be assigned to a server session at one time
Returns:
the durable connection consumer
Throws:
JMSException - if the Connection object fails to create a connection consumer due to some internal error or invalid arguments for sessionPool and messageSelector.
InvalidDestinationException - if an invalid destination is specified.
InvalidSelectorException - if the message selector is invalid.
Since:
1.1
See Also:
ConnectionConsumer

createDurableConnectionConsumer

public ConnectionConsumer createDurableConnectionConsumer(Topic topic,
                                                          String subscriptionName,
                                                          String messageSelector,
                                                          ServerSessionPool sessionPool,
                                                          int maxMessages,
                                                          boolean noLocal)
                                                   throws JMSException
Create a durable connection consumer for this connection (optional operation). This is an expert facility not used by regular JMS clients.

Parameters:
topic - topic to access
subscriptionName - durable subscription name
messageSelector - only messages with properties matching the message selector expression are delivered. A value of null or an empty string indicates that there is no message selector for the message consumer.
sessionPool - the server session pool to associate with this durable connection consumer
maxMessages - the maximum number of messages that can be assigned to a server session at one time
noLocal - set true if you want to filter out messages published locally
Returns:
the durable connection consumer
Throws:
JMSException - if the Connection object fails to create a connection consumer due to some internal error or invalid arguments for sessionPool and messageSelector.
InvalidDestinationException - if an invalid destination is specified.
InvalidSelectorException - if the message selector is invalid.
Since:
1.1
See Also:
ConnectionConsumer

isStarted

public boolean isStarted()
Returns true if this connection has been started

Returns:
true if this Connection is started

isClosed

public boolean isClosed()
Returns true if the connection is closed


isClosing

public boolean isClosing()
Returns true if the connection is in the process of being closed


isTransportFailed

public boolean isTransportFailed()
Returns true if the underlying transport has failed


getPrefetchPolicy

public ActiveMQPrefetchPolicy getPrefetchPolicy()
Returns:
Returns the prefetchPolicy.

setPrefetchPolicy

public void setPrefetchPolicy(ActiveMQPrefetchPolicy prefetchPolicy)
Sets the prefetch policy for consumers created by this connection.


getTransportChannel

public Transport getTransportChannel()

getInitializedClientID

public String getInitializedClientID()
                              throws JMSException
Returns:
Returns the clientID of the connection, forcing one to be generated if one has not yet been configured.
Throws:
JMSException

isDisableTimeStampsByDefault

public boolean isDisableTimeStampsByDefault()
Returns:
Returns the timeStampsDisableByDefault.

setDisableTimeStampsByDefault

public void setDisableTimeStampsByDefault(boolean timeStampsDisableByDefault)
Sets whether or not timestamps on messages should be disabled or not. If you disable them it adds a small performance boost.


isOptimizedMessageDispatch

public boolean isOptimizedMessageDispatch()
Returns:
Returns the dispatchOptimizedMessage.

setOptimizedMessageDispatch

public void setOptimizedMessageDispatch(boolean dispatchOptimizedMessage)
If this flag is set then an larger prefetch limit is used - only applicable for durable topic subscribers.


getCloseTimeout

public int getCloseTimeout()
Returns:
Returns the closeTimeout.

setCloseTimeout

public void setCloseTimeout(int 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


getConnectionInfo

public ConnectionInfo getConnectionInfo()
Returns:
ConnectionInfo

isUseRetroactiveConsumer

public boolean isUseRetroactiveConsumer()

setUseRetroactiveConsumer

public void setUseRetroactiveConsumer(boolean 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.


isNestedMapAndListEnabled

public boolean isNestedMapAndListEnabled()

setNestedMapAndListEnabled

public void setNestedMapAndListEnabled(boolean structuredMapsEnabled)
Enables/disables whether or not Message properties and MapMessage entries support Nested Structures of Map and List objects


isExclusiveConsumer

public boolean isExclusiveConsumer()

setExclusiveConsumer

public void setExclusiveConsumer(boolean exclusiveConsumer)
Enables or disables whether or not queue consumers should be exclusive or not for example to preserve ordering when not using Message Groups

Parameters:
exclusiveConsumer -

addTransportListener

public void addTransportListener(TransportListener transportListener)
Adds a transport listener so that a client can be notified of events in the underlying transport


removeTransportListener

public void removeTransportListener(TransportListener transportListener)

isUseDedicatedTaskRunner

public boolean isUseDedicatedTaskRunner()

setUseDedicatedTaskRunner

public void setUseDedicatedTaskRunner(boolean useDedicatedTaskRunner)

getSessionTaskRunner

public TaskRunnerFactory getSessionTaskRunner()

setSessionTaskRunner

public void setSessionTaskRunner(TaskRunnerFactory sessionTaskRunner)

getTransformer

public MessageTransformer getTransformer()

setTransformer

public void setTransformer(MessageTransformer transformer)
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


isStatsEnabled

public boolean isStatsEnabled()
Returns:
the statsEnabled

setStatsEnabled

public void setStatsEnabled(boolean statsEnabled)
Parameters:
statsEnabled - the statsEnabled to set

getDestinationSource

public DestinationSource getDestinationSource()
                                       throws JMSException
Returns the DestinationSource object which can be used to listen to destinations being created or destroyed or to enquire about the current destinations available on the broker

Specified by:
getDestinationSource in interface EnhancedConnection
Returns:
a lazily created destination source
Throws:
JMSException

addSession

protected void addSession(ActiveMQSession session)
                   throws JMSException
Used internally for adding Sessions to the Connection

Parameters:
session -
Throws:
JMSException
JMSException

removeSession

protected void removeSession(ActiveMQSession session)
Used interanlly for removing Sessions from a Connection

Parameters:
session -

addConnectionConsumer

protected void addConnectionConsumer(ActiveMQConnectionConsumer connectionConsumer)
                              throws JMSException
Add a ConnectionConsumer

Parameters:
connectionConsumer -
Throws:
JMSException

removeConnectionConsumer

protected void removeConnectionConsumer(ActiveMQConnectionConsumer connectionConsumer)
Remove a ConnectionConsumer

Parameters:
connectionConsumer -

createTopicSession

public TopicSession createTopicSession(boolean transacted,
                                       int acknowledgeMode)
                                throws JMSException
Creates a TopicSession object.

Specified by:
createTopicSession in interface TopicConnection
Parameters:
transacted - indicates whether the session is transacted
acknowledgeMode - indicates whether the consumer or the client will acknowledge any messages it receives; ignored if the session is transacted. Legal values are Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, and Session.DUPS_OK_ACKNOWLEDGE.
Returns:
a newly created topic session
Throws:
JMSException - if the TopicConnection object fails to create a session due to some internal error or lack of support for the specific transaction and acknowledgement mode.
See Also:
Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, Session.DUPS_OK_ACKNOWLEDGE

createConnectionConsumer

public ConnectionConsumer createConnectionConsumer(Topic topic,
                                                   String messageSelector,
                                                   ServerSessionPool sessionPool,
                                                   int maxMessages)
                                            throws JMSException
Creates a connection consumer for this connection (optional operation). This is an expert facility not used by regular JMS clients.

Specified by:
createConnectionConsumer in interface TopicConnection
Parameters:
topic - the topic to access
messageSelector - only messages with properties matching the message selector expression are delivered. A value of null or an empty string indicates that there is no message selector for the message consumer.
sessionPool - the server session pool to associate with this connection consumer
maxMessages - the maximum number of messages that can be assigned to a server session at one time
Returns:
the connection consumer
Throws:
JMSException - if the TopicConnection object fails to create a connection consumer due to some internal error or invalid arguments for sessionPool and messageSelector.
InvalidDestinationException - if an invalid topic is specified.
InvalidSelectorException - if the message selector is invalid.
See Also:
ConnectionConsumer

createConnectionConsumer

public ConnectionConsumer createConnectionConsumer(Queue queue,
                                                   String messageSelector,
                                                   ServerSessionPool sessionPool,
                                                   int maxMessages)
                                            throws JMSException
Creates a connection consumer for this connection (optional operation). This is an expert facility not used by regular JMS clients.

Specified by:
createConnectionConsumer in interface QueueConnection
Parameters:
queue - the queue to access
messageSelector - only messages with properties matching the message selector expression are delivered. A value of null or an empty string indicates that there is no message selector for the message consumer.
sessionPool - the server session pool to associate with this connection consumer
maxMessages - the maximum number of messages that can be assigned to a server session at one time
Returns:
the connection consumer
Throws:
JMSException - if the QueueConnection object fails to create a connection consumer due to some internal error or invalid arguments for sessionPool and messageSelector.
InvalidDestinationException - if an invalid queue is specified.
InvalidSelectorException - if the message selector is invalid.
See Also:
ConnectionConsumer

createConnectionConsumer

public ConnectionConsumer createConnectionConsumer(Destination destination,
                                                   String messageSelector,
                                                   ServerSessionPool sessionPool,
                                                   int maxMessages)
                                            throws JMSException
Creates a connection consumer for this connection (optional operation). This is an expert facility not used by regular JMS clients.

Specified by:
createConnectionConsumer in interface Connection
Parameters:
destination - the destination to access
messageSelector - only messages with properties matching the message selector expression are delivered. A value of null or an empty string indicates that there is no message selector for the message consumer.
sessionPool - the server session pool to associate with this connection consumer
maxMessages - the maximum number of messages that can be assigned to a server session at one time
Returns:
the connection consumer
Throws:
JMSException - if the Connection object fails to create a connection consumer due to some internal error or invalid arguments for sessionPool and messageSelector.
InvalidDestinationException - if an invalid destination is specified.
InvalidSelectorException - if the message selector is invalid.
Since:
1.1
See Also:
ConnectionConsumer

createConnectionConsumer

public ConnectionConsumer createConnectionConsumer(Destination destination,
                                                   String messageSelector,
                                                   ServerSessionPool sessionPool,
                                                   int maxMessages,
                                                   boolean noLocal)
                                            throws JMSException
Throws:
JMSException

createQueueSession

public QueueSession createQueueSession(boolean transacted,
                                       int acknowledgeMode)
                                throws JMSException
Creates a QueueSession object.

Specified by:
createQueueSession in interface QueueConnection
Parameters:
transacted - indicates whether the session is transacted
acknowledgeMode - indicates whether the consumer or the client will acknowledge any messages it receives; ignored if the session is transacted. Legal values are Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, and Session.DUPS_OK_ACKNOWLEDGE.
Returns:
a newly created queue session
Throws:
JMSException - if the QueueConnection object fails to create a session due to some internal error or lack of support for the specific transaction and acknowledgement mode.
See Also:
Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, Session.DUPS_OK_ACKNOWLEDGE

checkClientIDWasManuallySpecified

public void checkClientIDWasManuallySpecified()
                                       throws JMSException
Ensures that the clientID was manually specified and not auto-generated. If the clientID was not specified this method will throw an exception. This method is used to ensure that the clientID + durableSubscriber name are used correctly.

Throws:
JMSException

asyncSendPacket

public void asyncSendPacket(Command command)
                     throws JMSException
send a Packet through the Connection - for internal use only

Parameters:
command -
Throws:
JMSException

syncSendPacket

public void syncSendPacket(Command command,
                           AsyncCallback onComplete)
                    throws JMSException
Send a packet through a Connection - for internal use only

Parameters:
command -
Throws:
JMSException

syncSendPacket

public Response syncSendPacket(Command command)
                        throws JMSException
Throws:
JMSException

syncSendPacket

public Response syncSendPacket(Command command,
                               int timeout)
                        throws JMSException
Send a packet through a Connection - for internal use only

Parameters:
command -
Returns:
Throws:
JMSException

getStats

public StatsImpl getStats()
Specified by:
getStats in interface StatsCapable
Returns:
statistics for this Connection

checkClosedOrFailed

protected void checkClosedOrFailed()
                            throws JMSException
simply throws an exception if the Connection is already closed or the Transport has failed

Throws:
JMSException

checkClosed

protected void checkClosed()
                    throws JMSException
simply throws an exception if the Connection is already closed

Throws:
JMSException

ensureConnectionInfoSent

protected void ensureConnectionInfoSent()
                                 throws JMSException
Send the ConnectionInfo to the Broker

Throws:
JMSException

isWatchTopicAdvisories

public boolean isWatchTopicAdvisories()

setWatchTopicAdvisories

public void setWatchTopicAdvisories(boolean watchTopicAdvisories)

isUseAsyncSend

public boolean isUseAsyncSend()
Returns:
Returns the useAsyncSend.

setUseAsyncSend

public void setUseAsyncSend(boolean useAsyncSend)
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.


isAlwaysSyncSend

public boolean isAlwaysSyncSend()
Returns:
true if always sync send messages

setAlwaysSyncSend

public void setAlwaysSyncSend(boolean alwaysSyncSend)
Set true if always require messages to be sync sent

Parameters:
alwaysSyncSend -

isMessagePrioritySupported

public boolean isMessagePrioritySupported()
Returns:
the messagePrioritySupported

setMessagePrioritySupported

public void setMessagePrioritySupported(boolean messagePrioritySupported)
Parameters:
messagePrioritySupported - the messagePrioritySupported to set

cleanup

public void cleanup()
             throws JMSException
Cleans up this connection so that it's state is as if the connection was just created. This allows the Resource Adapter to clean up a connection so that it can be reused without having to close and recreate the connection.

Throws:
JMSException

finalize

public void finalize()
              throws Throwable
Overrides:
finalize in class Object
Throws:
Throwable

changeUserInfo

public void changeUserInfo(String userName,
                           String password)
                    throws JMSException
Changes the associated username/password that is associated with this connection. If the connection has been used, you must called cleanup() before calling this method.

Throws:
IllegalStateException - if the connection is in used.
JMSException

getResourceManagerId

public String getResourceManagerId()
                            throws JMSException
Returns:
Returns the resourceManagerId.
Throws:
JMSException

getBrokerName

public String getBrokerName()
Returns the broker name if one is available or null if one is not available yet.


getBrokerInfo

public BrokerInfo getBrokerInfo()
Returns the broker information if it is available or null if it is not available yet.


getRedeliveryPolicy

public RedeliveryPolicy getRedeliveryPolicy()
                                     throws JMSException
Returns:
Returns the RedeliveryPolicy.
Throws:
JMSException

setRedeliveryPolicy

public void setRedeliveryPolicy(RedeliveryPolicy redeliveryPolicy)
Sets the redelivery policy to be used when messages are rolled back


getBlobTransferPolicy

public BlobTransferPolicy getBlobTransferPolicy()

setBlobTransferPolicy

public void setBlobTransferPolicy(BlobTransferPolicy blobTransferPolicy)
Sets the policy used to describe how out-of-band BLOBs (Binary Large OBjects) are transferred from producers to brokers to consumers


isAlwaysSessionAsync

public boolean isAlwaysSessionAsync()
Returns:
Returns the alwaysSessionAsync.

setAlwaysSessionAsync

public void setAlwaysSessionAsync(boolean 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.


isOptimizeAcknowledge

public boolean isOptimizeAcknowledge()
Returns:
Returns the optimizeAcknowledge.

setOptimizeAcknowledge

public void setOptimizeAcknowledge(boolean optimizeAcknowledge)
Enables an optimised acknowledgement mode where messages are acknowledged in batches rather than individually

Parameters:
optimizeAcknowledge - The optimizeAcknowledge to set.

setOptimizeAcknowledgeTimeOut

public void setOptimizeAcknowledgeTimeOut(long optimizeAcknowledgeTimeOut)
The max time in milliseconds between optimized ack batches

Parameters:
optimizeAcknowledgeTimeOut -

getOptimizeAcknowledgeTimeOut

public long getOptimizeAcknowledgeTimeOut()

getWarnAboutUnstartedConnectionTimeout

public long getWarnAboutUnstartedConnectionTimeout()

setWarnAboutUnstartedConnectionTimeout

public void setWarnAboutUnstartedConnectionTimeout(long warnAboutUnstartedConnectionTimeout)
Enables the timeout from a connection creation to when a warning is generated if the connection is not properly started via 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).


getSendTimeout

public int getSendTimeout()
Returns:
the sendTimeout

setSendTimeout

public void setSendTimeout(int sendTimeout)
Parameters:
sendTimeout - the sendTimeout to set

isSendAcksAsync

public boolean isSendAcksAsync()
Returns:
the sendAcksAsync

setSendAcksAsync

public void setSendAcksAsync(boolean sendAcksAsync)
Parameters:
sendAcksAsync - the sendAcksAsync to set

getTimeCreated

public long getTimeCreated()
Returns the time this connection was created


getTransport

public Transport getTransport()

addProducer

public void addProducer(ProducerId producerId,
                        ActiveMQMessageProducer producer)

removeProducer

public void removeProducer(ProducerId producerId)

addDispatcher

public void addDispatcher(ConsumerId consumerId,
                          ActiveMQDispatcher dispatcher)

removeDispatcher

public void removeDispatcher(ConsumerId consumerId)

onCommand

public void onCommand(Object o)
Description copied from interface: TransportListener
called to process a command

Specified by:
onCommand in interface TransportListener
Parameters:
o - - the command to consume

onWireFormatInfo

protected void onWireFormatInfo(WireFormatInfo info)

onClientInternalException

public void onClientInternalException(Throwable error)
Handles async client internal exceptions. A client internal exception is usually one that has been thrown by a container runtime component during asynchronous processing of a message that does not affect the connection itself. This method notifies the ClientInternalExceptionListener by invoking its onException method, if one has been registered with this connection.

Parameters:
error - the exception that the problem

onAsyncException

public void onAsyncException(Throwable error)
Used for handling async exceptions

Parameters:
error -

onException

public void onException(IOException error)
Description copied from interface: TransportListener
An unrecoverable exception has occured on the transport

Specified by:
onException in interface TransportListener

transportInterupted

public void transportInterupted()
Description copied from interface: TransportListener
The transport has suffered an interuption from which it hopes to recover

Specified by:
transportInterupted in interface TransportListener

transportResumed

public void transportResumed()
Description copied from interface: TransportListener
The transport has resumed after an interuption

Specified by:
transportResumed in interface TransportListener

createTempDestination

protected ActiveMQTempDestination createTempDestination(boolean topic)
                                                 throws JMSException
Create the DestinationInfo object for the temporary destination.

Parameters:
topic - - if its true topic, else queue.
Returns:
DestinationInfo
Throws:
JMSException

deleteTempDestination

public void deleteTempDestination(ActiveMQTempDestination destination)
                           throws JMSException
Parameters:
destination -
Throws:
JMSException

isDeleted

public boolean isDeleted(ActiveMQDestination dest)

isCopyMessageOnSend

public boolean isCopyMessageOnSend()

getLocalTransactionIdGenerator

public LongSequenceGenerator getLocalTransactionIdGenerator()

isUseCompression

public boolean isUseCompression()

setUseCompression

public void setUseCompression(boolean useCompression)
Enables the use of compression of the message bodies


destroyDestination

public void destroyDestination(ActiveMQDestination destination)
                        throws JMSException
Throws:
JMSException

isDispatchAsync

public boolean isDispatchAsync()

setDispatchAsync

public void setDispatchAsync(boolean asyncDispatch)
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.

Parameters:
asyncDispatch - If true then consumers created on this connection will default to having their messages dispatched asynchronously. The default value is true.

isObjectMessageSerializationDefered

public boolean isObjectMessageSerializationDefered()

setObjectMessageSerializationDefered

public void setObjectMessageSerializationDefered(boolean 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.


createInputStream

public InputStream createInputStream(Destination dest)
                              throws JMSException
Specified by:
createInputStream in interface StreamConnection
Throws:
JMSException

createInputStream

public InputStream createInputStream(Destination dest,
                                     String messageSelector)
                              throws JMSException
Specified by:
createInputStream in interface StreamConnection
Throws:
JMSException

createInputStream

public InputStream createInputStream(Destination dest,
                                     String messageSelector,
                                     boolean noLocal)
                              throws JMSException
Specified by:
createInputStream in interface StreamConnection
Throws:
JMSException

createInputStream

public InputStream createInputStream(Destination dest,
                                     String messageSelector,
                                     boolean noLocal,
                                     long timeout)
                              throws JMSException
Specified by:
createInputStream in interface StreamConnection
Throws:
JMSException

createDurableInputStream

public InputStream createDurableInputStream(Topic dest,
                                            String name)
                                     throws JMSException
Specified by:
createDurableInputStream in interface StreamConnection
Throws:
JMSException

createDurableInputStream

public InputStream createDurableInputStream(Topic dest,
                                            String name,
                                            String messageSelector)
                                     throws JMSException
Specified by:
createDurableInputStream in interface StreamConnection
Throws:
JMSException

createDurableInputStream

public InputStream createDurableInputStream(Topic dest,
                                            String name,
                                            String messageSelector,
                                            boolean noLocal)
                                     throws JMSException
Specified by:
createDurableInputStream in interface StreamConnection
Throws:
JMSException

createDurableInputStream

public InputStream createDurableInputStream(Topic dest,
                                            String name,
                                            String messageSelector,
                                            boolean noLocal,
                                            long timeout)
                                     throws JMSException
Specified by:
createDurableInputStream in interface StreamConnection
Throws:
JMSException

createOutputStream

public OutputStream createOutputStream(Destination dest)
                                throws JMSException
Creates a persistent output stream; individual messages will be written to disk/database by the broker

Specified by:
createOutputStream in interface StreamConnection
Throws:
JMSException

createNonPersistentOutputStream

public OutputStream createNonPersistentOutputStream(Destination dest)
                                             throws JMSException
Creates a non persistent output stream; messages will not be written to disk

Throws:
JMSException

createOutputStream

public OutputStream createOutputStream(Destination dest,
                                       Map<String,Object> streamProperties,
                                       int deliveryMode,
                                       int priority,
                                       long timeToLive)
                                throws JMSException
Creates an output stream allowing full control over the delivery mode, the priority and time to live of the messages and the properties added to messages on the stream.

Specified by:
createOutputStream in interface StreamConnection
Parameters:
streamProperties - defines a map of key-value pairs where the keys are strings and the values are primitive values (numbers and strings) which are appended to the messages similarly to using the Message.setObjectProperty(String, Object) method
Throws:
JMSException

unsubscribe

public void unsubscribe(String name)
                 throws InvalidDestinationException,
                        JMSException
Unsubscribes a durable subscription that has been created by a client.

This method deletes the state being maintained on behalf of the subscriber by its provider.

It is erroneous for a client to delete a durable subscription while there is an active MessageConsumer or TopicSubscriber for the subscription, or while a consumed message is part of a pending transaction or has not been acknowledged in the session.

Specified by:
unsubscribe in interface StreamConnection
Parameters:
name - the name used to identify this subscription
Throws:
JMSException - if the session fails to unsubscribe to the durable subscription due to some internal error.
InvalidDestinationException - if an invalid subscription name is specified.
Since:
1.1

addOutputStream

public void addOutputStream(ActiveMQOutputStream stream)

removeOutputStream

public void removeOutputStream(ActiveMQOutputStream stream)

addInputStream

public void addInputStream(ActiveMQInputStream stream)

removeInputStream

public void removeInputStream(ActiveMQInputStream stream)

onControlCommand

protected void onControlCommand(ControlCommand command)

onConnectionControl

protected void onConnectionControl(ConnectionControl command)

onConsumerControl

protected void onConsumerControl(ConsumerControl command)

transportFailed

protected void transportFailed(IOException error)

setCopyMessageOnSend

public void setCopyMessageOnSend(boolean 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


toString

public String toString()
Overrides:
toString in class Object

createBlobTransferPolicy

protected BlobTransferPolicy createBlobTransferPolicy()

getProtocolVersion

public int getProtocolVersion()

getProducerWindowSize

public int getProducerWindowSize()

setProducerWindowSize

public void setProducerWindowSize(int producerWindowSize)

setAuditDepth

public void setAuditDepth(int auditDepth)

setAuditMaximumProducerNumber

public void setAuditMaximumProducerNumber(int auditMaximumProducerNumber)

removeDispatcher

protected void removeDispatcher(ActiveMQDispatcher dispatcher)

isDuplicate

protected boolean isDuplicate(ActiveMQDispatcher dispatcher,
                              Message message)

rollbackDuplicate

protected void rollbackDuplicate(ActiveMQDispatcher dispatcher,
                                 Message message)

getFirstFailureError

public IOException getFirstFailureError()

waitForTransportInterruptionProcessingToComplete

protected void waitForTransportInterruptionProcessingToComplete()
                                                         throws InterruptedException
Throws:
InterruptedException

transportInterruptionProcessingComplete

protected void transportInterruptionProcessingComplete()

setConsumerFailoverRedeliveryWaitPeriod

public void setConsumerFailoverRedeliveryWaitPeriod(long consumerFailoverRedeliveryWaitPeriod)

getConsumerFailoverRedeliveryWaitPeriod

public long getConsumerFailoverRedeliveryWaitPeriod()

getScheduler

protected Scheduler getScheduler()
                          throws JMSException
Throws:
JMSException

getExecutor

protected ThreadPoolExecutor getExecutor()

isCheckForDuplicates

public boolean isCheckForDuplicates()
Returns:
the checkForDuplicates

setCheckForDuplicates

public void setCheckForDuplicates(boolean checkForDuplicates)
Parameters:
checkForDuplicates - the checkForDuplicates to set

isTransactedIndividualAck

public boolean isTransactedIndividualAck()

setTransactedIndividualAck

public void setTransactedIndividualAck(boolean transactedIndividualAck)

isNonBlockingRedelivery

public boolean isNonBlockingRedelivery()

setNonBlockingRedelivery

public void setNonBlockingRedelivery(boolean nonBlockingRedelivery)

cleanUpTempDestinations

public void cleanUpTempDestinations()
Removes any TempDestinations that this connection has cached, ignoring any exceptions generated because the destination is in use as they should not be removed. Used from a pooled connection, b/c it will not be explicitly closed.


setRedeliveryPolicyMap

public void setRedeliveryPolicyMap(RedeliveryPolicyMap redeliveryPolicyMap)
Sets the Connection wide RedeliveryPolicyMap for handling messages that are being rolled back.

Parameters:
redeliveryPolicyMap - the redeliveryPolicyMap to set

getRedeliveryPolicyMap

public RedeliveryPolicyMap getRedeliveryPolicyMap()
Gets the Connection's configured RedeliveryPolicyMap which will be used by all the Consumers when dealing with transaction messages that have been rolled back.

Returns:
the redeliveryPolicyMap

getMaxThreadPoolSize

public int getMaxThreadPoolSize()

setMaxThreadPoolSize

public void setMaxThreadPoolSize(int maxThreadPoolSize)

getRejectedTaskHandler

public RejectedExecutionHandler getRejectedTaskHandler()

setRejectedTaskHandler

public void setRejectedTaskHandler(RejectedExecutionHandler rejectedTaskHandler)

getOptimizedAckScheduledAckInterval

public long getOptimizedAckScheduledAckInterval()
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.

Returns:
the scheduledOptimizedAckInterval

setOptimizedAckScheduledAckInterval

public void setOptimizedAckScheduledAckInterval(long optimizedAckScheduledAckInterval)
Sets the amount of time between scheduled sends of any outstanding Message Acks for consumers that have been configured with optimizeAcknowledge enabled.

Parameters:
optimizedAckScheduledAckInterval - the scheduledOptimizedAckInterval to set


Copyright © 2005–2013 The Apache Software Foundation. All rights reserved.