Apache activeMq结合spring应用

自己记录点干货，关于apache activeMq的，她的两种消息模式主要分为队列和订阅者，queue和topic，queue是消息发出后，消费后就消失，topic可配置持久化，既消息没来及消费的情况可以持久化到硬盘上，待消费者需要时再消费 ，就是如此。

下面是结合spring的配置文件------------这个是消费者的配置文件，其中生产者的配置已注掉了

<?xml version="1.0" encoding="UTF-8"?>   
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
    http://www.springframework.org/schema/context    
    http://www.springframework.org/schema/context/spring-context-2.5.xsd "   
    default-autowire="byName"> 
    <!-- 包的扫描 -->
    <context:component-scan base-package="com.ycg.exteriorline.message.activeMq" />

    
    
    
    <!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
    <bean id="connectinFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    

<!--<property name="brokerURL" value="failover:(tcp://172.16.251.132:61616,tcp://172.16.251.132:61617)?initialReconnectDelay=100"  /> -->
        <!-- <property name="brokerURL" value="tcp://localhost:61616" /> -->
     <!--从配置文件里读取-->

   <property name="brokerURL" value="${mqUrl}" />
    </bean>
    
    
    
    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="cachingConnectionFactory"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="connectinFactory"></property>
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="10"></property>
    </bean>
    
    
    
    <!-- 配置消息发送目的地方式 -->
    <!-- Queue队列：仅有一个订阅者会收到消息，消息一旦被处理就不会存在队列中 -->
    <bean id="notifyQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg value="q.notify"></constructor-arg>
    </bean>
    
    
    
    <!-- 目的地：Topic主题 ：放入一个消息，所有订阅者都会收到 -->
    <!--这个是主题目的地，一对多的 -->
    <bean id="notifyTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg value="t.notify"></constructor-arg>
    </bean>
    
    
    <!-- Spring JMS Template 配置JMS模版 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="cachingConnectionFactory" />
    </bean>
    
    
    
    <!-- 使用Spring JmsTemplate 的消息生产者 -->
    <!-- <bean id="queueMessageProducer" class="com.ycg.exteriorline.message.activeMq.QueueMessageProducer">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
        <property name="notifyQueue" ref="notifyQueue"></property>
        <property name="messageConverter" ref="messageConverter"></property>
    </bean>
    <bean id="topicMessageProducer" class="com.ycg.exteriorline.message.activeMq.TopicMessageProducer">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
        <property name="notifyTopic" ref="notifyTopic"></property>
        <property name="messageConverter" ref="messageConverter"></property>
    </bean> -->
    
    
    
    <!-- 消息消费者 一般使用spring的MDP异步接收Queue模式 -->
    <!-- 消息监听容器 -->
    <bean id="queueContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectinFactory"></property>
        <property name="destination" ref="notifyQueue"></property>
        <property name="messageListener" ref="queueMessageListener"></property>
    </bean>
    
    
    
    <!-- 消息监听容器 -->
    <bean id="topicContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectinFactory"></property>
        <property name="destination" ref="notifyTopic"></property>
        <property name="messageListener" ref="topicMessageListener"></property>
        <!-- 发布订阅模式 -->
        <property name="pubSubDomain" value="true" />
        <!-- 开启持久化，订阅者必须指定clientId -->
        <property name="subscriptionDurable" value="true"/>
        <property name="clientId" value="clientId_001"/>
         <property name="durableSubscriptionName" value="clientId_001"/>
    </bean>
     <!-- 消息监听容器2 -->
    <!--<bean id="topicContainer2"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectinFactory"></property>
        <property name="destination" ref="notifyTopic"></property>
        <property name="messageListener" ref="topicMessageListener2"></property>
       是否持久化，true为持久化，若持久化，必须能保证，clientId和durableSubscriptionName相同

         <property name="subscriptionDurable" value="true"/>
        <property name="clientId" value="clientId_002"/>
        <property name="durableSubscriptionName" value="clientId_002"/>
        发布订阅模式 
        <property name="pubSubDomain" value="true" />
    </bean>-->
     
    
    
    
    <!-- 异步接收消息处理类 -->
    <bean id="queueMessageListener" class="com.ycg.exteriorline.message.activeMq.QueueMessageListener">
        <property name="messageConverter" ref="messageConverter"></property>
    </bean>
    <!-- <bean id="topicMessageListener" class="com.ycg.exteriorline.message.activeMq.TopicMessageListener">
        <property name="messageConverter" ref="messageConverter"></property>
    </bean> -->
    <bean id="topicConsumerA" class="com.ycg.exteriorline.message.activeMq.TopicMessageListener">

