1. /*

  2.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  3.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  4.  */

  5. 

  6. package javax.jms;

  7. 

  8. /** A client uses a <CODE>MessageProducer</CODE> object to send messages to a 

  9.   * destination. A <CODE>MessageProducer</CODE> object is created by passing a 

  10.   * <CODE>Destination</CODE> object to a message-producer creation method 

  11.   * supplied by a session.

  12.   *

  13.   * <P><CODE>MessageProducer</CODE> is the parent interface for all message 

  14.   * producers.

  15.   *

  16.   * <P>A client also has the option of creating a message producer without 

  17.   * supplying a destination. In this case, a destination must be provided with 

  18.   * every send operation. A typical use for this kind of message producer is

  19.   * to send replies to requests using the request's <CODE>JMSReplyTo</CODE> 

  20.   * destination.

  21.   *

  22.   * <P>A client can specify a default delivery mode, priority, and time to live 

  23.   * for messages sent by a message producer. It can also specify the delivery 

  24.   * mode, priority, and time to live for an individual message.

  25.   *

  26.   * <P>A client can specify a time-to-live value in milliseconds for each

  27.   * message it sends. This value defines a message expiration time that

  28.   * is the sum of the message's time-to-live and the GMT when it is sent (for

  29.   * transacted sends, this is the time the client sends the message, not

  30.   * the time the transaction is committed).

  31.   *

  32.   * <P>A JMS provider should do its best to expire messages accurately;

  33.   * however, the JMS API does not define the accuracy provided.

  34.   *

  35.   * @version     1.0 - 3 August 1998

  36.   * @author      Mark Hapner

  37.   * @author      Rich Burridge

  38.   *

  39.   * @see         javax.jms.TopicPublisher

  40.   * @see         javax.jms.QueueSender

  41.   * @see         javax.jms.Session

  42.   */

  43. 

  44. public interface MessageProducer {

  45. 

  46.     /** Sets whether message IDs are disabled.

  47.       *  

  48.       * <P>Since message IDs take some effort to create and increase a

  49.       * message's size, some JMS providers may be able to optimize message

  50.       * overhead if they are given a hint that the message ID is not used by

  51.       * an application. By calling the <CODE>setDisableMessageID</CODE>  

  52.       * method on this message producer, a JMS client enables this potential 

  53.       * optimization for all messages sent by this message producer. If the JMS 

  54.       * provider accepts this hint, 

  55.       * these messages must have the message ID set to null; if the provider 

  56.       * ignores the hint, the message ID must be set to its normal unique value.

  57.       *

  58.       * <P>Message IDs are enabled by default.

  59.       *

  60.       * @param value indicates if message IDs are disabled

  61.       *  

  62.       * @exception JMSException if the JMS provider fails to set message ID to

  63.       *                         disabled due to some internal error.

  64.       */ 

  65. 

  66.     void

  67.     setDisableMessageID(boolean value) throws JMSException;

  68. 

  69. 

  70.     /** Gets an indication of whether message IDs are disabled.

  71.       *  

  72.       * @return an indication of whether message IDs are disabled

  73.       *  

  74.       * @exception JMSException if the JMS provider fails to determine if 

  75.       *                         message IDs are disabled due to some internal 

  76.       *                         error.

  77.       */ 

  78. 

  79.     boolean 

  80.     getDisableMessageID() throws JMSException;

  81. 

  82. 

  83.     /** Sets whether message timestamps are disabled.

  84.       *  

  85.       * <P>Since timestamps take some effort to create and increase a 

  86.       * message's size, some JMS providers may be able to optimize message 

  87.       * overhead if they are given a hint that the timestamp is not used by an 

  88.       * application. By calling the <CODE>setDisableMessageTimestamp</CODE> 

  89.       * method on this message producer, a JMS client enables this potential 

  90.       * optimization for all messages sent by this message producer.  If the 

  91.       * JMS provider accepts this hint, 

  92.       * these messages must have the timestamp set to zero; if the provider 

  93.       * ignores the hint, the timestamp must be set to its normal value.

  94.       *  

  95.       * <P>Message timestamps are enabled by default.

  96.       *

  97.       * @param value indicates if message timestamps are disabled

  98.       *  

  99.       * @exception JMSException if the JMS provider fails to set timestamps to

  100.       *                         disabled due to some internal error.

  101.       */ 

  102. 

  103.     void

  104.     setDisableMessageTimestamp(boolean value) throws JMSException;

  105. 

  106. 

  107.     /** Gets an indication of whether message timestamps are disabled.

  108.       *  

  109.       * @return an indication of whether message timestamps are disabled

  110.       *  

  111.       * @exception JMSException if the JMS provider fails to determine if 

  112.       *                         timestamps are disabled due to some internal 

  113.       *                         error.

  114.       */ 

  115. 

  116.     boolean

  117.     getDisableMessageTimestamp() throws JMSException;

  118. 

  119. 

  120.     /** Sets the producer's default delivery mode.

  121.       *  

  122.       * <P>Delivery mode is set to <CODE>PERSISTENT</CODE> by default.

  123.       *

  124.       * @param deliveryMode the message delivery mode for this message

  125.       * producer; legal values are <code>DeliveryMode.NON_PERSISTENT</code>

  126.       * and <code>DeliveryMode.PERSISTENT</code>

  127.       *  

  128.       * @exception JMSException if the JMS provider fails to set the delivery 

  129.       *                         mode due to some internal error.          

  130.       *

  131.       * @see javax.jms.MessageProducer#getDeliveryMode

  132.       * @see javax.jms.DeliveryMode#NON_PERSISTENT

  133.       * @see javax.jms.DeliveryMode#PERSISTENT

  134.       * @see javax.jms.Message#DEFAULT_DELIVERY_MODE

  135.       */ 

  136. 

  137.     void

  138.     setDeliveryMode(int deliveryMode) throws JMSException;

  139. 

  140. 

  141.     /** Gets the producer's default delivery mode.

  142.       *  

  143.       * @return the message delivery mode for this message producer

  144.       *  

  145.       * @exception JMSException if the JMS provider fails to get the delivery 

  146.       *                         mode due to some internal error.

  147.       *

  148.       * @see javax.jms.MessageProducer#setDeliveryMode

  149.       */ 

  150. 

  151.     int 

  152.     getDeliveryMode() throws JMSException;

  153. 

  154. 

  155.     /** Sets the producer's default priority.

  156.       *  

  157.       * <P>The JMS API defines ten levels of priority value, with 0 as the 

  158.       * lowest priority and 9 as the highest. Clients should consider priorities

  159.       * 0-4 as gradations of normal priority and priorities 5-9 as gradations 

  160.       * of expedited priority. Priority is set to 4 by default.

  161.       *

  162.       * @param defaultPriority the message priority for this message producer;

  163.       *                        must be a value between 0 and 9

  164.       * 

  165.       *  

  166.       * @exception JMSException if the JMS provider fails to set the priority

  167.       *                         due to some internal error.

  168.       *

  169.       * @see javax.jms.MessageProducer#getPriority

  170.       * @see javax.jms.Message#DEFAULT_PRIORITY

  171.       */ 

  172. 

  173.     void

  174.     setPriority(int defaultPriority) throws JMSException;

  175. 

  176. 

  177.     /** Gets the producer's default priority.

  178.       *  

  179.       * @return the message priority for this message producer

  180.       *  

  181.       * @exception JMSException if the JMS provider fails to get the priority

  182.       *                         due to some internal error.

  183.       *

  184.       * @see javax.jms.MessageProducer#setPriority

  185.       */ 

  186. 

  187.     int 

  188.     getPriority() throws JMSException;

  189. 

  190. 

  191.     /** Sets the default length of time in milliseconds from its dispatch time

  192.       * that a produced message should be retained by the message system.

  193.       *

  194.       * <P>Time to live is set to zero by default.

  195.       *

  196.       * @param timeToLive the message time to live in milliseconds; zero is

  197.       * unlimited

  198.       *

  199.       * @exception JMSException if the JMS provider fails to set the time to 

  200.       *                         live due to some internal error.

  201.       *

  202.       * @see javax.jms.MessageProducer#getTimeToLive

  203.       * @see javax.jms.Message#DEFAULT_TIME_TO_LIVE

  204.       */

  205.    

  206.     void

  207.     setTimeToLive(long timeToLive) throws JMSException;

  208.    

  209.    

  210.     /** Gets the default length of time in milliseconds from its dispatch time

  211.       * that a produced message should be retained by the message system.

  212.       *

  213.       * @return the message time to live in milliseconds; zero is unlimited

  214.       *

  215.       * @exception JMSException if the JMS provider fails to get the time to 

  216.       *                         live due to some internal error.

  217.       *

  218.       * @see javax.jms.MessageProducer#setTimeToLive

  219.       */ 

  220.  

  221.     long

  222.     getTimeToLive() throws JMSException;

  223. 

  224. 

  225.     /** Closes the message producer.

  226.       *

  227.       * <P>Since a provider may allocate some resources on behalf of a

  228.       * <CODE>MessageProducer</CODE> outside the Java virtual machine, clients 

  229.       * should close them when they

  230.       * are not needed. Relying on garbage collection to eventually reclaim

  231.       * these resources may not be timely enough.

  232.       *  

  233.       * @exception JMSException if the JMS provider fails to close the producer

  234.       *                         due to some internal error.

  235.       */ 

  236. 

  237.     void

  238.     close() throws JMSException;

  239. }