public class HornetQConnection extends Object implements TopicConnection, QueueConnection
TopicConnection
and QueueConnection
is per design,
following the common usage of these as one flat API in JMS 1.1.Modifier and Type | Field and Description |
---|---|
static SimpleString |
CONNECTION_ID_PROPERTY_NAME |
static String |
EXCEPTION_DISCONNECT |
static String |
EXCEPTION_FAILOVER |
static int |
TYPE_GENERIC_CONNECTION |
static int |
TYPE_QUEUE_CONNECTION |
static int |
TYPE_TOPIC_CONNECTION |
Constructor and Description |
---|
HornetQConnection(String username,
String password,
int connectionType,
String clientID,
int dupsOKBatchSize,
int transactionBatchSize,
ClientSessionFactory sessionFactory) |
Modifier and Type | Method and Description |
---|---|
void |
addTemporaryQueue(SimpleString queueAddress) |
void |
authorize() |
protected void |
checkClosed() |
void |
close()
Closes the connection.
|
boolean |
containsTemporaryQueue(SimpleString queueAddress) |
ConnectionConsumer |
createConnectionConsumer(Destination destination,
String messageSelector,
ServerSessionPool sessionPool,
int maxMessages)
Creates a connection consumer for this connection (optional operation).
|
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).
|
protected HornetQSession |
createHQSession(boolean isXA,
boolean transacted,
int acknowledgeMode,
ClientSession session,
int type) |
Session |
createNonXAQueueSession(boolean transacted,
int acknowledgeMode)
This internal method serves basically the Resource Adapter.
|
Session |
createNonXASession(boolean transacted,
int acknowledgeMode)
This internal method serves basically the Resource Adapter.
|
Session |
createNonXATopicSession(boolean transacted,
int acknowledgeMode)
This internal method serves basically the Resource Adapter.
|
QueueSession |
createQueueSession(boolean transacted,
int acknowledgeMode)
Creates a
QueueSession object. |
Session |
createSession(boolean transacted,
int acknowledgeMode)
Creates a
Session object. |
protected HornetQSession |
createSessionInternal(boolean isXA,
boolean transacted,
int acknowledgeMode,
int type) |
TopicSession |
createTopicSession(boolean transacted,
int acknowledgeMode)
Creates a
TopicSession object. |
protected void |
finalize() |
String |
getClientID()
Gets the client identifier for this connection.
|
ExceptionListener |
getExceptionListener()
Gets the
ExceptionListener object for this connection. |
FailoverEventListener |
getFailoverListener() |
ClientSession |
getInitialSession() |
ConnectionMetaData |
getMetaData()
Gets the metadata for this connection.
|
SimpleString |
getUID() |
boolean |
hasNoLocal() |
protected boolean |
isXA() |
void |
removeSession(HornetQSession session) |
void |
removeTemporaryQueue(SimpleString queueAddress) |
void |
setClientID(String clientID)
Sets the client identifier for this connection.
|
void |
setExceptionListener(ExceptionListener listener)
Sets an exception listener for this connection.
|
void |
setFailoverListener(FailoverEventListener listener)
Sets a FailureListener for the session which is notified if a failure occurs on the session.
|
void |
setHasNoLocal() |
void |
setReference(HornetQConnectionFactory factory) |
void |
signalStopToAllSessions() |
void |
start()
Starts (or restarts) a connection's delivery of incoming messages.
|
void |
stop()
Temporarily stops a connection's delivery of incoming messages.
|
public static final int TYPE_GENERIC_CONNECTION
public static final int TYPE_QUEUE_CONNECTION
public static final int TYPE_TOPIC_CONNECTION
public static final String EXCEPTION_FAILOVER
public static final String EXCEPTION_DISCONNECT
public static final SimpleString CONNECTION_ID_PROPERTY_NAME
public HornetQConnection(String username, String password, int connectionType, String clientID, int dupsOKBatchSize, int transactionBatchSize, ClientSessionFactory sessionFactory)
public Session createNonXASession(boolean transacted, int acknowledgeMode) throws JMSException
JMSException
public Session createNonXATopicSession(boolean transacted, int acknowledgeMode) throws JMSException
JMSException
public Session createNonXAQueueSession(boolean transacted, int acknowledgeMode) throws JMSException
JMSException
public Session createSession(boolean transacted, int acknowledgeMode) throws JMSException
Connection
Session
object.createSession
in interface Connection
transacted
- indicates whether the session is transactedacknowledgeMode
- 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
.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.Session.AUTO_ACKNOWLEDGE
,
Session.CLIENT_ACKNOWLEDGE
,
Session.DUPS_OK_ACKNOWLEDGE
public String getClientID() throws JMSException
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.
getClientID
in interface Connection
JMSException
- if the JMS provider fails to return
the client ID for this connection due
to some internal error.public void setClientID(String clientID) throws JMSException
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
.
setClientID
in interface Connection
clientID
- the unique client identifierJMSException
- 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.public ConnectionMetaData getMetaData() throws JMSException
Connection
getMetaData
in interface Connection
JMSException
- if the JMS provider fails to
get the connection metadata for this connection.ConnectionMetaData
public ExceptionListener getExceptionListener() throws JMSException
Connection
ExceptionListener
object for this connection.
Not every Connection
has an ExceptionListener
associated with it.getExceptionListener
in interface Connection
ExceptionListener
for this connection, or null.
if no ExceptionListener
is associated
with this connection.JMSException
- if the JMS provider fails to
get the ExceptionListener
for this
connection.Connection.setExceptionListener(javax.jms.ExceptionListener)
public void setExceptionListener(ExceptionListener listener) throws JMSException
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.
setExceptionListener
in interface Connection
listener
- the exception listenerJMSException
- if the JMS provider fails to
set the exception listener for this connection.public void start() throws JMSException
Connection
start
on a connection that has already been
started is ignored.start
in interface Connection
JMSException
- if the JMS provider fails to start
message delivery due to some internal error.Connection.stop()
public void signalStopToAllSessions()
public void stop() throws JMSException
Connection
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.
stop
in interface Connection
JMSException
- if the JMS provider fails to stop
message delivery due to some internal error.Connection.start()
public final void close() throws JMSException
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.
close
in interface Connection
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.public ConnectionConsumer createConnectionConsumer(Destination destination, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException
Connection
createConnectionConsumer
in interface Connection
destination
- the destination to accessmessageSelector
- 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 consumermaxMessages
- the maximum number of messages that can be
assigned to a server session at one timeJMSException
- 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.ConnectionConsumer
public ConnectionConsumer createDurableConnectionConsumer(Topic topic, String subscriptionName, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException
TopicConnection
createDurableConnectionConsumer
in interface Connection
createDurableConnectionConsumer
in interface TopicConnection
topic
- the topic to accesssubscriptionName
- durable subscription namemessageSelector
- 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 consumermaxMessages
- the maximum number of messages that can be
assigned to a server session at one timeJMSException
- 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.ConnectionConsumer
public QueueSession createQueueSession(boolean transacted, int acknowledgeMode) throws JMSException
QueueConnection
QueueSession
object.createQueueSession
in interface QueueConnection
transacted
- indicates whether the session is transactedacknowledgeMode
- 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
.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.Session.AUTO_ACKNOWLEDGE
,
Session.CLIENT_ACKNOWLEDGE
,
Session.DUPS_OK_ACKNOWLEDGE
public ConnectionConsumer createConnectionConsumer(Queue queue, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException
QueueConnection
createConnectionConsumer
in interface QueueConnection
queue
- the queue to accessmessageSelector
- 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 consumermaxMessages
- the maximum number of messages that can be
assigned to a server session at one timeJMSException
- 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.ConnectionConsumer
public TopicSession createTopicSession(boolean transacted, int acknowledgeMode) throws JMSException
TopicConnection
TopicSession
object.createTopicSession
in interface TopicConnection
transacted
- indicates whether the session is transactedacknowledgeMode
- 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
.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.Session.AUTO_ACKNOWLEDGE
,
Session.CLIENT_ACKNOWLEDGE
,
Session.DUPS_OK_ACKNOWLEDGE
public ConnectionConsumer createConnectionConsumer(Topic topic, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException
TopicConnection
createConnectionConsumer
in interface TopicConnection
topic
- the topic to accessmessageSelector
- 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 consumermaxMessages
- the maximum number of messages that can be
assigned to a server session at one timeJMSException
- 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.ConnectionConsumer
public void setFailoverListener(FailoverEventListener listener) throws JMSException
listener
- the listener to addJMSException
public FailoverEventListener getFailoverListener() throws JMSException
FailoverEventListener
the current failover event listener for this connectionJMSException
public void addTemporaryQueue(SimpleString queueAddress)
public void removeTemporaryQueue(SimpleString queueAddress)
public boolean containsTemporaryQueue(SimpleString queueAddress)
public boolean hasNoLocal()
public void setHasNoLocal()
public SimpleString getUID()
public void removeSession(HornetQSession session)
public ClientSession getInitialSession()
protected final void finalize() throws Throwable
protected boolean isXA()
protected final HornetQSession createSessionInternal(boolean isXA, boolean transacted, int acknowledgeMode, int type) throws JMSException
JMSException
protected HornetQSession createHQSession(boolean isXA, boolean transacted, int acknowledgeMode, ClientSession session, int type)
transacted
- acknowledgeMode
- session
- type
- protected final void checkClosed() throws JMSException
JMSException
public void authorize() throws JMSException
JMSException
public void setReference(HornetQConnectionFactory factory)
Copyright © 2018 JBoss by Red Hat. All rights reserved.