JMS实现简单聊天程序

使用了JMS的开源实现activemq消息中间件。各版本都行

分为如下几步完成。

  第一步：安装activemq

  (1)下载解压到E:\open_source\activeMQ\apache-activemq-5.5.0，并在环境变量配置ACTIVEMQ_HOME

  (2)因为apache-activemq-5.5.0需要使用slf4j-1.5.11版本的jar包,下载slf4j

  第二步：编写相应的代码，如下：

  package ch02.chat;

Java代码  

1. import java.io.BufferedReader;   
2. import java.io.InputStreamReader;   
3. import java.util.Properties;   
4.   
5. import javax.jms.JMSException;   
6. import javax.jms.Message;   
7. import javax.jms.MessageListener;   
8. import javax.jms.Session;   
9. import javax.jms.TextMessage;   
10. import javax.jms.Topic;   
11. import javax.jms.TopicConnection;   
12. import javax.jms.TopicConnectionFactory;   
13. import javax.jms.TopicPublisher;   
14. import javax.jms.TopicSession;   
15. import javax.jms.TopicSubscriber;   
16. import javax.naming.Context;   
17. import javax.naming.InitialContext;   
18.   
19.   
20. public class Chat implements MessageListener {   
21.   
22.     private TopicSession pubSession;   
23.     private TopicPublisher publisher;   
24.     private TopicConnection connection;   
25.     private String username;   
26.   
27.     // 用于初始化chat的构造函数   
28.     public Chat(String topicFactory, String topicName, String username)   
29.             throws Exception {   
30. //      Properties env=new Properties();   
31. //      env.put(Context.SECURITY_PRINCIPAL, "system");   
32. //      env.put(Context.SECURITY_CREDENTIALS, "manager");   
33. //      env.put(Context.INITIAL_CONTEXT_FACTORY, "org.apache.activemq.jndi.ActiveMQInitialContextFactory");   
34. //      env.put(Context.PROVIDER_URL, "tcp://localhost:61616");   
35.            
36.         // 使用jndi.properties文件获得一个JNDI连接   
37.         InitialContext ctx = new InitialContext();   
38.   
39.         // 查找一个jms连接工厂并创建连接   
40.         TopicConnectionFactory conFactory = (TopicConnectionFactory) ctx   
41.                 .lookup(topicFactory);   
42.         TopicConnection connection = conFactory.createTopicConnection();   
43.   
44.         // 创建两个JMS会话对象   
45.         TopicSession pubSession = connection.createTopicSession(false,   
46.                 Session.AUTO_ACKNOWLEDGE);   
47.         TopicSession subSession = connection.createTopicSession(false,   
48.                 Session.AUTO_ACKNOWLEDGE);   
49.   
50.         // 查找一个JMS主题   
51.         Topic chatTopic = (Topic) ctx.lookup(topicName);   
52.   
53.         // 创建一个JMS发布者和订阅者,createSubscriber中附加的参数是一个消息   
54.         // 选择器(null)和noLocal标记的一个真值,它表明这个发布者生产的消息不应被他自己所消费   
55.         TopicPublisher publisher = pubSession.createPublisher(chatTopic);   
56.         TopicSubscriber subscriber = subSession.createSubscriber(chatTopic,   
57.                 null, true);   
58.   
59.         // 设置一个JMS消息侦听器   
60.         subscriber.setMessageListener(this);   
61.   
62.         // 初始化Chat应用程序变量   
63.         this.connection = connection;   
64.         this.pubSession = pubSession;   
65.         this.publisher = publisher;   
66.         this.username = username;   
67.   
68.         // 启动JMS连接，允许传递消息   
69.         connection.start();   
70.     }   
71.   
72.     // 接受来自TopicSubscriber的消息   
73.     public void onMessage(Message message) {   
74.         try {   
75.             TextMessage textMessage = (TextMessage) message;   
76.             System.out.println(textMessage.getText());   
77.   
78.         } catch (JMSException jmse) {   
79.             jmse.printStackTrace();   
80.         }   
81.     }   
82.   
83.     // 使用发布者创建并发送消息   
84.     protected void writeMessage(String text) throws JMSException {   
85.         TextMessage message = pubSession.createTextMessage();   
86.         message.setText(username + " : " + text);   
87.         publisher.publish(message);   
88.     }   
89.   
90.     // 关闭JMS连接   
91.     public void close() throws JMSException {   
92.         connection.close();   
93.     }   
94.   
95.     // 运行聊天客户端   
96.     public static void main(String[] args) {   
97.         try {   
98.             if (args.length != 3) {   
99.                 System.out.println("Factory.Topic.or username missing");   
100.             }   
101.             String topicFactory="TopicCF";   
102.             String topicName="topic1";   
103.             String username="lyb";   
104.             Chat chat = new Chat(topicFactory, topicName, username);   
105.   
106.             // 从命令行读取   
107.             BufferedReader commandLine = new BufferedReader(   
108.                     new InputStreamReader(System.in));   
109.   
110.             // 循环   
111.             while (true) {   
112.                 String s = commandLine.readLine();   
113.                 if (s.equalsIgnoreCase("exit")) {   
114.                     chat.close();   
115.                     System.exit(0);   
116.                 } else {   
117.                     chat.writeMessage(s);   
118.                 }   
119.             }   
120.         } catch (Exception e) {   
121.             e.printStackTrace();   
122.         }   
123.         ;   
124.     }   
125.   
126. }  

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Properties;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicPublisher;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.Context;
import javax.naming.InitialContext;


