ActiveMQMessageProducer (ActiveMQ 1.1 API)
Keywords: org.codehaus.activemq.ActiveMQMessageProducer class

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.codehaus.activemq
Class ActiveMQMessageProducer

    java.lang.Object
      org.codehaus.activemq.ActiveMQMessageProducer

All Implemented Interfaces:
  MessageProducer, StatsCapable

Direct Known Subclasses:
  ActiveMQQueueSender, ActiveMQTopicPublisher

public class ActiveMQMessageProducer
extends Object
implements MessageProducer, StatsCapable

A client uses a `MessageProducer` object to send messages to a destination. A `MessageProducer` object is created by passing a `Destination` object to a message-producer creation method supplied by a session.

`MessageProducer` is the parent interface for all message producers.

A client also has the option of creating a message producer without supplying a destination. In this case, a destination must be provided with every send operation. A typical use for this kind of message producer is to send replies to requests using the request's `JMSReplyTo` destination.

A client can specify a default delivery mode, priority, and time to live for messages sent by a message producer. It can also specify the delivery mode, priority, and time to live for an individual message.

A client can specify a time-to-live value in milliseconds for each message it sends. This value defines a message expiration time that is the sum of the message's time-to-live and the GMT when it is sent (for transacted sends, this is the time the client sends the message, not the time the transaction is committed).

A JMS provider should do its best to expire messages accurately; however, the JMS API does not define the accuracy provided.

Version:
  $Revision: 1.19 $
See Also:
  `TopicPublisher`, `QueueSender`, `Session.createProducer(javax.jms.Destination)`

Field Summary
`protected boolean` | `closed`
`protected ActiveMQDestination` | `defaultDestination`
`protected String` | `producerId`
`protected ActiveMQSession` | `session`

Constructor Summary
`protected` | `ActiveMQMessageProducer(ActiveMQSession theSession, ActiveMQDestination destination)`

Method Summary
`protected void` | `checkClosed()`
`void` | `close()` Closes the message producer.
`int` | `getDeliveryMode()` Gets the producer's default delivery mode.
`Destination` | `getDestination()` Gets the destination associated with this `MessageProducer`.
`boolean` | `getDisableMessageID()` Gets an indication of whether message IDs are disabled.
`boolean` | `getDisableMessageTimestamp()` Gets an indication of whether message timestamps are disabled.
`protected IdGenerator` | `getIdGenerator()`
`int` | `getPriority()` Gets the producer's default priority.
`protected String` | `getProducerId()`
`JMSProducerStatsImpl` | `getProducerStats()`
`protected long` | `getStartTime()`
`Stats` | `getStats()`
`long` | `getTimeToLive()` Gets the default length of time in milliseconds from its dispatch time that a produced message should be retained by the message system.
`boolean` | `isResuseMessageId()`
`void` | `send(Destination destination, Message message)` Sends a message to a destination for an unidentified message producer.
`void` | `send(Destination destination, Message message, int deliveryMode, int priority, long timeToLive)` Sends a message to a destination for an unidentified message producer, specifying delivery mode, priority and time to live.
`void` | `send(Message message)` Sends a message using the `MessageProducer`'s default delivery mode, priority, and time to live.
`void` | `send(Message message, int deliveryMode, int priority, long timeToLive)` Sends a message to the destination, specifying delivery mode, priority, and time to live.
`void` | `setDeliveryMode(int newDeliveryMode)` Sets the producer's default delivery mode.
`void` | `setDisableMessageID(boolean value)` Sets whether message IDs are disabled.
`void` | `setDisableMessageTimestamp(boolean value)` Sets whether message timestamps are disabled.
`void` | `setPriority(int newDefaultPriority)` Sets the producer's default priority.
`protected void` | `setProducerId(String producerId)`
`void` | `setReuseMessageId(boolean reuseMessageId)`
`void` | `setTimeToLive(long timeToLive)` Sets the default length of time in milliseconds from its dispatch time that a produced message should be retained by the message system.

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

Field Detail

### session

    protected ActiveMQSession session

### producerId

    protected String producerId

### closed

    protected boolean closed

### defaultDestination

    protected ActiveMQDestination defaultDestination

Constructor Detail

### ActiveMQMessageProducer

    protected ActiveMQMessageProducer(ActiveMQSession theSession,
                                      ActiveMQDestination destination)
                               throws JMSException

Method Detail

### getStats

    public Stats getStats()

  Specified by:
    `getStats` in interface `StatsCapable`
  Returns:
    the Stats for this object

### getProducerStats

    public JMSProducerStatsImpl getProducerStats()

### setDisableMessageID

    public void setDisableMessageID(boolean value)
                             throws JMSException

  Sets whether message IDs are disabled.

  Since message IDs take some effort to create and increase a message's size, some JMS providers may be able to optimize message overhead if they are given a hint that the message ID is not used by an application. By calling the `setDisableMessageID` method on this message producer, a JMS client enables this potential optimization for all messages sent by this message producer. If the JMS provider accepts this hint, these messages must have the message ID set to null; if the provider ignores the hint, the message ID must be set to its normal unique value.

  Message IDs are enabled by default.

  Specified by:
    `setDisableMessageID` in interface `MessageProducer`
  Parameters:
    `value` - indicates if message IDs are disabled
  Throws:
    `JMSException` - if the JMS provider fails to close the producer due to some internal error.

