jms和ActiveMQ的应用例子

最新推荐文章于 2024-11-04 09:00:07 发布
最新推荐文章于 2024-11-04 09:00:07 发布
阅读量976 收藏
点赞数
分类专栏： ActiveMQ VS JMS 文章标签： activemq jms string null class 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/junierzzu/article/details/4492254
版权

package com.example;


import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.jms.TopicPublisher;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.command.ActiveMQTopic;

public class My implements MessageListener{

// 队列的连接工厂和连接
 private QueueConnectionFactory queueConnectionFactory;
 private QueueConnection queueConnection;
// 主题的连接工厂和连接
 private TopicConnectionFactory topicConnectinFactory;
 private TopicConnection topicConnection;
// 主题持久订阅的设置
 private String clientId;
 private String durableName;
// 是否为主题的持久订阅
 private boolean isDurable = false;
// 主题会话
 private TopicSession topicSession;
// 主题发布者
 private TopicPublisher  topicPublisher;
// 主题订阅者
 private TopicSubscriber topicSubscriber;
// 发布的主题
 private Topic topicPublish;
// 发布的主题名称
 private String topicPublishName;
// 订阅的主题名称
 private String topicSubscribName;
// 订阅的主题
 private Topic topicSubscrib;
// 是否采用主题模式
 private boolean isTopic = false;
// 队列会话
 private QueueSession queueSession;
// 队列发送者
 private QueueSender queueSender;
// 队列接收者
 private QueueReceiver queueReceiver;
// 发送的队列
 private Queue queueSend;
//  接收的队列
 private Queue queueReceive;
// 发送的队列名称
 private String queueSendName;
// 接收的队列名称
 private String queueReceiveName;
// 是否采用事务
 private boolean isTransacted = false;
// 应答的参数
 private int acknowledgementMode;
// 连接工厂的参数
 private String user = ActiveMQConnection.DEFAULT_USER;
 private String password = ActiveMQConnection.DEFAULT_PASSWORD;
 private String url = ActiveMQConnection.DEFAULT_BROKER_URL;
// 是否在发送消息用持久模式
 private boolean isPersistent = false;
// 消息的过期时间
 private long timeToLive;
 
 
 public QueueConnectionFactory getQueueConnectionFactory() {
  if(this.queueConnectionFactory==null)
   this.queueConnectionFactory = new ActiveMQConnectionFactory(this.getUser(),this.getPassword(),this.getUrl());
  return queueConnectionFactory;
 }

