java.lang.Object
- org.springframework.jms.support.JmsAccessor

All Implemented Interfaces:
InitializingBean
Direct Known Subclasses:
JmsDestinationAccessor
```
public abstract class JmsAccessor
extends Object
implements InitializingBean
```
Base class for JmsTemplate and other JMS-accessing gateway helpers, defining common properties such as the JMS ConnectionFactory to operate on. The subclass JmsDestinationAccessor adds further, destination-related properties.
Not intended to be used directly. See JmsTemplate.
Since:
1.2
Author:
Juergen Hoeller
See Also:
JmsDestinationAccessor, JmsTemplate

Field Summary
Fields
Modifier and Type Field Description
protected Log logger
Logger available to subclasses

Constructor Summary
Constructors
Constructor Description
JmsAccessor()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`afterPropertiesSet()`	Invoked by the containing `BeanFactory` after it has set all bean properties and satisfied `BeanFactoryAware`, `ApplicationContextAware` etc.
`protected JmsException`	`convertJmsAccessException(JMSException ex)`	Convert the specified checked `JMSException` to a Spring runtime `JmsException` equivalent.
`protected Connection`	`createConnection()`	Create a JMS Connection via this template's ConnectionFactory.
`protected Session`	`createSession(Connection con)`	Create a JMS Session for the given Connection.
`ConnectionFactory`	`getConnectionFactory()`	Return the ConnectionFactory that this accessor uses for obtaining JMS `Connections`.
`int`	`getSessionAcknowledgeMode()`	Return the acknowledgement mode for JMS `sessions`.
`protected boolean`	`isClientAcknowledge(Session session)`	Determine whether the given Session is in client acknowledge mode.
`boolean`	`isSessionTransacted()`	Return whether the JMS `sessions` used by this accessor are supposed to be transacted.
`void`	`setConnectionFactory(ConnectionFactory connectionFactory)`	Set the ConnectionFactory to use for obtaining JMS `Connections`.
`void`	`setSessionAcknowledgeMode(int sessionAcknowledgeMode)`	Set the JMS acknowledgement mode that is used when creating a JMS `Session` to send a message.
`void`	`setSessionAcknowledgeModeName(String constantName)`	Set the JMS acknowledgement mode by the name of the corresponding constant in the JMS `Session` interface, e.g.
`void`	`setSessionTransacted(boolean sessionTransacted)`	Set the transaction mode that is used when creating a JMS `Session`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - logger
```
protected final Log logger
```
    Logger available to subclasses
- Constructor Detail
  - JmsAccessor
```
public JmsAccessor()
```
- Method Detail
  - setConnectionFactory
```
public void setConnectionFactory(ConnectionFactory connectionFactory)
```
    Set the ConnectionFactory to use for obtaining JMS Connections.
  - getConnectionFactory
```
public ConnectionFactory getConnectionFactory()
```
    Return the ConnectionFactory that this accessor uses for obtaining JMS Connections.
  - setSessionTransacted
```
public void setSessionTransacted(boolean sessionTransacted)
```
    Set the transaction mode that is used when creating a JMS Session. Default is "false".
    Note that within a JTA transaction, the parameters passed to create(Queue/Topic)Session(boolean transacted, int acknowledgeMode) method are not taken into account. Depending on the Java EE transaction context, the container makes its own decisions on these values. Analogously, these parameters are not taken into account within a locally managed transaction either, since the accessor operates on an existing JMS Session in this case.
    Setting this flag to "true" will use a short local JMS transaction when running outside of a managed transaction, and a synchronized local JMS transaction in case of a managed transaction (other than an XA transaction) being present. This has the effect of a local JMS transaction being managed alongside the main transaction (which might be a native JDBC transaction), with the JMS transaction committing right after the main transaction.
    See Also:
    Connection.createSession(boolean, int)
  - isSessionTransacted
```
public boolean isSessionTransacted()
```
    Return whether the JMS sessions used by this accessor are supposed to be transacted.
    See Also:
    setSessionTransacted(boolean)
  - setSessionAcknowledgeModeName