<!--这里注掉转换器是因为，消息直接序列化了，不需要再转，可以在拿到消息后手动强转成java对象-->
        <!-- <property name="messageConverter" ref="messageConverter"></property> -->
    </bean>
    <!-- <bean id="topicConsumerB" class="com.ycg.exteriorline.message.activeMq.TopicMessageListener2">
        <property name="messageConverter" ref="messageConverter"></property>
    </bean> -->
    
    
    <!-- 配置了两个消费者： 
            所以需要两个监听容器：topicContainer，topicContainer2
    
    -->
    <bean id="topicMessageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
        <constructor-arg ref="topicConsumerA" />  
        <!--  may be other method -->  
        <!-- <property name="defaultListenerMethod" value="receive" />   -->
        <!-- custom MessageConverter define -->  
        <!-- <property name="messageConverter" ref="defaultMessageConverter" />   -->
    </bean>  
  
  <!--   <bean id="topicMessageListener2" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
        <constructor-arg ref="topicConsumerB" />  
         may be other method  
        <property name="defaultListenerMethod" value="receive" />  
        custom MessageConverter define  
        <property name="messageConverter" ref="defaultMessageConverter" />  
    </bean>  -->
    
    
    
    <!-- <bean id="messageConverter" class="com.ycg.exteriorline.message.activeMq.NotifyMessageConverter">
    </bean> -->
    <bean id="messageConverter" class="com.ycg.exteriorline.message.activeMq.NotifyMessageConverter">
    </bean>
</beans>

 

 

------------------------------------------------下面试转换器

 

import java.io.Serializable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.apache.activemq.command.ActiveMQObjectMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.MessageConverter;

public class NotifyMessageConverter implements MessageConverter{
    private static Logger logger = LoggerFactory.getLogger(NotifyMessageConverter.class);
   //消息转换java对象，可看源码，中有注释
    @Override
    public Object fromMessage(Message message) throws JMSException, MessageConversionException {
        // TODO Auto-generated method stub
        return null;
    }

 //java对象转换消息，可看源码，中有注释
    @Override
    public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
        ActiveMQObjectMessage msg = (ActiveMQObjectMessage)session.createObjectMessage();
        msg.setObject((Serializable)object);
        return msg;
    }
}

----------------------------------------------------------消费者

----------消费者只要实现MessageListener接口，并在配置文件中配置就行

 

import java.io.Serializable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;

public class TopicMessageListener implements MessageListener{