### getDisableMessageID

    public boolean getDisableMessageID()
                                throws JMSException

  Gets an indication of whether message IDs are disabled.

  Specified by:
    `getDisableMessageID` in interface `MessageProducer`
  Returns:
    an indication of whether message IDs are disabled
  Throws:
    `JMSException` - if the JMS provider fails to determine if message IDs are disabled due to some internal error.

### setDisableMessageTimestamp

    public void setDisableMessageTimestamp(boolean value)
                                    throws JMSException

  Sets whether message timestamps are disabled.

  Since timestamps take some effort to create and increase a message's size, some JMS providers may be able to optimize message overhead if they are given a hint that the timestamp is not used by an application. By calling the `setDisableMessageTimestamp` method on this message producer, a JMS client enables this potential optimization for all messages sent by this message producer. If the JMS provider accepts this hint, these messages must have the timestamp set to zero; if the provider ignores the hint, the timestamp must be set to its normal value.

  Message timestamps are enabled by default.

  Specified by:
    `setDisableMessageTimestamp` in interface `MessageProducer`
  Parameters:
    `value` - indicates if message timestamps are disabled
  Throws:
    `JMSException` - if the JMS provider fails to close the producer due to some internal error.

### getDisableMessageTimestamp

    public boolean getDisableMessageTimestamp()
                                       throws JMSException

  Gets an indication of whether message timestamps are disabled.

  Specified by:
    `getDisableMessageTimestamp` in interface `MessageProducer`
  Returns:
    an indication of whether message timestamps are disabled
  Throws:
    `JMSException` - if the JMS provider fails to close the producer due to some internal error.

### setDeliveryMode

    public void setDeliveryMode(int newDeliveryMode)
                         throws JMSException

  Sets the producer's default delivery mode.

  Delivery mode is set to `PERSISTENT` by default.

  Specified by:
    `setDeliveryMode` in interface `MessageProducer`
  Parameters:
    `newDeliveryMode` - the message delivery mode for this message producer; legal values are `DeliveryMode.NON_PERSISTENT` and `DeliveryMode.PERSISTENT`
  Throws:
    `JMSException` - if the JMS provider fails to set the delivery mode due to some internal error.
  See Also:
    `MessageProducer.getDeliveryMode()`, `DeliveryMode.NON_PERSISTENT`, `DeliveryMode.PERSISTENT`, `Message.DEFAULT_DELIVERY_MODE`

### getDeliveryMode

    public int getDeliveryMode()
                        throws JMSException

  Gets the producer's default delivery mode.

  Specified by:
    `getDeliveryMode` in interface `MessageProducer`
  Returns:
    the message delivery mode for this message producer
  Throws:
    `JMSException` - if the JMS provider fails to close the producer due to some internal error.

### setPriority

    public void setPriority(int newDefaultPriority)
                     throws JMSException

  Sets the producer's default priority.

  The JMS API defines ten levels of priority value, with 0 as the lowest priority and 9 as the highest. Clients should consider priorities 0-4 as gradations of normal priority and priorities 5-9 as gradations of expedited priority. Priority is set to 4 by default.

  Specified by:
    `setPriority` in interface `MessageProducer`
  Parameters:
    `newDefaultPriority` - the message priority for this message producer; must be a value between 0 and 9
  Throws:
    `JMSException` - if the JMS provider fails to set the delivery mode due to some internal error.
  See Also:
    `MessageProducer.getPriority()`, `Message.DEFAULT_PRIORITY`

### getPriority

    public int getPriority()
                    throws JMSException

  Gets the producer's default priority.

  Specified by:
    `getPriority` in interface `MessageProducer`
  Returns:
    the message priority for this message producer
  Throws:
    `JMSException` - if the JMS provider fails to close the producer due to some internal error.
  See Also:
    `MessageProducer.setPriority(int)`

### setTimeToLive

    public void setTimeToLive(long timeToLive)
                       throws JMSException

  Sets the default length of time in milliseconds from its dispatch time that a produced message should be retained by the message system.

  Time to live is set to zero by default.

  Specified by:
    `setTimeToLive` in interface `MessageProducer`
  Parameters:
    `timeToLive` - the message time to live in milliseconds; zero is unlimited
  Throws:
    `JMSException` - if the JMS provider fails to set the time to live due to some internal error.
  See Also:
    `MessageProducer.getTimeToLive()`, `Message.DEFAULT_TIME_TO_LIVE`

### getTimeToLive

    public long getTimeToLive()
                       throws JMSException

  Gets the default length of time in milliseconds from its dispatch time that a produced message should be retained by the message system.

  Specified by:
    `getTimeToLive` in interface `MessageProducer`
  Returns:
    the message time to live in milliseconds; zero is unlimited
  Throws:
    `JMSException` - if the JMS provider fails to get the time to live due to some internal error.
  See Also:
    `MessageProducer.setTimeToLive(long)`

