In JMS 1.1, creating a javax.jms.MessageProducer object sends the messages. Developers who are fortunate enough to experience this API will see code that looks similar to this:

// JMS 1.1
Connection conx = 
  queueConnectionFactory.createConnection();
Session session = conx.createSession(true, 
  Session.AUTO_ACKNOWLEDGE);
MessageProducer producer = session.createProducer()
producer.setDeliverDelay(10*1000)
producer.setPriority(7)
producer.setTimeToLive(1000)
producer.setDeliverMode(DeliveryMode.NON_PERSISTENT)
producer.send(destination, message );

The older API only provides bean setter methods in order to configure destination parameters. JMSProducer is the preferred way for JMS 2.0 because it always supports the fluent-style of interface; it has method chaining:

// JMS 2.0
JMSContext context = /* Injected */
JMSProducer producer = context.createProducer()
producer.setDeliverDelay(10*1000)
  .setTimeToLive(1000)
  .setPriority(7)
  .setDeliverMode(DeliveryMode.NON_PERSISTENT)
  .send(destination, message );

The method chaining is clearer, eminently readable, and affords declarative code.

Synchronous sending occurs when the JMS client sends a message to the channel and the provider does not return the thread of control to the sender until it knows that the consumer endpoint has received and acknowledged that successful consumption of the message. This is an example of block-and-wait.

The JMSProducer defines these methods as synchronous operations in the simplified API:

send(Destination destination, Message message)
send(Destination destination, String body)
send(Destination destination, Map<String,Object> body)
send(Destination destination, byte[] body)
send(Destination destination, Serializable body)
send(Destination destination, String body)	

Note that there is no need to create the intermediate Message type object. Incidentally, the developer can set custom key value and pair properties on the JMSProducer instance using the method setStringProperty().

A JMSProducer can also send messages asynchronously so the caller does not block-and-wait on the consumer to successfully acknowledge the message on the channel. This is a performance feature that is intended for unmanaged environment Java SE applications rather than inside an application server.

The JMSProducer defines a setAsync() method in the simplified API and it takes a single argument: an implementation of the Java interface class javax.jms.CompletionListener.

The definition of CompletionListener is as follows:

package javax.jms;
public interface CompletionListener {
  void onCompletion(Message message);
  void onException(Message message, Exception exception);
}

A completion listener must be registered prior to calling any of the send() overloaded methods on JMSPublisher. The JMS provider invokes the callback onCompletion() method when the consumer successfully consumes the message. It will invoke the callback method onException() instead when a failure occurs delivering the message to the consumer.

Every JMS message has a map collection of header fields which are name and value pairs. The message header is sent to all the JMS clients and they are able to read the complete message with the headers on the consumer side.

The names of the header fields begin with the prefix 'JMS' string; here is a table of the headers and their descriptions:

Most of these properties are set on the javax.jms.Message type, but they can be set on the JMSProducer type directly in a fluent API style.

The standard reserves the JMSX property prefix for JMSdefined properties. These are defined as key and value pairs on the message header and are important for message consumers.