    @Override
    public void onMessage(Message message) {

        ObjectMessage objectMessage  = (ObjectMessage)message;

        Serializable noticeInfo = null;
        try {
            noticeInfo = (Serializable) objectMessage.getObject();
        } catch (JMSException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("-------------------消费者一接受消息-----------------------"+noticeInfo);

    }

}

项目启动程序：

 

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ServiceLauncher {

    private static final Logger logger = LoggerFactory.getLogger(ServiceLauncher.class);

    private static volatile boolean  running = true;
    
    private static ClassPathXmlApplicationContext context;

    public static void main(String[] args) throws Exception {
        context = new ClassPathXmlApplicationContext(new String[] { "classpath*:conf/app-context.xml" });
        context.start();
        
        System.out.println("start service");
        
        try {
            logger.info("INFO ## the Service server is running now ......");
            Runtime.getRuntime().addShutdownHook(new Thread() {

                public void run() {
                    try {
                        logger.info("INFO ## stop the Service server");
                        context.close();
                    } catch (Throwable e) {
                        logger.warn("WARN ##something goes wrong when stopping Service Server:\n{}");
                    } finally {
                        logger.info("INFO ## Service server is down.");
                    }

                    synchronized (ServiceLauncher.class) {
                        running = false;
                        ServiceLauncher.class.notify();
                    }
                }

            });
        } catch (Throwable e) {
            logger.error("ERROR ## Something goes wrong when starting up the Service Server:\n{}");
            System.exit(0);
        }
        
        synchronized (ServiceLauncher.class) {
            while (running) {
                try {
                    ServiceLauncher.class.wait();
                } catch (Throwable e) {
                }
            }
        }
    }
}
 

 

--------------config.properties

mqUrl=tcp://localhost:61616

---------------log4j.xml -----------建议自写，这个另一个项目，拿过来用了下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[CMS]%d %c %p %m%n" />
        </layout>
    </appender>
    <appender name="APPLICATION" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="./logs/cms/application.log" />
        <param name="encoding" value="utf-8" />
        <param name="threshold" value="INFO" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[CMS]%d %c %p %X{url} %m%n" />
        </layout>
    </appender>
    <appender name="ERROR" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="./logs/cms/application-error.log" />
        <param name="encoding" value="utf-8" />
        <param name="threshold" value="ERROR" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[CMS]%d %c %p %X{url} %m%n" />
        </layout>
    </appender>
    <appender name="CAPABILITY" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="./logs/cms/application-capability.log" />
        <param name="encoding" value="utf-8" />
        <param name="threshold" value="ERROR" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[CMS]%d %c %p %X{url} %m%n" />
        </layout>
    </appender>
    <appender name="REMOTING" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="./logs/cms/remoting.log" />
        <param name="encoding" value="utf-8" />
        <param name="threshold" value="INFO" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[CMS]%d %c %p %m%n" />
        </layout>
    </appender>
    <appender name="ACCESS" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="./logs/cms/access.log" />
        <param name="encoding" value="utf-8" />
        <param name="threshold" value="INFO" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern"
                value="[CMS]%d %X{username}@%X{remoteAddr} %X{method} %X{url} UserAgent:%X{userAgent} Referer:%X{referer}%n" />
        </layout>
    </appender>
    <appender name="ACCESS-WARN" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="./logs/cms/access-warn.log" />
        <param name="encoding" value="utf-8" />
        <param name="threshold" value="WARN" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern"
                value="[CMS]%d %X{username}@%X{remoteAddr} %X{method} %X{url} UserAgent:%X{userAgent} Referer:%X{referer} %m%n" />
        </layout>
    </appender>

    <appender name="IBatis" class="org.apache.log4j.ConsoleAppender">
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-4r [%t] %-5p %c %x - %m%n" />
        </layout>
        <filter class="org.apache.log4j.varia.LevelRangeFilter">
            <param name="LevelMin" value="DEBUG" />
            <param name="LevelMax" value="DEBUG" />
        </filter>
    </appender>

    <logger name="org.apache.ibatis" additivity="true">
        <level value="DEBUG" />
    </logger>
    <logger name="java.sql.Connection" additivity="true">
        <level value="DEBUG" />
    </logger>
    <logger name="java.sql.Statement" additivity="true">
        <level value="DEBUG" />
    </logger>
    <logger name="java.sql.PreparedStatement" additivity="true">
        <level value="DEBUG" />
        <appender-ref ref="IBatis" />
    </logger>
    <logger name="java.sql.ResultSet" additivity="true">
        <level value="DEBUG" />
        <appender-ref ref="IBatis" />
    </logger>

    <logger name="org.apache">
        <level value="WARN" />
    </logger>

    <logger name="org.springframework">
        <level value="WARN" />
    </logger>

    <logger name="org.apache.catalina">
        <level value="WARN" />
    </logger>

