org.jboss.resource.adapter.jms.JmsSessionFactoryImpl
|
||||||||||
| PREV CLASS (src) NEXT CLASS (src) | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Object
Implements the JMS Connection API and produces JmsSession (src) objects.
Created: Thu Mar 29 15:36:51 2001
| Field Summary |
| Fields inherited from interface org.jboss.resource.adapter.jms.JmsSessionFactory (src) |
ISE |
| Constructor Summary | |
JmsSessionFactoryImpl(ManagedConnectionFactory (src) mcf,
ConnectionManager (src) cm,
int type)
|
|
| Method Summary | |
void |
addTemporaryQueue(TemporaryQueue (src) temp)
Add a temporary queue |
void |
addTemporaryTopic(TemporaryTopic (src) temp)
Add a temporary topic |
protected JmsSession (src) |
allocateConnection(boolean transacted,
int acknowledgeMode,
int sessionType)
|
protected void |
checkClosed()
|
void |
close()
Closes the connection. |
void |
closeSession(JmsSession (src) session)
Notification that a session is closed |
ConnectionConsumer (src) |
createConnectionConsumer(Destination (src) destination,
ServerSessionPool (src) pool,
int maxMessages)
|
ConnectionConsumer (src) |
createConnectionConsumer(Destination (src) destination,
java.lang.String name,
ServerSessionPool (src) pool,
int maxMessages)
Creates a connection consumer for this connection (optional operation). |
ConnectionConsumer (src) |
createConnectionConsumer(Queue (src) queue,
java.lang.String messageSelector,
ServerSessionPool (src) sessionPool,
int maxMessages)
Creates a connection consumer for this connection (optional operation). |
ConnectionConsumer (src) |
createConnectionConsumer(Topic (src) topic,
java.lang.String messageSelector,
ServerSessionPool (src) sessionPool,
int maxMessages)
Creates a connection consumer for this connection (optional operation). |
ConnectionConsumer (src) |
createDurableConnectionConsumer(Topic (src) topic,
java.lang.String subscriptionName,
java.lang.String messageSelector,
ServerSessionPool (src) sessionPool,
int maxMessages)
Create a durable connection consumer for this connection (optional operation). |
QueueSession (src) |
createQueueSession(boolean transacted,
int acknowledgeMode)
Creates a QueueSession object. |
Session (src) |
createSession(boolean transacted,
int acknowledgeMode)
Creates a Session object. |
TopicSession (src) |
createTopicSession(boolean transacted,
int acknowledgeMode)
Creates a TopicSession object. |
java.lang.String |
getClientID()
Gets the client identifier for this connection. |
ExceptionListener (src) |
getExceptionListener()
Gets the ExceptionListener object for this connection. |
ConnectionMetaData (src) |
getMetaData()
Gets the metadata for this connection. |
javax.naming.Reference |
getReference()
|
void |
setClientID(java.lang.String cID)
Sets the client identifier for this connection. |
void |
setExceptionListener(ExceptionListener (src) listener)
Sets an exception listener for this connection. |
void |
setPassword(java.lang.String password)
|
void |
setReference(javax.naming.Reference reference)
Sets the reference instance |
void |
setUserName(java.lang.String name)
|
void |
start()
Starts (or restarts) a connection's delivery of incoming messages. |
void |
stop()
Temporarily stops a connection's delivery of incoming messages. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
public JmsSessionFactoryImpl(ManagedConnectionFactory (src) mcf,
ConnectionManager (src) cm,
int type)
| Method Detail |
public void setReference(javax.naming.Reference reference)
Referenceable (src)
setReference in interface Referenceable (src) reference - the referencepublic javax.naming.Reference getReference()
getReference in interface javax.naming.Referenceablepublic void setUserName(java.lang.String name)
public void setPassword(java.lang.String password)
public QueueSession (src) createQueueSession(boolean transacted,
int acknowledgeMode)
throws JMSException (src)
QueueConnection (src) QueueSession object.
createQueueSession in interface QueueConnection (src) 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 (src) - 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 (src) createConnectionConsumer(Queue (src) queue,
java.lang.String messageSelector,
ServerSessionPool (src) sessionPool,
int maxMessages)
throws JMSException (src)
QueueConnection (src)
createConnectionConsumer in interface QueueConnection (src) 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 time
JMSException (src) - if the QueueConnection object fails
to create a connection consumer due to some
internal error or invalid arguments for
sessionPool and
messageSelector.ConnectionConsumer (src)
public TopicSession (src) createTopicSession(boolean transacted,
int acknowledgeMode)
throws JMSException (src)
TopicConnection (src) TopicSession object.
createTopicSession in interface TopicConnection (src) 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 (src) - 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 (src) createConnectionConsumer(Topic (src) topic,
java.lang.String messageSelector,
ServerSessionPool (src) sessionPool,
int maxMessages)
throws JMSException (src)
TopicConnection (src)
createConnectionConsumer in interface TopicConnection (src) 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 time
JMSException (src) - if the TopicConnection object fails
to create a connection consumer due to some
internal error or invalid arguments for
sessionPool and
messageSelector.ConnectionConsumer (src)
public ConnectionConsumer (src) createDurableConnectionConsumer(Topic (src) topic,
java.lang.String subscriptionName,
java.lang.String messageSelector,
ServerSessionPool (src) sessionPool,
int maxMessages)
throws JMSException (src)
Connection (src)
createDurableConnectionConsumer in interface Connection (src) topic - 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 time
JMSException (src) - if the Connection object fails
to create a connection consumer due to some
internal error or invalid arguments for
sessionPool and
messageSelector.ConnectionConsumer (src)
public java.lang.String getClientID()
throws JMSException (src)
Connection (src) 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 (src) JMSException (src) - if the JMS provider fails to return
the client ID for this connection due
to some internal error.
public void setClientID(java.lang.String cID)
throws JMSException (src)
Connection (src) 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 (src) cID - the unique client identifier
JMSException (src) - if the JMS provider fails to
set the client ID for this connection due
to some internal error.
public ConnectionMetaData (src) getMetaData()
throws JMSException (src)
Connection (src)
getMetaData in interface Connection (src) JMSException (src) - if the JMS provider fails to
get the connection metadata for this connection.ConnectionMetaData (src)
public ExceptionListener (src) getExceptionListener()
throws JMSException (src)
Connection (src) ExceptionListener object for this connection.
Not every Connection has an ExceptionListener
associated with it.
getExceptionListener in interface Connection (src) ExceptionListener for this connection, or null.
if no ExceptionListener is associated
with this connection.
JMSException (src) - if the JMS provider fails to
get the ExceptionListener for this
connection.Connection.setExceptionListener(javax.jms.ExceptionListener)
public void setExceptionListener(ExceptionListener (src) listener)
throws JMSException (src)
Connection (src) 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 (src) listener - the exception listener
JMSException (src) - if the JMS provider fails to
set the exception listener for this connection.
public void start()
throws JMSException (src)
Connection (src) start on a connection that has already been
started is ignored.
start in interface Connection (src) JMSException (src) - if the JMS provider fails to start
message delivery due to some internal error.Connection.stop()
public void stop()
throws JMSException (src)
Connection (src) 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 (src) JMSException (src) - if the JMS provider fails to stop
message delivery due to some internal error.Connection.start()
public void close()
throws JMSException (src)
Connection (src) 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 (src) JMSException (src) - 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 void closeSession(JmsSession (src) session)
throws JMSException (src)
JmsSessionFactory (src)
closeSession in interface JmsSessionFactory (src) JMSException (src) - for any errorpublic void addTemporaryQueue(TemporaryQueue (src) temp)
JmsSessionFactory (src)
addTemporaryQueue in interface JmsSessionFactory (src) temp - the temporary queuepublic void addTemporaryTopic(TemporaryTopic (src) temp)
JmsSessionFactory (src)
addTemporaryTopic in interface JmsSessionFactory (src) temp - the temporary topic
public ConnectionConsumer (src) createConnectionConsumer(Destination (src) destination,
ServerSessionPool (src) pool,
int maxMessages)
throws JMSException (src)
JMSException (src)
public ConnectionConsumer (src) createConnectionConsumer(Destination (src) destination,
java.lang.String name,
ServerSessionPool (src) pool,
int maxMessages)
throws JMSException (src)
Connection (src)
createConnectionConsumer in interface Connection (src) destination - the destination to accessname - 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.pool - 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 time
JMSException (src) - if the Connection object fails
to create a connection consumer due to some
internal error or invalid arguments for
sessionPool and
messageSelector.ConnectionConsumer (src)
public Session (src) createSession(boolean transacted,
int acknowledgeMode)
throws JMSException (src)
Connection (src) Session object.
createSession in interface Connection (src) 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 (src) - 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
protected JmsSession (src) allocateConnection(boolean transacted,
int acknowledgeMode,
int sessionType)
throws JMSException (src)
JMSException (src)
protected void checkClosed()
throws IllegalStateException (src)
IllegalStateException (src)
|
||||||||||
| PREV CLASS (src) NEXT CLASS (src) | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||