ActiveMQ 封装Java代码常用推送消息功能，自己封装简单实用，容易调用，代码如下：
/**
* 發送消息
*/
public void sendMsg() {
logger.info("mq推送消息--------------------------");
//1、获取activeMQ连接
Connection connection = connectionActiveMQ();
//2、使用连接对象创建会话（session）对象
Session session = createSessionActiveMQ(connection);
//3、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
Queue queue = createQueueActiveMQ(session, "aiyaku_mq_test");
//4、使用会话对象创建生产者对象
MessageProducer producer = createProducerActiveMQ(session, queue);
//5、使用会话对象创建一个消息对象
TextMessage textMessage = createTextMessageActiveMQ(session, "aiyaku_mq_test activeMQ消息测试。。");
//6、发送消息
sendMsgActiveMQ(producer,textMessage);
//7、关闭生产者资源
closeProducerActiveMQ(producer);
// 8、关闭session
closeSessionActiveMQ(session);
// 9、关闭activeMQ的连接
closeConnectionActiveMQ(connection);
}
/**
* 向指定队列发送消息
*/
public void sendMessage(String msg) {
Connection connection = connectionActiveMQ();
//2、使用连接对象创建会话（session）对象
Session session = createSessionActiveMQ(connection);
//3、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
Queue queue = createQueueActiveMQ(session, "aiyaku_mq_test1");
//4、使用会话对象创建生产者对象
MessageProducer producer = createProducerActiveMQ(session, queue);
//5、使用会话对象创建一个消息对象
TextMessage textMessage = createTextMessageActiveMQ(session, msg);
//6、发送消息
sendMsgActiveMQ(producer,textMessage);
//7、关闭生产者资源
closeProducerActiveMQ(producer);
// 8、关闭session
closeSessionActiveMQ(session);
// 9、关闭activeMQ的连接
closeConnectionActiveMQ(connection);
}
/**
* 向默认队列发送消息
*/
public void sendMsgDefault(String msg) {
Connection connection = connectionActiveMQ();
//2、使用连接对象创建会话（session）对象
Session session = createSessionActiveMQ(connection);
//3、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
Queue queue = createQueueActiveMQ(session, "aiyaku_mq_test");
//4、使用会话对象创建生产者对象
MessageProducer producer = createProducerActiveMQ(session, queue);
//5、使用会话对象创建一个消息对象
TextMessage textMessage = createTextMessageActiveMQ(session, msg);
//6、发送消息
sendMsgActiveMQ(producer,textMessage);
//7、关闭生产者资源
closeProducerActiveMQ(producer);
// 8、关闭session
closeSessionActiveMQ(session);
// 9、关闭activeMQ的连接
closeConnectionActiveMQ(connection);
}
/**
* 接收消息
*/
public String receiveMsg() {
return "";
}
/**
* 向指定队列发送消息
*/
public void sendMessageMQQueue(String msg) {
}
/**
* 获取
* @return MBeanServerConnection
*/
public void testConnectionJMS(){
String mqUrl="tcp://192.168.1.54:61616";
JMXServiceURL url;
try {
url = new JMXServiceURL(mqUrl);
JMXConnector connector = JMXConnectorFactory.connect(url);
connector.connect();
MBeanServerConnection connection = connector.getMBeanServerConnection();
logger.info("connection===========>"+connection.toString());
} catch (MalformedURLException e) {
logger.error(e.getMessage(), e);
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
/**
* 获取activeMQ连接
* @return Connection
*/
public Connection connectionActiveMQ(){
String active_mq_url=systemConfigServiceBiz.getByCodeCache("active_mq_url");
//1、创建工厂连接对象，需要制定ip和端口号
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(active_mq_url);
//2、使用连接工厂创建一个连接对象
Connection connection;
try {
connection = connectionFactory.createConnection();
//3、开启连接
connection.start();
return connection;
} catch (JMSException e) {
logger.error("获取activeMQ连接失败======》"+e.getMessage(),e);
}
return null;
}
/**
* 关闭activeMQ连接
* @param connection
*/
public void closeConnectionActiveMQ(Connection connection){
try {
connection.close();
} catch (JMSException e) {
logger.error("关闭activeMQ连接失败======》"+e.getMessage(),e);
}
}
/**
* 使用连接对象创建会话（session）对象
* @param connection
* @return Session
*/
public Session createSessionActiveMQ(Connection connection){
Session session=null;
try {
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
} catch (JMSException e) {
logger.error("activeMQ使用连接对象创建会话（session）对象失败======》"+e.getMessage(),e);
}
return session;
}
/**
* 关闭activeMQ会话（session）对象
* @param connection
*/
public void closeSessionActiveMQ(Session session){
try {
session.close();
} catch (JMSException e) {
logger.error("关闭activeMQ会话（session）对象失败======》"+e.getMessage(),e);
}
}
/**
* 使用会话对象创建目标对象queue
* @param session
* @param queueName:队列名称
* @return Queue
*/
public Queue createQueueActiveMQ(Session session,String queueName){
Queue queue=null;
try {
queue = session.createQueue(queueName);
} catch (JMSException e) {
logger.error("activeMQ使用会话对象创建目标对象queue失败====>"+e.getMessage(), e);
}
return queue;
}
/**
* 使用会话对象创建生产者对象
* @param session
* @param queue
* @return MessageProducer
*/
public MessageProducer createProducerActiveMQ(Session session,Queue queue){
MessageProducer producer=null;
try {
producer = session.createProducer(queue);
} catch (JMSException e) {
// TODO Auto-generated catch block
logger.error("activeMQ使用会话对象创建生产者对象失败======>"+e.getMessage(), e);
}
return producer;
}
/**
* 关闭会话对象创建生产者对象
* @param producer
* @return
*/
public void closeProducerActiveMQ(MessageProducer producer){
try {
producer.close();
} catch (JMSException e) {
logger.error("activeMQ关闭会话对象创建生产者对象失败==>"+e.getMessage(), e);
}
}
/**
* 关闭会话对象消费者对象
* @param producer
* @return
*/
public void closeConsumerActiveMQ(MessageConsumer consumer){
try {
consumer.close();
} catch (JMSException e) {
logger.error("activeMQ关闭会话对象创建生产者对象失败==>"+e.getMessage(), e);
}
}
/**
* 发送消息
* @param producer
* @param message
*/
public void sendMsgActiveMQ(MessageProducer producer,Message message){
try {
producer.send(message);
} catch (JMSException e) {
logger.error("activeMQ发送消息失败===》"+e.getMessage(), e);
}
}
/**
* 使用会话对象创建消费者对象
* @param session
* @param queue
* @return MessageConsumer
*/
public MessageConsumer createMessageConsumerActiveMQ(Session session,Queue queue){
MessageConsumer consumer=null;
try {
consumer = session.createConsumer(queue);
} catch (JMSException e) {
// TODO Auto-generated catch block
logger.error("activeMQ使用会话对象创建消费者对象失败======>"+e.getMessage(), e);
}
return consumer;
}
/**
* 使用会话对象创建消费者主题对象
* @param session
* @param topic
* @return MessageConsumer
*/
public MessageConsumer createMessageTopicConsumerActiveMQ(Session session,Topic topic){
MessageConsumer consumer=null;
try {
consumer = session.createConsumer(topic);
} catch (JMSException e) {
// TODO Auto-generated catch block
logger.error("activeMQ使用会话对象创建消费者对象失败======>"+e.getMessage(), e);
}
return consumer;
}
/**
* 向consumer对象中设置一个messageListener对象，用来接收消息
* @param consumer
*/
public void receiveMsgActiveMQ(MessageConsumer consumer){
try {
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
// TODO Auto-generated method stub
if(message instanceof TextMessage){
TextMessage textMessage = (TextMessage)message;
try {
logger.info(textMessage.getText());
} catch (JMSException e) {
logger.error("activeMQ接收消息失败====>"+e.getMessage(), e);
}
}
}
});
} catch (JMSException e) {
logger.error("activeMQ向consumer对象中设置一个messageListener对象，用来接收消息失败===>"+e.getMessage(), e);
}
}
/**
* 使用会话对象创建目标对象topic
* @param session
* @param topicName
* @return Topic
*/
public Topic createTopicActiveMQ(Session session,String topicName){
Topic topic =null;
try {
topic = session.createTopic(topicName);
} catch (JMSException e) {
logger.error("activeMQ使用会话对象创建目标对象topic失败===>"+e.getMessage(), e);
}
return topic;
}
/**
* 使用会话对象创建topic生产者对象
* @param session
* @param queue
* @return MessageProducer
*/
public MessageProducer createProducerTopicActiveMQ(Session session,Topic topic){
MessageProducer producer=null;
try {
producer = session.createProducer(topic);
} catch (JMSException e) {
// TODO Auto-generated catch block
logger.error("activeMQ使用会话对象创建生产者对象失败======>"+e.getMessage(), e);
}
return producer;
}
/**
* 使用会话对象创建一个消息对象，TextMessage发送字符串消息
* @param session
* @param msg
* @return TextMessage
*/
public TextMessage createTextMessageActiveMQ(Session session,String msg){
TextMessage textMessage=null;
try {
textMessage = session.createTextMessage(msg);
} catch (JMSException e) {
logger.error("activeMQ使用会话对象创建一个TextMessage消息对象失败==》"+e.getMessage(), e);
}
return textMessage;
}
/**
* 使用会话对象创建一个消息对象，MapMessage发送Map消息
* @param session
* @param map
* @return MapMessage
*/
public MapMessage createMapMessageActiveMQ(Session session,Map<Object, Object> map){
MapMessage mapMessage=null;
if(null == session || null == map || 0== map.size()){
return mapMessage;
}
try {
mapMessage = session.createMapMessage();
for(Map.Entry<Object, Object> entry : map.entrySet()){
String mapKey = entry.getKey().toString();
String mapValue ="";
if(null != entry.getValue()){
mapValue = entry.getValue().toString();
}
logger.info("MQActive推送map消息,key="+mapKey+":"+mapValue);
mapMessage.setString(mapKey, mapValue);
}
// for(Object key:map.keySet()){
// Object value=map.get(key);
// if(null != value){
// if (value instanceof Integer) {// int类型
// mapMessage.setInt(key.toString(), (int) value);
// } else if (value instanceof String) {// 字符串
// mapMessage.setString(key.toString(), value.toString());
// } else if (value instanceof Double) {// Double类型
// mapMessage.setDouble(key.toString(), (double) value);
// } else if (value instanceof Float) {// Float类型
// mapMessage.setFloat(key.toString(), (float) value);
// } else if (value instanceof Long) {// Long类型
// mapMessage.setLong(key.toString(), (long) value);
// } else if (value instanceof Boolean) {// Boolean类型
// mapMessage.setBoolean(key.toString(), (boolean) value);
// } else if (value instanceof Date) {// Date类型
//
// }else if (value instanceof BigDecimal) {// BigDecimal类型
//
// }
// }
// }
} catch (JMSException e) {
logger.error("activeMQ使用会话对象创建一个MapMessage消息对象失败==》"+e.getMessage(), e);
}
return mapMessage;
}
/**
* 使用会话对象创建一个消息对象，ObjectMessage发送对象消息
* ObjectMessage发送序列化对象消息，Object必须实现Serializable接口
* @param session
* @param Object
* @return ObjectMessage
*/
public ObjectMessage createObjectMessageActiveMQ(Session session,Object object){
ObjectMessage objectMessage=null;
try {
objectMessage = session.createObjectMessage();
objectMessage.setObject((Serializable) object);
} catch (JMSException e) {
logger.error("activeMQ使用会话对象创建一个ObjectMessage消息对象失败==》"+e.getMessage(), e);
}
return objectMessage;
}
/**
* 使用会话对象创建一个消息对象，BytesMessage对象发送字节消息
* @param session
* @param bytes：字节数组
* @return BytesMessage
*/
public BytesMessage createBytesMessageActiveMQ(Session session,byte [] bytes){
BytesMessage bytesMessage=null;
try {
bytesMessage = session.createBytesMessage();
bytesMessage.writeBytes(bytes);
} catch (JMSException e) {
logger.error("activeMQ使用会话对象创建一个BytesMessage消息对象失败==》"+e.getMessage(), e);
}
return bytesMessage;
}
/**
* 使用会话对象创建一个消息对象，StreamMessage对象发送stream消息
* @param session
* @param bytes：字节数组
* @return StreamMessage
*/
public StreamMessage createStreamMessageActiveMQ(Session session,byte [] bytes){
StreamMessage streamMessage=null;
try {
streamMessage = session.createStreamMessage();
streamMessage.writeBytes(bytes);
} catch (JMSException e) {
logger.error("activeMQ使用会话对象创建一个BytesMessage消息对象失败==》"+e.getMessage(), e);
}
return streamMessage;
}
/**
* 接收消息
* @param message
*/
public void receiveMessageActivMQ(Message message) {
try{
logger.info(message.getClass());
// TextMessage
if (message instanceof TextMessage) {
TextMessage textMessage1 = (TextMessage) message;
logger.info(textMessage1.getText());
}
// MapMessage
if (message instanceof MapMessage) {
MapMessage mapMessage = (MapMessage) message;
logger.info(mapMessage.toString());
}
// ObjectMessage
if (message instanceof ObjectMessage) {
ObjectMessage objectMessage = (ObjectMessage) message;
logger.info(objectMessage.toString());
}
// BytesMessage
if (message instanceof BytesMessage) {
byte[] b = new byte[1024];
int len = -1;
BytesMessage bm = (BytesMessage) message;
while ((len = bm.readBytes(b)) != -1) {
logger.info(new String(b, 0, len));
}
}
// StreamMessage
if (message instanceof StreamMessage) {
StreamMessage sm = (StreamMessage) message;
logger.info(sm.readString());
logger.info(sm.readInt());
}
}catch (Exception e){
logger.error("接收消息失败===》"+e.getMessage(), e);
}
}
/**
* queue的发送代码
* @return
* @throws Exception
*/
public Map<String, Object> testMQProducerQueue() throws Exception{
logger.info("queue的发送代码.........................");
Map<String, Object> map=new HashMap<String, Object>();
map.put("code", 200);
//1、创建工厂连接对象，需要制定ip和端口号
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.54:61616");
//2、使用连接工厂创建一个连接对象
Connection connection = connectionFactory.createConnection();
//3、开启连接
connection.start();
//4、使用连接对象创建会话（session）对象
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
Queue queue = session.createQueue("test-queue");
//6、使用会话对象创建生产者对象
MessageProducer producer = session.createProducer(queue);
//7、使用会话对象创建一个消息对象
TextMessage textMessage = session.createTextMessage("hello!test-queue");
//8、发送消息
producer.send(textMessage);
//9、关闭资源
producer.close();
session.close();
connection.close();
map.put("msg", "success");
return map;
}
/**
* 接收代码
* @throws Exception
*/
public Map<String, Object> TestMQConsumerQueue() throws Exception{
logger.info("queue的接收代码.........................");
Map<String, Object> map=new HashMap<String, Object>();
map.put("code", 200);
//1、创建工厂连接对象，需要制定ip和端口号
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.54:61616");
//2、使用连接工厂创建一个连接对象
Connection connection = connectionFactory.createConnection();
//3、开启连接
connection.start();
//4、使用连接对象创建会话（session）对象
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
Queue queue = session.createQueue("test-queue");
//6、使用会话对象创建消费者对象
MessageConsumer consumer = session.createConsumer(queue);
//7、向consumer对象中设置一个messageListener对象，用来接收消息
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
// TODO Auto-generated method stub
if(message instanceof TextMessage){
TextMessage textMessage = (TextMessage)message;
try {
logger.info(textMessage.getText());
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
//8、程序等待接收用户消息
System.in.read();
//9、关闭资源
consumer.close();
session.close();
connection.close();
map.put("msg", "success");
return map;
}
/**
* topic进行测试，发送代码
* @throws Exception
*/
public Map<String, Object> TestTopicProducer() throws Exception{
logger.info("topic进行测试，发送代码.........................");
Map<String, Object> map=new HashMap<String, Object>();
map.put("code", 200);
//1、创建工厂连接对象，需要制定ip和端口号
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.54:61616");
//2、使用连接工厂创建一个连接对象
Connection connection = connectionFactory.createConnection();
//3、开启连接
connection.start();
//4、使用连接对象创建会话（session）对象
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
Topic topic = session.createTopic("test-topic");
//6、使用会话对象创建生产者对象
MessageProducer producer = session.createProducer(topic);
//7、使用会话对象创建一个消息对象
TextMessage textMessage = session.createTextMessage("hello!test-topic");
//8、发送消息
producer.send(textMessage);
//9、关闭资源
producer.close();
session.close();
connection.close();
map.put("msg", "success");
return map;
}
/**
* topic进行测试，接收代码
* @throws Exception
*/
public Map<String, Object> TestTopicConsumer() throws Exception{
Map<String, Object> map=new HashMap<String, Object>();
logger.info("topic进行测试，接收代码.........................");
map.put("code", 200);
//1、创建工厂连接对象，需要制定ip和端口号
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.54:61616");
//2、使用连接工厂创建一个连接对象
Connection connection = connectionFactory.createConnection();
//3、开启连接
connection.start();
//4、使用连接对象创建会话（session）对象
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
Topic topic = session.createTopic("test-topic");
//6、使用会话对象创建生产者对象
MessageConsumer consumer = session.createConsumer(topic);
//7、向consumer对象中设置一个messageListener对象，用来接收消息
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
// TODO Auto-generated method stub
if(message instanceof TextMessage){
TextMessage textMessage = (TextMessage)message;
try {
logger.info(textMessage.getText());
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
//8、程序等待接收用户消息
System.in.read();
//9、关闭资源
consumer.close();
session.close();
connection.close();
map.put("msg", "success");
return map;
}
/**
* ActiveMQ推送map信息
* @param map：推送消息内容map
* @param queueName:队列名称
*/
public void sendMsgMapActiveMQ(String queueName,Map<Object, Object> map){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建队列
Queue queue=createQueueActiveMQ(session, queueName);
// 创建生产者
MessageProducer producer=createProducerActiveMQ(session, queue);
// 创建MapMessage对象
MapMessage mapMessage=createMapMessageActiveMQ(session, map);
// 推送消息
sendMsgActiveMQ(producer, mapMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送字符串信息
* @param msg：推送消息内容
* @param queueName:队列名称
*/
public void sendMsgActiveMQ(String queueName,String msg){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建队列
Queue queue=createQueueActiveMQ(session, queueName);
// 创建生产者
MessageProducer producer=createProducerActiveMQ(session, queue);
// 创建TextMessage对象
TextMessage textMessage=createTextMessageActiveMQ(session, msg);
// 推送消息
sendMsgActiveMQ(producer, textMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送Object信息
* @param object：推送Object消息内容
* @param queueName:队列名称
*/
public void sendObjectActiveMQ(String queueName,Object object){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建队列
Queue queue=createQueueActiveMQ(session, queueName);
// 创建生产者
MessageProducer producer=createProducerActiveMQ(session, queue);
// 创建ObjectMessage对象
ObjectMessage objMessage=createObjectMessageActiveMQ(session, object);
// 推送消息
sendMsgActiveMQ(producer, objMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送字节信息
* @param bytes：推送字节消息内容
* @param queueName:队列名称
*/
public void sendByteActiveMQ(String queueName,byte [] bytes){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建队列
Queue queue=createQueueActiveMQ(session, queueName);
// 创建生产者
MessageProducer producer=createProducerActiveMQ(session, queue);
// 创建BytesMessage对象
BytesMessage bytesMessage=createBytesMessageActiveMQ(session, bytes);
// 推送消息
sendMsgActiveMQ(producer, bytesMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送Stream流信息
* @param bytes：推送字节消息内容
* @param queueName:队列名称
*/
public void sendStreamActiveMQ(String queueName,byte [] bytes){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建队列
Queue queue=createQueueActiveMQ(session, queueName);
// 创建生产者
MessageProducer producer=createProducerActiveMQ(session, queue);
// 创建streamMessage对象
StreamMessage streamMessage=createStreamMessageActiveMQ(session, bytes);
// 推送消息
sendMsgActiveMQ(producer, streamMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* 向consumer对象中设置一个messageListener对象，用来接收消息
* @param consumer
*/
public void receiveActiveMQMsg(String queueName){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建队列
Queue queue=createQueueActiveMQ(session, queueName);
// 创建消费者
MessageConsumer consumer=createMessageConsumerActiveMQ(session, queue);
try {
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
// TODO Auto-generated method stub
receiveMessageActivMQ(message);
cacheServiceBiz.set("ayk_mq_queue:"+queueName, message, 604800L);
}
});
} catch (JMSException e) {
logger.error("activeMQ向consumer对象中设置一个messageListener对象，用来接收消息失败===>"+e.getMessage(), e);
}
// 关闭生产者
closeConsumerActiveMQ(consumer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送主题(topic)map信息
* @param map：推送消息内容map
* @param queueName:队列名称
*/
public void sendMsgMapTopicActiveMQ(String topicName,Map<Object, Object> map){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建主题
Topic topic=createTopicActiveMQ(session, topicName);
// 创建生产者
MessageProducer producer=createProducerTopicActiveMQ(session, topic);
// 创建MapMessage对象
MapMessage mapMessage=createMapMessageActiveMQ(session, map);
// 推送消息
sendMsgActiveMQ(producer, mapMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送主题(topic)字符串信息
* @param msg：推送消息内容
* @param queueName:队列名称
*/
public void sendMsgTopicActiveMQ(String topicName,String msg){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建主题
Topic topic=createTopicActiveMQ(session, topicName);
// 创建生产者
MessageProducer producer=createProducerTopicActiveMQ(session, topic);
// 创建TextMessage对象
TextMessage textMessage=createTextMessageActiveMQ(session, msg);
// 推送消息
sendMsgActiveMQ(producer, textMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送主题(Topic)Object信息
* @param object：推送Object消息内容
* @param queueName:队列名称
*/
public void sendObjectTopicActiveMQ(String topicName,Object object){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建主题
Topic topic=createTopicActiveMQ(session, topicName);
// 创建生产者
MessageProducer producer=createProducerTopicActiveMQ(session, topic);
// 创建ObjectMessage对象
ObjectMessage objMessage=createObjectMessageActiveMQ(session, object);
// 推送消息
sendMsgActiveMQ(producer, objMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送主题字节信息
* @param bytes：推送字节消息内容
* @param queueName:队列名称
*/
public void sendByteTopicActiveMQ(String topicName,byte [] bytes){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建主题
Topic topic=createTopicActiveMQ(session, topicName);
// 创建生产者
MessageProducer producer=createProducerTopicActiveMQ(session, topic);
// 创建BytesMessage对象
BytesMessage bytesMessage=createBytesMessageActiveMQ(session, bytes);
// 推送消息
sendMsgActiveMQ(producer, bytesMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* ActiveMQ推送主题Stream流信息
* @param bytes：推送字节消息内容
* @param queueName:队列名称
*/
public void sendStreamTopicActiveMQ(String topicName,byte [] bytes){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建主题
Topic topic=createTopicActiveMQ(session, topicName);
// 创建生产者
MessageProducer producer=createProducerTopicActiveMQ(session, topic);
// 创建streamMessage对象
StreamMessage streamMessage=createStreamMessageActiveMQ(session, bytes);
// 推送消息
sendMsgActiveMQ(producer, streamMessage);
// 关闭生产者
closeProducerActiveMQ(producer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
/**
* 向consumer对象中设置一个messageListener对象，用来接收主题消息
* @param consumer
*/
public void receiveActiveTopicMQMsg(String topicName){
// 创建activeMQ连接
Connection connection=connectionActiveMQ();
// 创建session会话
Session session=createSessionActiveMQ(connection);
// 创建主题
Topic topic=createTopicActiveMQ(session, topicName);
// 创建消费者
MessageConsumer consumer=createMessageTopicConsumerActiveMQ(session, topic);
try {
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
// TODO Auto-generated method stub
receiveMessageActivMQ(message);
cacheServiceBiz.set("ayk_mq_topic:"+topic, message, 604800L);
}
});
} catch (JMSException e) {
logger.error("activeMQ向consumer对象中设置一个messageListener对象，用来接收主题消息失败===>"+e.getMessage(), e);
}
// 关闭生产者
closeConsumerActiveMQ(consumer);
// 关闭回话对象
closeSessionActiveMQ(session);
// 关闭连接
closeConnectionActiveMQ(connection);
}
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
