JMS 公共接口

ConnectionFactory 是一个可以从JNDI检索的受管理对象，它建立了到提供者的连接。它包含 createConnection() 方法，该方法返回了一个 Connection 对象。

Connection 封装了一个连接到提供者的活动连接。它的一些方法包括：

createSession(boolean, int)：返回一个 Session 对象。boolean 参数指出 Session 是否被处理， int 则指出确认模式（请参阅 确认）。

start()：激活提供者发送消息。

stop()：临时停止消息的发送，可以用 start() 重新开始发送。

close()：关闭到提供者的连接，并释放以它的名义占用的所有资源。

Session 是用来发送和接收消息的单线程的上下文。它的一些方法包括：

createProducer(Destination)：返回一个 MessageProducer 对象，向指定的 Destination 发送消息。

createConsumer(Destination)：返回一个 MessageConsumer 对象来接收来自指定 Destination 的消息。

commit()：提交当前事务的所有使用的或者产生的消息。

rollback()：回滚当前事务所有使用的或者产生的消息。

create<MessageType>Message(...)：一组返回 <MessageType>Message 的方法——例如，MapMessage、TextMessage 等。

Destination 封装消息的目的地。它是一个从 JNDI 检索的受管理对象。

MessageProducer 用于发送消息。它的一些方法包括：

send(Message)：发送指示的 Message。

setDeliveryMode(int)：设置后续消息的发送模式，有效值为 DeliveryMode.PERSISTENT 和 DeliveryMode.NON_PERSISTENT。

setPriority(int)：设置后续发送消息的优先级，有效值为 0 到 9。

setTimeToLive(long)：设置后续发送消息失效前的持续时间，以毫秒计。

MessageConsumer 被用来接收消息。它的一些方法包括：

receive()：返回下一发到达的消息，该方法在消息可用之前会受到阻塞。

receive(long)：接收在 long 毫秒内到达的下一个消息，如果在时间限制内没有消息到达，则该方法返回 null。

receiveNoWait：如果有一个消息立即可用，则接收下一个消息，如果没有消息可用，则该方法返回 null。

setMessageListener(MessageListener)：设置 MessageListener，MessageListener 对象在消息到达时接收它们，也就是异步接收（请参阅 MessageListener ）。

MessageListener 是有一个单一方法——onMessage(Message)——的接口，它提供了消息的异步接收和处理。

应该通过客户机类和该类使用 setMessageListener(MessageListener) 方法传递给 MessageConsumer 对象的实例来实现这个接口。在消息到达目的地时，用 onMessage(Message) 将它传递给对象。

例子：
Sender.java

代码

import java.io.*;  
import javax.jms.*;  
import javax.naming.*;  
  
public class Sender ...{  
  
    public static void main(String[] args) ...{  
  
        new Sender().send();  
    }  
  
    public void send() ...{  
  
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));  
  
        try ...{  
            //Prompt for JNDI names  
            System.out.println("Enter ConnectionFactory name:");  
            String factoryName = reader.readLine();  
            System.out.println("Enter Destination name:");  
            String destinationName = reader.readLine();  
  
            //Look up administered objects  
            InitialContext initContext = new InitialContext();  
            ConnectionFactory factory =  
                (ConnectionFactory) initContext.lookup(factoryName);  
            Destination destination = (Destination) initContext.lookup(destinationName);  
            initContext.close();  
  
            //Create JMS objects  
            Connection connection = factory.createConnection();  
            Session session =  
                connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
            MessageProducer sender = session.createProducer(queue);  
  
            //Send messages  
            String messageText = null;  
            while (true) ...{  
                System.out.println("Enter message to send or 'quit':");  
                messageText = reader.readLine();  
                if ("quit".equals(messageText))  
                    break;  
                TextMessage message = session.createTextMessage(messageText);  
                sender.send(message);  
            }  
  
            //Exit  
            System.out.println("Exiting...");  
            reader.close();  
            connection.close();  
            System.out.println("Goodbye!");  
  
        } catch (Exception e) ...{  
            e.printStackTrace();  
            System.exit(1);  
        }  
    }  
}  

 

代码

Sender 类有两个方法：main(String[]) 和 send()。main(String[]) 方法只是举例说明了 Sender 并调用了它的 send() 方法。   
  
send() 方法的第一部分提示了将用来发送消息的受管理对象的 JNDI 名。   
  
send() 方法的下一部分用前面输入的名字在 JNDI 中查询受管理的对象。  
  
通 过举例说明 InitialContext 对象访问了 JNDI，通过调用 lookup(String) 方法并传递要获取的对象的名字来检索受管理 的对象。注意， lookup(String) 方法返回 Object，所以必须对返回的对象进行类型强制转换（typecast）。   
  
Receiver.java   
  
[code]import java.io.*;  
import javax.jms.*;  
import javax.naming.*;  
  
public class Receiver implements MessageListener ...{  
  
    private boolean stop = false;  
  
    public static void main(String[] args) ...{  
  
        new Receiver().receive();  
    }  
  
    public void receive() ...{  
  
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));  
  
        try ...{  
            //Prompt for JNDI names  
            System.out.println("Enter ConnectionFactory name:");  
            String factoryName = reader.readLine();  
            System.out.println("Enter Destination name:");  
            String destinationName = reader.readLine();  
            reader.close();  
  
            //Look up administered objects  
            InitialContext initContext = new InitialContext();  
            ConnectionFactory factory =  
                (ConnectionFactory) initContext.lookup(factoryName);  
            Destination destination = (Destination) initContext.lookup(destinationName);  
            initContext.close();  
  
            //Create JMS objects  
            Connection connection = factory.createConnection();  
            Session session =  
                connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
            MessageConsumer receiver = session.createConsumer(queue);  
            receiver.setMessageListener(this);  
            connection.start();  
  
            //Wait for stop  
            while (!stop) ...{  
                Thread.sleep(1000);  
            }  
  
            //Exit  
            System.out.println("Exiting...");  
            connection.close();  
            System.out.println("Goodbye!");  
  
        } catch (Exception e) ...{  
            e.printStackTrace();  
            System.exit(1);  
        }  
    }  
  
    public void onMessage(Message message) ...{  
  
        try ...{  
            String msgText = ((TextMessage) message).getText();  
            System.out.println(msgText);  
            if ("stop".equals(msgText))  
                stop = true;  
        } catch (JMSException e) ...{  
            e.printStackTrace();  
            stop = true;  
        }  
    }  
}  

boolean stop 实例变量用来指出程序应该退出。

Receiver 实现了 MessageListener 接口，为了异步接收消息