 public QueueConnection getQueueConnection() {
  if(this.queueConnection==null)
  {

   try {
    this.queueConnection = this.getQueueConnectionFactory().createQueueConnection();
    this.queueConnection.start();
    
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  return queueConnection;
 }

 public TopicConnectionFactory getTopicConnectinFactory() {
  if(this.topicConnectinFactory==null)
  {
   this.topicConnectinFactory = new ActiveMQConnectionFactory(this.getUser(),this.getPassword(),this.getUrl());
  }
  return topicConnectinFactory;
 }

 public TopicConnection getTopicConnection() {
  if(this.topicConnection==null)
  {
   try {
    this.topicConnection = this.getTopicConnectinFactory().createTopicConnection();
    
    if(this.isDurable && this.getClientId()!=null && this.getClientId().length()>0 && !"null".equals(this.getClientId()))
    {
     this.topicConnection.setClientID(this.getClientId());
    }
    this.topicConnection.start();
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  return topicConnection;
 }

 public String getClientId() {
  return clientId;
 }
 public void setClientId(String clientId) {
  this.clientId = clientId;
 }
 public String getDurableName() {
  return durableName;
 }
 public void setDurableName(String durableName) {
  this.durableName = durableName;
 }
 public boolean isDurable() {
  return isDurable;
 }
 public void setDurable(boolean isDurable) {
  this.isDurable = isDurable;
 }
 public TopicSession getTopicSession() {
  if(this.topicSession==null)
  {
   try {
   this.topicSession = this.getTopicConnection().createTopicSession(this.isTransacted(), this.getAcknowledgementMode());
   } catch (JMSException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   }
  }
  return topicSession;
 }

 public TopicPublisher getTopicPublisher() {
  if(this.topicPublisher == null)
  {
   try {
    this.topicPublisher = this.getTopicSession().createPublisher(this.getTopicPublish());
//    是否采用发送方的持久及消息过期的设置
    if(this.isPersistent)
    {
     this.topicPublisher.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
     this.topicPublisher.setTimeToLive(this.getTimeToLive());
    }
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  return topicPublisher;
 }

 public TopicSubscriber getTopicSubscriber() {
  if(this.topicSubscriber==null)
  {
   try {
    if(this.isDurable && this.isTopic )
    {
     this.topicSubscriber = this.getTopicSession().createDurableSubscriber(this.getTopicSubscrib(), this.getDurableName());
    }
    else
    {
     this.topicSubscriber = this.getTopicSession().createSubscriber(this.getTopicSubscrib());
     
    }
//    采用监听的方式接收消息，也可以采用主动接收的方式
    this.topicSubscriber.setMessageListener(this);
    this.getTopicConnection().start();
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  return topicSubscriber;
 }

 public Topic getTopicPublish() {
  this.topicPublish = new ActiveMQTopic(this.getTopicPublishName());
  return topicPublish;
 }

 public String getTopicPublishName() {
  return topicPublishName;
 }
 public void setTopicPublishName(String topicPublishName) {
  this.topicPublishName = topicPublishName;
 }
 public String getTopicSubscribName()
 {
  return topicSubscribName;
 }
 public void setTopicSubscribName(String topicSubscribName)
 {
  this.topicSubscribName = topicSubscribName;
 }
 public Topic getTopicSubscrib() {
  this.topicSubscrib = new ActiveMQTopic(this.getTopicSubscribName());
  return topicSubscrib;
 }

 public boolean isTopic() {
  return isTopic;
 }
 public void setTopic(boolean isTopic) {
  this.isTopic = isTopic;
 }
 public QueueSession getQueueSession() {
  if(this.queueSession==null)
  {
   try {
    this.queueSession = this.getQueueConnection().createQueueSession(this.isDurable(), this.getAcknowledgementMode());
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  return queueSession;
 }

 public QueueSender getQueueSender() {
  if(this.queueSender==null)
  {
   try {
    this.queueSender = this.getQueueSession().createSender(this.getQueueSend()) ;
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  return queueSender;
 }

 public QueueReceiver getQueueReceiver()throws JMSException {
  if(queueReceiver==null)
  {
   this.queueReceiver = this.getQueueSession().createReceiver(this.getQueueReceive());
//   采用监听的方式接收消息，也可以采用主动接收的方式
   this.queueReceiver.setMessageListener(this);
//   this.queueConnection.start();
  }
  return queueReceiver;
 }

 public Queue getQueueSend() {
  this.queueSend = new ActiveMQQueue(this.getQueueSendName());
  return queueSend;
 }

 public  Queue getQueueReceive()
 {
  this.queueReceive = new ActiveMQQueue(this.getQueueReceiveName());
  return queueReceive;
 }

 public String getQueueSendName() {
  return queueSendName;
 }
 public void setQueueSendName(String queueSendName) {
  this.queueSendName = queueSendName;
 }
 public String getQueueReceiveName() {
  return queueReceiveName;
 }
 public void setQueueReceiveName(String queueReceiveName) {
  this.queueReceiveName = queueReceiveName;
 }
 public boolean isTransacted() {
  return isTransacted;
 }
 public void setTransacted(boolean isTransacted) {
  this.isTransacted = isTransacted;
 }
 public int getAcknowledgementMode() {
  return acknowledgementMode;
 }
 public void setAcknowledgementMode(int acknowledgementMode) {
  this.acknowledgementMode = acknowledgementMode;
 }
 public String getUser() {
  return user;
 }
 public void setUser(String user) {
  this.user = user;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public String getUrl() {
  return url;
 }
 public void setUrl(String url) {
  this.url = url;
 }
 public boolean isPersistent() {
  return isPersistent;
 }
 public void setPersistent(boolean isPersistent) {
  this.isPersistent = isPersistent;
 }
 public long getTimeToLive() {
  return timeToLive;
 }
 public void setTimeToLive(long timeToLive) {
  this.timeToLive = timeToLive;
 }
// 发布主题消息--字符串型的消息，也可以发布其他的消息类型
 public void publishTextMessage(String textMessage) throws JMSException
 {
  TextMessage message = this.getTopicSession().createTextMessage();
  message.clearBody();
  message.setText(textMessage);
  this.getTopicPublisher().publish(message);
  
  if(this.isTransacted)
  {
   this.getTopicSession().commit();
  }
  
 }
// 发送队列消息--字符串型的消息，也可以发送其他的消息类型
 public void sendTextMessage(String textMessage) throws JMSException
 {
  TextMessage message = this.getQueueSession().createTextMessage();
  message.clearBody();
  message.setText(textMessage);
  this.getQueueSender().send(message);
  if(this.isTransacted)
  {
   this.getQueueSession().commit();
  }
 }
// 监听接口的方法，用于接收消息
 public void onMessage(Message message) {
  // TODO Auto-generated method stub
  if(message instanceof  TextMessage)
  {
   TextMessage myMessage = (TextMessage)message;
   try {
    
    System.out.println(myMessage.getText());
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  if(this.isTransacted)
  {
   try {
    if(this.isTopic)
    {
     this.getTopicSession().commit();
    }
    else
    {
     this.getQueueSession().commit();
    }
    
   } catch (JMSException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
// 关闭相应的资源
 public void closeResource() throws JMSException
 {
  if(this.isTopic)
  {
   if(this.topicPublisher!=null)
   {
    this.topicPublisher.close();
   }
   if(this.topicSubscriber!=null)
   {
    this.topicSubscriber.close();
   }
   if(this.topicSession!=null)
   {
    this.topicSession.close();
   }
   if(this.topicConnection!=null)
   {
    this.topicConnection.close();
   }
   System.out.println("TopicResource is closed..");
  }
  else
  {
   if(this.queueSender!=null)
   {
    this.queueSender.close();
   }
   if(this.queueReceiver!=null)
   {
    this.queueReceiver.close();
   }
   if(this.queueSession!=null)
   {
    this.queueSession.close();
   }
   if(this.queueConnection!=null)
   {
    this.queueConnection.close();
   }
   System.out.println("QueueResource is closed..");
  }
  
 }
//  测试
 public static void main(String[] args) throws JMSException
 {

//  队列  接收端的测试
//  My receivequeue = new My();
//  receivequeue.setDurable(false);
//  receivequeue.setTopic(false);
//  receivequeue.setTransacted(false);
//  receivequeue.setPersistent(false);
//  receivequeue.setAcknowledgementMode(QueueSession.AUTO_ACKNOWLEDGE);
//  receivequeue.setQueueReceiveName("kkk");
//  receivequeue.getQueueReceiver();
//  synchronized(receivequeue)
//  {
//   try {
//    receivequeue.wait(900);
//   } catch (InterruptedException e) {
//    // TODO Auto-generated catch block
//    e.printStackTrace();
//   }
//  }
//  receivequeue.closeResource();
  

  
//  主题  接收端得测试
  My subscribtopic = new My();
  subscribtopic.setDurable(true);
  subscribtopic.setClientId("opop");
  subscribtopic.setDurableName("ww");
  subscribtopic.setPersistent(false);
  subscribtopic.setTopic(true);
  subscribtopic.setTransacted(false);
  subscribtopic.setAcknowledgementMode(TopicSession.AUTO_ACKNOWLEDGE);
  subscribtopic.setTopicSubscribName("eee");
  subscribtopic.getTopicSubscriber();
     synchronized(subscribtopic)
     {
      try {
    subscribtopic.wait(900);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
     }
     subscribtopic.closeResource();
  
  
 }
 
 
}//end class

以上是队列和主题的编码，下面是启动ActiveMQ的类
[code="java"]package com.by.ptop;

import org.apache.activemq.broker.BrokerService;

public class CreateServer {

 public void startServer()
 {
  BrokerService broker = new BrokerService();
//  配置jms服务器
  try {
   broker.addConnector("tcp://localhost:61616");
   broker.start();
   System.out.println("jms服务器已经启动.");
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 public static void main(String[] args)
 {
  CreateServer cs = new CreateServer();
  cs.startServer();
 }
}

下面是测试用的：
[code="java"]package com.example;

import javax.jms.JMSException;
import javax.jms.QueueSession;
import javax.jms.TopicSession;

import com.by.ptop.CreateServer;

public class MyTest {

 
 public static void main(String[] args) throws JMSException {
//  启动jms服务器
  CreateServer cs = new CreateServer();
  cs.startServer();

  for(int i = 1;i<=9;i++)
  {
//   队列  发送端得编程
//   My sendqueue = new My();
//   sendqueue.setDurable(false);
//   sendqueue.setPersistent(false);
//   sendqueue.setTransacted(false);
//   sendqueue.setTopic(false);
//   sendqueue.setAcknowledgementMode(QueueSession.AUTO_ACKNOWLEDGE);
//   sendqueue.setQueueSendName("kkk");
//   sendqueue.sendTextMessage("zz"+i);
//   sendqueue.closeResource();
   
//   主题 接收端得编程
   My publishtopic = new My();
   publishtopic.setDurable(true);
   publishtopic.setClientId("opop");
   publishtopic.setDurableName("ww");
   publishtopic.setPersistent(false);
   publishtopic.setTransacted(false);
   publishtopic.setTopic(true);
   publishtopic.setAcknowledgementMode(TopicSession.AUTO_ACKNOWLEDGE);
   publishtopic.setTopicPublishName("eee");
   publishtopic.publishTextMessage("zz"+i);
   publishtopic.closeResource();
  }
  
  

 }

}

以上是本人初学jms时写的，如有不足之处，还望大家不吝赐教。

jms和ActiveMQ的一个小例子
iteye_5816的博客
08-20 118
[code="java"]package com.example; import javax.jms.DeliveryMode; import javax.jms.JMSException; import javax.jms.Message; import javax.jms.MessageListener; import javax.jms.Queue; import jav...
简单的JMS实例，包括点对点和主题订阅
lanmh的专栏
06-24 169
程序代码： JMSTest.javapackage com.lizongbo.jmsdemo;import javax.jms.MessageListener;import javax.naming.Context;import javax.jms.QueueConnectionFactory;import javax.jms.QueueConnection;import javax.j...
JMS和ActiveMQ
za10056108的博客
03-22 562
JMS架构简介 Java 消息服务（Java Message Service，简称JMS）是用于访问企业消息系统的开发商中立的API。JMS 在其中扮演的角色与JDBC 很相似，正如JDBC 提供了一套用于访问各种不同关系数据库的公共API，JMS 也提供了独立于特定厂商的企业消息系统访问方式。发送消息的JMS 客户端被称为生产者（producer），而接收消息的JMS 客户端则被称为消费者(
JMS&ActiveMQ
鹏鹏的博客
09-05 766
一、JMS是什么 JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于 面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。 JMS的优势： ①异步：JMS 原本就是一个异步的消息服务，客户端获取消息的时候，不需...
最简单的JMS和ActiveMQ入门学习
飘
09-12 632
一 .什么是消息中间件    1,    消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有Producer（生产者）、Consumer（消费者） 生活中的例子:比如现在出现的各种快递柜或者E栈其实就相当于我们变成邻域的消息中间件,如果没...
Spring整合JMS基于ActiveMQ
qq_41714882的博客
12-31 251
JMS简介 JMS（Java Messaging Service）是Java平台上有关面向消息中间件的技术规范，它便于消息系统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。 JMS本身只定义了一系列的接口规范，是一种与厂商无关的 API，用来访问消息收发系统。它类似于 JDBC(java Database Connectivity)：这里，JDB...
activemq和jms是种什么关系
编程reborn
11-08 796
JMS是一个用于提供消息服务的技术规范，它制定了在整个消息服务提供过程中的所有数据结构和交互流程。而activemq则是消息队列服务，是面向消息中间件（MOM）的最终实现，是真正的服务提供者。 　　jms 的一个标准或者说是一个协议. 通常用于企业级应用的消息传递. 主要有topic 消息(1 对多), queue 消息(1对1)。activemq 是一个jms 的实现, apache 出的.
ActiveMQ与JMS，差异、优缺点详解
virtual_users的博客
11-13 752
ActiveMQ 这是关于消息中间件ActiveMQ的一个系列专题文章，将涵盖JMS、ActiveMQ的初步入门及API详细使用、两种经典的消息模式（PTP and Pub/Sub）、与Spring整合、ActiveMQ集群、监控与配置优化等。话不多说，我们来一起瞧一瞧！ JMS 首先来说较早以前，也就是没有JMS的那个时候，很多应用系统存在一些缺陷： 1.通信的同步性 client端发起调用后，必须等待server处理完成并返回结果后才能继续执行 2.client 和 server 的生命周
JMS —— ActiveMQ 消息中间件
LTY_Sun的博客
01-31 378
我们通过一张图来梳理，为什么要在项目中使用消息中间件    通过这张项目结构图我们可以看出，运营商后台的调用关系最多，用到了商家商品服务、广告内容服务、搜索服务、页面生成服务，这种模块之间的依赖也称为耦合，而耦合越多之后的维护工作就越困难。那么如何改善系统模块调用关系减少模块之间的耦合呢？jdk中默认存在一种JMS, 就是消息中间件，很好的解决了这种文件。 1. JMS简介： 1.1 什么...
一、 JMS-activeMQ 入门
贵在坚持
08-17 432
备注：主要参考黑马老师祯帅课程所写 一、消息中间件 消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有Producer（生产者）、Consumer（消费者） 常见的消息中间件产品: （1）ActiveMQ ActiveMQ ...
JMS 使用 ActiveMQ 传送文件
03-30
**标题：“JMS 使用 ActiveMQ 传送文件”** 在IT领域，Java消息服务（Java ...通过这些知识点的学习和实践，开发者可以掌握使用JMS和ActiveMQ进行文件传输的核心技能，为构建可靠的、分布式的应用打下坚实的基础。
JMS.rar_activemq_jms_jms activemq
09-24
**正文** ActiveMQ是Apache软件基金会开发的一款开源...理解JMS和ActiveMQ的工作原理及其API的使用，对于构建高效、可靠的分布式应用程序至关重要。通过实践和探索"JMS.txt"中的代码，你可以更深入地理解这一过程。
JMS之ActiveMQ工具类+使用例子.zip
07-08
ActiveMQ因其高效、稳定和易用的特性，在企业级应用中被广泛应用。 JMS是一种标准，定义了在Java平台上创建、发送、接收和读取消息的应用程序接口。它提供了一种可靠的消息传递机制，确保数据可以在分布式系统中...
jms之activeMQ 队列和广播模式例子（主要给初学者提供入门知识）
08-06
这篇博客"jms之activeMQ 队列和广播模式例子"主要面向初学者，旨在提供ActiveMQ入门级的知识，通过实例解释队列（Queue）和主题（Topic）这两种基本的消息模式。 首先，我们要理解JMS中的队列和主题的区别。队列...
jms-test.zip_jms activemq_jms test
09-19
描述中提到，“jms测试程序，将tomcat和activeMq整合在一起做的一个发送接受的发布订阅的例子”，这表明项目是基于Tomcat服务器，并且通过ActiveMQ实现了一个发布/订阅模式的消息传递。Tomcat是一个流行的Java应用...
如何正确进行activemq服务搭建及性能调优？
梦在硅谷的博客
10-31 1031
ActiveMQ是Apache软件基金会开发的一个开源消息代理，支持多种消息协议，包括JMS（Java Message Service）、AMQP、MQTT等。它提供了可靠的消息传递、持久性、事务支持等功能。
Linux下安装ActiveMQ-CPP
燃犀的博客
10-31 474
参考文章。
如何在Linux环境中的Qt项目中使用ActiveMQ-CPP
燃犀的博客
10-31 384
之前在Linux下的qt程序中使用activeMQ的时候也是用了很多时间去研究，本来想的是好好记录一下，但是当时顾着写代码。很多细节也不想再去走一遍了。大概写一下怎么使用就行了。注意：一定要先开启服务器。
服务器技术（一）--Linux基础入门
最新发布
qq_32091929的博客
11-04 965
操作系统（OperatingSystem）是应用程序运行的基础支撑环境。操作系统作用是管理和控制计算机系统硬件与软件资源。Intel x86架构上常见的操作系统：Windows、Linux、Unix…PS：有种特殊的Linux支持ARM架构，称为ARM Linux，与标准Linux并不兼容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值