JMS: 一种规范，一种标准
JMS只是Java EE中定义的一组标准API，它自身并不是一个消息服务系统，它是消息传送服务的一个抽象，也就是说它定义了消息传送的接口而并没有具体实现。
ActiveMQ: ActiveMQ 是一款非常流行的开源消息服务器；
我们知道JMS只是消息服务的一组规范和接口，并没有具体的实现，而ActiveMQ就是JMS规范的具体实现；
ActiveMQ分为点对点发送与接收、发布与订阅
QUEQ:
导入jms的jar包
1创建连接工厂connectionFactory，创建连接connection，创建session，创建文本消息message，创建目的地destination，创建一个生产者messageProducer，发送一下messageProducer.send（)
2消费者
创建连接工厂connectionFactory，创建连接connection，创建session，创建目的地destination，创建一个消费者messageConsumer，接收一下（注意：接受前要启动一下连接）receive（）
写点对点和发送与接收的区别无非就是发送的地址不一样和接收的方式不一样而已，不过发送与接收的地址必须是一样的才能收到消息
Queue 发送时，创建目的地： createQueue （"myQueue"）; 发送用 生产者.send（）即可
接受是，创建目的地： createQueue （"myQueue"）; 接受用 //消费者接受消息 前面需要将连接启动一下connection.start(); 接收者.receive（）即可
Topic 发送时，创建目的地： createTopic("topic"); 发送用 生产者.send（）即可
接受时， 创建目的地： createTopic("topic"); 接受用 //消费者接受消息 前面需要将连接启动一下connection.start(); 接收者.receive（）即可
还有一个当发送的为byteMessage字节消息、流消息时候，发送的顺序要与接收的顺序一致否则会报异常
发送与接收时还能设置密码，要从配置文件中改（linux中的配置文件）
//点对点发送
public class Sender {
private static final String BROKER_URL = "tcp://192.168.119.128:61616";
/**
* 发送消息到服务器上
* @param msg
*/
public void sendMessage(String msg){
ConnectionFactory connectionFactory = null;
Connection connection = null;
Session session = null;
MessageProducer messageProducer = null;
try {
//创建连接工厂
connectionFactory = new ActiveMQConnectionFactory(BROKER_URL);
//创建连接
connection = connectionFactory.createConnection();
//创建session(不使用事务消息，消息自动确认)
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建文本消息
TextMessage message = session.createTextMessage(msg);
//给消息设置特殊标记
// message.setStringProperty("flag", "guolv");
//创建目的地
Destination destination = session.createQueue("myQueue");
//创建一个生产者
messageProducer = session.createProducer(destination);
//默认发送的消息都是持久化的
// messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
//发送一下
messageProducer.send(message);
//当开启事务时，不管接受者还是发送者都得进行commit（）
// session.commit();
} catch (JMSException e) {
e.printStackTrace();
}
finally {
try {
if(null != messageProducer){
messageProducer.close();
}
if(null != session){
session.close();
}
if(null != connection){
connection.close();
}
} catch (JMSException e) {
e.printStackTrace();
}
}
}
}
//这个是点对点接收 java工程
/**
* 消息接受者（点对点接受）
* @author d
*
*/
public class Receiver {
private static final String BROKER_URL = "tcp://192.168.119.128:61616";
/**
* 从activeMQ服务器上接受消息
*/
public void receiverMessage(){
try {
//创建一个连接工厂
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(BROKER_URL);
//创建连接
Connection connection = connectionFactory.createConnection();
//创建session(不使用事务，消息自动确认)
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建消息的目的地
Destination destination = session.createQueue("myQueue");
//创建消息的消费者
MessageConsumer messageConsumer = session.createConsumer(destination);
//创建消息过滤
// String selector = "'flag'='guolv'";
// MessageConsumer messageConsumer = session.createConsumer(destination, selector);
//消费者接受消息 前面需要将连接启动一下
connection.start();
while(true){
//使用消息消费者接受一条消息
Message message = messageConsumer.receive();
//当开启事务时，不管接受者还是发送者都得进行commit（）
// session.commit();
if(message instanceof TextMessage){
//获取文本消息
String text = ((TextMessage) message).getText();
System.out.println("接收到的消息为"+text);
}
}
} catch (JMSException e) {
e.printStackTrace();
}
}
}
//spring与ActiveMQ结合 web工程
1导入spring-jms的jar包
2 用spring来创建connectionFactory对象
<!-- 扫描包，让这个包下的spring注解了的类能加入到spring容器中 -->
<context:component-scan base-package="com.bjpowernode.spring"/>
<!--配置连接工厂，连接ActiveMQ服务器 -->
<bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://192.168.119.128:61616" />
<!-- <property name="userName" value="root"/>
<property name="password" value="abc123"/> -->
</bean>
<!-- 配置jsm操作模板 -->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate" >
<property name="connectionFactory" ref="connectionFactory"/>
<property name="defaultDestinationName" value="listenerQueue"/>
</bean>
3 写一个类去发送消息再加个main方法去发送
@Component("sender") //把普通pojo实例化到spring容器中
public class Sender {
@Autowired
private JmsTemplate jmsTemplate;
/**
* 发送消息
* @param msg
*/
public void senderMessage(String msg){
jmsTemplate.send(new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
return session.createTextMessage(msg);
}
});
}
}
//接受消息
1导入spring-jms的jar包
2 用spring来创建connectionFactory对象
<!-- 扫描包，让这个包下的spring注解了的类能加入到spring容器中 -->
<context:component-scan base-package="com.bjpowernode"/>
<!--配置连接工厂，连接ActiveMQ服务器 -->
<bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://192.168.119.128:61616" /> //若要配置集群的话就在这个配置端口信息
<!-- <property name="userName" value="root"/>
<property name="password" value="abc123"/> -->
</bean>
<!-- 配置jsm操作模板 -->
<!-- <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate" >
<property name="connectionFactory" ref="connectionFactory"/>
<property name="defaultDestinationName" value="springQueue"/>这个是点对点
这句能体现出发布与订阅来
<property name="pubSubDomain" value="true"/>
</bean> -->
<!-- 自定义的监听器 -->
<bean id="receiverMessageListener" class="com.bjpowernode.ReceiverMessageListener"/>
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory"/>
<property name="destinationName" value="listenerQueue"/>
<property name="messageListener" ref="receiverMessageListener"/>
</bean>
3接受消息
/**
* 消息的监听器
* @author handy
*
*/
@Component("receiverMessageListener")
public class ReceiverMessageListener implements MessageListener {
@Override
public void onMessage(Message message) {
try {
if(message instanceof TextMessage){
String text = ((TextMessage) message).getText();
System.out.println("收到的消息是"+text);
}else if (message instanceof ObjectMessage) {
}
} catch (JMSException e) {
e.printStackTrace();
}
}
}