public class Chat implements MessageListener {

	private TopicSession pubSession;
	private TopicPublisher publisher;
	private TopicConnection connection;
	private String username;

	// 用于初始化chat的构造函数
	public Chat(String topicFactory, String topicName, String username)
			throws Exception {
//		Properties env=new Properties();
//		env.put(Context.SECURITY_PRINCIPAL, "system");
//		env.put(Context.SECURITY_CREDENTIALS, "manager");
//		env.put(Context.INITIAL_CONTEXT_FACTORY, "org.apache.activemq.jndi.ActiveMQInitialContextFactory");
//		env.put(Context.PROVIDER_URL, "tcp://localhost:61616");
		
		// 使用jndi.properties文件获得一个JNDI连接
		InitialContext ctx = new InitialContext();

		// 查找一个jms连接工厂并创建连接
		TopicConnectionFactory conFactory = (TopicConnectionFactory) ctx
				.lookup(topicFactory);
		TopicConnection connection = conFactory.createTopicConnection();

		// 创建两个JMS会话对象
		TopicSession pubSession = connection.createTopicSession(false,
				Session.AUTO_ACKNOWLEDGE);
		TopicSession subSession = connection.createTopicSession(false,
				Session.AUTO_ACKNOWLEDGE);

		// 查找一个JMS主题
		Topic chatTopic = (Topic) ctx.lookup(topicName);

		// 创建一个JMS发布者和订阅者,createSubscriber中附加的参数是一个消息
		// 选择器(null)和noLocal标记的一个真值,它表明这个发布者生产的消息不应被他自己所消费
		TopicPublisher publisher = pubSession.createPublisher(chatTopic);
		TopicSubscriber subscriber = subSession.createSubscriber(chatTopic,
				null, true);

		// 设置一个JMS消息侦听器
		subscriber.setMessageListener(this);

		// 初始化Chat应用程序变量
		this.connection = connection;
		this.pubSession = pubSession;
		this.publisher = publisher;
		this.username = username;

		// 启动JMS连接，允许传递消息
		connection.start();
	}

	// 接受来自TopicSubscriber的消息
	public void onMessage(Message message) {
		try {
			TextMessage textMessage = (TextMessage) message;
			System.out.println(textMessage.getText());

		} catch (JMSException jmse) {
			jmse.printStackTrace();
		}
	}

	// 使用发布者创建并发送消息
	protected void writeMessage(String text) throws JMSException {
		TextMessage message = pubSession.createTextMessage();
		message.setText(username + " : " + text);
		publisher.publish(message);
	}

	// 关闭JMS连接
	public void close() throws JMSException {
		connection.close();
	}

	// 运行聊天客户端
	public static void main(String[] args) {
		try {
			if (args.length != 3) {
				System.out.println("Factory.Topic.or username missing");
			}
			String topicFactory="TopicCF";
			String topicName="topic1";
			String username="lyb";
			Chat chat = new Chat(topicFactory, topicName, username);

			// 从命令行读取
			BufferedReader commandLine = new BufferedReader(
					new InputStreamReader(System.in));

			// 循环
			while (true) {
				String s = commandLine.readLine();
				if (s.equalsIgnoreCase("exit")) {
					chat.close();
					System.exit(0);
				} else {
					chat.writeMessage(s);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		;
	}

}

Java代码  

1.   

Java代码  

1.   

     将以上的类复制一份，放在同一个包下面。一份代码作为消息的发布方，一份代码作为消息的订阅方。

     整个程序的工程结构组织见下图

    

    

  第三步、配置jndi文件

  java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory

  java.naming.provider.url=tcp://localhost\:61616

  java.naming.security.principal=system

  java.naming.security.credentials=manager

  connectionFactoryNames=TopicCF

  topic.topic1=jms.topic1

 第四步、启动activeMQ，分别运行Chat.java和CopyChat.java,可以在两个程序之间交互信息