    <root>
        <level value="INFO" />
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="APPLICATION"/>
        <appender-ref ref="ERROR"/>
    </root>

</log4j:configuration>
 

 

--------------------------------------------------------以上完整的消费者客户端，并采用订阅者模式接受消息，若采用queue只需要，写一个相关类实现MessageListener就行。其他实现，大致雷同，有兴趣的朋友可以试试。

 

 

 

 

 

----------------------------------------------------------------------------------------

-----------------------------------------------------下面是生产者的配置文件，app-context-mq.xml

 

 

<?xml version="1.0" encoding="UTF-8"?>   
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
    http://www.springframework.org/schema/context    
    http://www.springframework.org/schema/context/spring-context-2.5.xsd "   
    default-autowire="byName"> 
    <!-- 包的扫描 -->
    <context:component-scan base-package="com.message.activeMq" />

    
    
    
    <!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
    <bean id="connectinFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
     <!-- <property name="brokerURL" value="failover:(tcp://172.16.251.132:61616,tcp://172.16.251.132:61617)?initialReconnectDelay=100"  /> -->
        <!-- <property name="brokerURL" value="tcp://localhost:61616" /> -->
        <property name="brokerURL" value="${mqUrl}" />
    </bean>
    
    
    
    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="cachingConnectionFactory"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="connectinFactory"></property>
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="10"></property>
    </bean>
    
    
    
    <!-- 配置消息发送目的地方式 -->
    <!-- Queue队列：仅有一个订阅者会收到消息，消息一旦被处理就不会存在队列中 -->
    <bean id="notifyQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg value="q.notify"></constructor-arg>
    </bean>
    
    
    
    <!-- 目的地：Topic主题 ：放入一个消息，所有订阅者都会收到 -->
    <!--这个是主题目的地，一对多的 -->
    <bean id="notifyTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg value="t.notify"></constructor-arg>
    </bean>
    
    
    <!-- Spring JMS Template 配置JMS模版 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="cachingConnectionFactory" />
    </bean>
    
    
    
    <!-- 使用Spring JmsTemplate 的消息生产者 -->
    <bean id="queueMessageProducer" class="com.ycg.exteriorline.message.activeMq.QueueMessageProducer">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
        <property name="notifyQueue" ref="notifyQueue"></property>
        <property name="messageConverter" ref="messageConverter"></property>
    </bean>
    <bean id="topicMessageProducer" class="com.ycg.exteriorline.message.activeMq.TopicMessageProducer">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
        <property name="notifyTopic" ref="notifyTopic"></property>
        <property name="messageConverter" ref="jmsmessageConverter"></property>
<!--         <property name="messageConverter" ref="messageConverter"></property> -->
    </bean>
    
    
    
    <!-- 消息消费者 一般使用spring的MDP异步接收Queue模式 -->
    <!-- 消息监听容器 -->
    <bean id="queueContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectinFactory"></property>
        <property name="destination" ref="notifyQueue"></property>
        <property name="messageListener" ref="queueMessageListener"></property>
    </bean>
    
    
    
    
    
    
    <!-- 异步接收消息处理类 -->
    <bean id="queueMessageListener" class="com.ycg.exteriorline.message.activeMq.QueueMessageListener">
        <property name="messageConverter" ref="messageConverter"></property>
    </bean>
    <!-- <bean id="topicMessageListener" class="com.ycg.exteriorline.message.activeMq.TopicMessageListener">
        <property name="messageConverter" ref="messageConverter"></property>
    </bean> -->
    
    
    
    
    
    
    <!-- <bean id="messageConverter" class="com.ycg.exteriorline.message.activeMq.NotifyMessageConverter">
    </bean> -->
    <bean id="jmsmessageConverter" class="com.ycg.exteriorline.message.activeMq.MessageConvertForSys">
    </bean>
</beans>

 

 

--------------------------------------------------------订阅者生产者

 

 

import javax.jms.Destination;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.support.converter.MessageConverter;

public class TopicMessageProducer implements TopicMessageProducerManager{
    private JmsTemplate jmsTemplate;
    private Destination notifyQueue;
    private Destination notifyTopic;
    public Destination getNotifyTopic() {
        return notifyTopic;
    }
    @Override
    public void setNotifyTopic(Destination notifyTopic) {
        this.notifyTopic = notifyTopic;
    }
    private MessageConverter messageConverter;
    @Override
    public <T> void sendTopic(T noticeInfo){
        sendMessage(noticeInfo);
    }
    private <T> void sendMessage(T noticeInfo) {
        // TODO Auto-generated method stub
        jmsTemplate.setMessageConverter(messageConverter);
        //jmsTemplate.setPubSubDomain(false);
        jmsTemplate.convertAndSend(notifyTopic,noticeInfo);
    }
    public JmsTemplate getJmsTemplate() {
        return jmsTemplate;
    }
    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }
    public Destination getNotifyQueue() {
        return notifyQueue;
    }
    public void setNotifyQueue(Destination notifyQueue) {
        this.notifyQueue = notifyQueue;
    }
    public MessageConverter getMessageConverter() {
        return messageConverter;
    }
    public void setMessageConverter(MessageConverter messageConverter) {
        this.messageConverter = messageConverter;
    }
}
 