```
public void setSessionAcknowledgeModeName(String constantName)
```
    Set the JMS acknowledgement mode by the name of the corresponding constant in the JMS Session interface, e.g. "CLIENT_ACKNOWLEDGE".
    If you want to use vendor-specific extensions to the acknowledgment mode, use setSessionAcknowledgeMode(int) instead.
    Parameters:
    constantName - the name of the Session acknowledge mode constant
    See Also:
    Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, Session.DUPS_OK_ACKNOWLEDGE, Connection.createSession(boolean, int)
  - setSessionAcknowledgeMode
```
public void setSessionAcknowledgeMode(int sessionAcknowledgeMode)
```
    Set the JMS acknowledgement mode that is used when creating a JMS Session to send a message.
    Default is Session.AUTO_ACKNOWLEDGE.
    Vendor-specific extensions to the acknowledgment mode can be set here as well.
    Note that inside an EJB, the parameters to the create(Queue/Topic)Session(boolean transacted, int acknowledgeMode) method are not taken into account. Depending on the transaction context in the EJB, the container makes its own decisions on these values. See section 17.3.5 of the EJB spec.
    Parameters:
    sessionAcknowledgeMode - the acknowledgement mode constant
    See Also:
    Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, Session.DUPS_OK_ACKNOWLEDGE, Connection.createSession(boolean, int)
  - getSessionAcknowledgeMode
```
public int getSessionAcknowledgeMode()
```
    Return the acknowledgement mode for JMS sessions.
  - afterPropertiesSet
```
public void afterPropertiesSet()
```
    Description copied from interface: InitializingBean
    Invoked by the containing BeanFactory after it has set all bean properties and satisfied BeanFactoryAware, ApplicationContextAware etc.
    This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.
    Specified by:
    afterPropertiesSet in interface InitializingBean
  - convertJmsAccessException
```
protected JmsException convertJmsAccessException(JMSException ex)
```
    Convert the specified checked JMSException to a Spring runtime JmsException equivalent.
    The default implementation delegates to the JmsUtils.convertJmsAccessException(javax.jms.JMSException) method.
    Parameters:
    ex - the original checked JMSException to convert
    Returns:
    the Spring runtime JmsException wrapping ex
    See Also:
    JmsUtils.convertJmsAccessException(javax.jms.JMSException)
  - createConnection
```
protected Connection createConnection()
                               throws JMSException
```
    Create a JMS Connection via this template's ConnectionFactory.
    This implementation uses JMS 1.1 API.
    Returns:
    the new JMS Connection
    Throws:
    JMSException - if thrown by JMS API methods
    See Also:
    ConnectionFactory.createConnection()
  - createSession
```
protected Session createSession(Connection con)
                         throws JMSException
```
    Create a JMS Session for the given Connection.
    This implementation uses JMS 1.1 API.
    Parameters:
    con - the JMS Connection to create a Session for
    Returns:
    the new JMS Session
    Throws:
    JMSException - if thrown by JMS API methods
    See Also:
    Connection.createSession(boolean, int)
  - isClientAcknowledge
```
protected boolean isClientAcknowledge(Session session)
                               throws JMSException
```
    Determine whether the given Session is in client acknowledge mode.
    This implementation uses JMS 1.1 API.
    Parameters:
    session - the JMS Session to check
    Returns:
    whether the given Session is in client acknowledge mode
    Throws:
    JMSException - if thrown by JMS API methods
    See Also:
    Session.getAcknowledgeMode(), Session.CLIENT_ACKNOWLEDGE

Class JmsAccessor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

JmsAccessor

Method Detail

setConnectionFactory

getConnectionFactory

setSessionTransacted

isSessionTransacted

setSessionAcknowledgeModeName

setSessionAcknowledgeMode

getSessionAcknowledgeMode

afterPropertiesSet

convertJmsAccessException

createConnection

createSession

isClientAcknowledge