### getDestination

    public Destination getDestination()
                               throws JMSException

  Gets the destination associated with this `MessageProducer`.

  Specified by:
    `getDestination` in interface `MessageProducer`
  Returns:
    this producer's `Destination/ ```
  Throws:
    `JMSException` - if the JMS provider fails to close the producer due to some internal error.
  Since:
    1.1

### close

    public void close()
               throws JMSException

  Closes the message producer.

  Since a provider may allocate some resources on behalf of a `MessageProducer` outside the Java virtual machine, clients should close them when they are not needed. Relying on garbage collection to eventually reclaim these resources may not be timely enough.

  Specified by:
    `close` in interface `MessageProducer`
  Throws:
    `JMSException` - if the JMS provider fails to close the producer due to some internal error.

### checkClosed

    protected void checkClosed()
                        throws IllegalStateException

  Throws:
    `IllegalStateException`

### send

    public void send(Message message)
              throws JMSException

  Sends a message using the `MessageProducer`'s default delivery mode, priority, and time to live.

  Specified by:
    `send` in interface `MessageProducer`
  Parameters:
    `message` - the message to send
  Throws:
    `JMSException` - if the JMS provider fails to send the message due to some internal error.
    `MessageFormatException` - if an invalid message is specified.
    `InvalidDestinationException` - if a client uses this method with a `MessageProducer` with an invalid destination.
    `UnsupportedOperationException` - if a client uses this method with a `MessageProducer` that did not specify a destination at creation time.
  Since:
    1.1
  See Also:
    `Session.createProducer(javax.jms.Destination)`, `MessageProducer`

### send

    public void send(Message message,
                     int deliveryMode,
                     int priority,
                     long timeToLive)
              throws JMSException

  Sends a message to the destination, specifying delivery mode, priority, and time to live.

  Specified by:
    `send` in interface `MessageProducer`
  Parameters:
    `message` - the message to send
    `deliveryMode` - the delivery mode to use
    `priority` - the priority for this message
    `timeToLive` - the message's lifetime (in milliseconds)
  Throws:
    `JMSException` - if the JMS provider fails to send the message due to some internal error.
    `MessageFormatException` - if an invalid message is specified.
    `InvalidDestinationException` - if a client uses this method with a `MessageProducer` with an invalid destination.
    `UnsupportedOperationException` - if a client uses this method with a `MessageProducer` that did not specify a destination at creation time.
  Since:
    1.1
  See Also:
    `Session.createProducer(javax.jms.Destination)`

### send

    public void send(Destination destination,
                     Message message)
              throws JMSException

  Sends a message to a destination for an unidentified message producer. Uses the `MessageProducer`'s default delivery mode, priority, and time to live.

  Typically, a message producer is assigned a destination at creation time; however, the JMS API also supports unidentified message producers, which require that the destination be supplied every time a message is sent.

  Specified by:
    `send` in interface `MessageProducer`
  Parameters:
    `destination` - the destination to send this message to
    `message` - the message to send
  Throws:
    `JMSException` - if the JMS provider fails to send the message due to some internal error.
    `MessageFormatException` - if an invalid message is specified.
    `InvalidDestinationException` - if a client uses this method with an invalid destination.
    `UnsupportedOperationException` - if a client uses this method with a `MessageProducer` that specified a destination at creation time.
  Since:
    1.1
  See Also:
    `Session.createProducer(javax.jms.Destination)`, `MessageProducer`

### send

    public void send(Destination destination,
                     Message message,
                     int deliveryMode,
                     int priority,
                     long timeToLive)
              throws JMSException

  Sends a message to a destination for an unidentified message producer, specifying delivery mode, priority and time to live.

  Typically, a message producer is assigned a destination at creation time; however, the JMS API also supports unidentified message producers, which require that the destination be supplied every time a message is sent.

  Specified by:
    `send` in interface `MessageProducer`
  Parameters:
    `destination` - the destination to send this message to
    `message` - the message to send
    `deliveryMode` - the delivery mode to use
    `priority` - the priority for this message
    `timeToLive` - the message's lifetime (in milliseconds)
  Throws:
    `JMSException` - if the JMS provider fails to send the message due to some internal error.
    `MessageFormatException` - if an invalid message is specified.
    `InvalidDestinationException` - if a client uses this method with an invalid destination.
  Since:
    1.1
  See Also:
    `Session.createProducer(javax.jms.Destination)`

### isResuseMessageId

    public boolean isResuseMessageId()

  Returns:
    Returns the reuseMessageId.

### setReuseMessageId

    public void setReuseMessageId(boolean reuseMessageId)

  Parameters:
    `reuseMessageId` - The resuseMessageId to set.

### getProducerId

    protected String getProducerId()

  Returns:
    Returns the producerId.

### setProducerId

    protected void setProducerId(String producerId)

  Parameters:
    `producerId` - The producerId to set.

### getStartTime

    protected long getStartTime()

### getIdGenerator

    protected IdGenerator getIdGenerator()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2004 Protique, Ltd.. All Rights Reserved.