-----------------------------------------------生产者接口

 

import javax.jms.Destination;

public interface TopicMessageProducerManager {
    public void setNotifyTopic(Destination destination);
    public <T> void sendTopic(T noticeInfo);
}
 

 

 

-------------------------------------------------------队列模式生产者

 

import javax.jms.Destination;

import org.springframework.jms.core.JmsTemplate;

public class QueueMessageProducer {
    private JmsTemplate jmsTemplate;
    private Destination notifyQueue;
    private NotifyMessageConverter messageConverter;
    public void sendQueue(PhoneNoticeInfo noticeInfo){
        sendMessage(noticeInfo);
    }
    private void sendMessage(PhoneNoticeInfo noticeInfo) {
        // TODO Auto-generated method stub
        jmsTemplate.setMessageConverter(messageConverter);
        jmsTemplate.setPubSubDomain(false);
        jmsTemplate.convertAndSend(notifyQueue,noticeInfo);
    }
    public JmsTemplate getJmsTemplate() {
        return jmsTemplate;
    }
    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }
    public Destination getNotifyQueue() {
        return notifyQueue;
    }
    public void setNotifyQueue(Destination notifyQueue) {
        this.notifyQueue = notifyQueue;
    }
    public NotifyMessageConverter getMessageConverter() {
        return messageConverter;
    }
    public void setMessageConverter(NotifyMessageConverter messageConverter) {
        this.messageConverter = messageConverter;
    }
}
 

----------------------------------------------testcase

 

 

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @SuppressWarnings("resource")
    @org.junit.Test
    public void sendTest(){

        ApplicationContext act = new ClassPathXmlApplicationContext(new String[] { "classpath*:conf/app-context.xml" });
        TopicMessageProducer qmp=(TopicMessageProducer) act.getBean("topicMessageProducer");
        System.out.println("sad");
        for(int i=0;i<10;i++){

            PhoneNoticeInfo info = new PhoneNoticeInfo();
            info.setNoticeContent("你好！");
            qmp.sendTopic("dfsdfsadfsadfsad");
            System.out.println("topic信息已发送----》+"+i+"");
        }
 
 
    }
}

 -----------------------------------------------------PhoneNoticeInfo

 

 

import java.io.Serializable;

public class PhoneNoticeInfo implements Serializable{
    /** 消息标题 */
    public String noticeTitle;
    /** 消息内容 */
    public String noticeContent;
    /** 接收者 */
    public String receiver;
    /** 接收手机号 */
    public String receiverPhone;
    public String getNoticeTitle() {
        return noticeTitle;
    }
    public void setNoticeTitle(String noticeTitle) {
        this.noticeTitle = noticeTitle;
    }
    public String getNoticeContent() {
        return noticeContent;
    }
    public void setNoticeContent(String noticeContent) {
        this.noticeContent = noticeContent;
    }
    public String getReceiver() {
        return receiver;
    }
    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }
    public String getReceiverPhone() {
        return receiverPhone;
    }
    public void setReceiverPhone(String receiverPhone) {
        this.receiverPhone = receiverPhone;
    }
}
 

 

----------------------------------------------

消息转换器

 

import java.io.Serializable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Session;

import org.apache.activemq.command.ActiveMQObjectMessage;
import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.MessageConverter;

public class MessageConvertForSys implements MessageConverter {  
    public Message toMessage(Object object, Session session)  
            throws JMSException, MessageConversionException {  
        System.out.println("[toMessage]");  
        ObjectMessage objectMessage = session.createObjectMessage();  
        //  
        objectMessage.setObject((Serializable) object);  
        return objectMessage;  
    }  

    public Object fromMessage(Message message) throws JMSException,
            MessageConversionException {
        // TODO Auto-generated method stub
        return null;
    }  
}  

转载于:https://my.oschina.net/u/3139755/blog/814228