activeMQ

最新推荐文章于 2024-08-06 15:30:01 发布

飞起的蜗牛

最新推荐文章于 2024-08-06 15:30:01 发布

阅读量218

点赞数

分类专栏： activemq 文章标签： activemq java spring

本文链接：https://blog.csdn.net/changzhou0519/article/details/71123669

版权

activemq 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

以下内容均是在网上找别人的博客综合学习而成的，可能会发现某些代码与其他博主的相同

1、安装java和activeMQ

参考网上的资料自行安装，本文涉及到的JDK版本为1.8.0_131，activeMQ版本为apache-activemq-5.14.5，可到官网上下载

2、搭建maven项目

本文给出使用的POM文件，使用eclipse，基于spring开发

2.1 pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.sdnware</groupId>
  <artifactId>start04</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>start04</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.4</version>
    </dependency>

    <dependency>
      <groupId>org.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>3.3.1</version>
    </dependency>  

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.6.RELEASE</version>
    </dependency>

    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-jms</artifactId>  
        <version>4.3.6.RELEASE</version>  
    </dependency>

    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-spring</artifactId>
        <version>5.14.5</version>
    </dependency>

     <!-- 
     <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-core</artifactId>
        <version>5.7.0</version>
    </dependency>-->

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

2.2 spring-activemq.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans" xmlns:amq="http://activemq.apache.org/schema/core"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
     classpath:/org/springframework/beans/factory/xml/spring-beans-4.3.xsd 
     http://activemq.apache.org/schema/core 
     classpath:/org/apache/activemq/activemq.xsd 
     http://www.springframework.org/schema/jms 
     classpath:/org/springframework/jms/config/spring-jms-4.3.xsd">

    <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL">
            <value>tcp://192.168.100.205:61616</value>
        </property>
        <property name="userName">
            <value>admin</value>
        </property>
        <property name="password">
            <value>admin</value>
        </property>
    </bean>

    <!-- PooledConnectionFactory:另外一种设置ConnectionFactory
        <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"
            destroy-method="stop">
            <property name="connectionFactory">
                <bean class="org.apache.activemq.ActiveMQConnectionFactory">
                    <property name="brokerURL">
                        <value>tcp://localhost:61616</value>
                    </property>
                </bean>
            </property>
        </bean>
    -->

    <bean id="connectionFactory"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="jmsFactory" />
        <property name="sessionCacheSize" value="100" />
    </bean>

    <!-- 定义消息队列（Queue） -->
    <bean id="probeQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 设置消息队列的名字 -->
        <constructor-arg>
            <value>probeQueue</value>
        </constructor-arg>
    </bean>

    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="defaultDestination" ref="probeQueue" />
        <property name="receiveTimeout" value="10000" />
        <!-- true是topic，false是queue，默认是false，此处显示写出false -->
        <property name="pubSubDomain" value="false" />
    </bean>

    <!-- 自定义接受消息对象：主动接受消息 -->
    <!-- Message Receiver Definition
    <bean id="messageReceiver" class="com.sdnware.start04.activemq.MessageReceiver">
    </bean>
    <bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="destinationName" value="probeQueue"/>
        <property name="messageListener" ref="messageReceiver"/>
    </bean>
 -->
</beans>

3、生产者

package com.sdnware.start04.activemq;

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

import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class ProducerService {

    private JmsTemplate jmsTemplate;

    public ProducerService(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    //发送指定的队列
    public void sendMessage(Destination destination, final String message) {
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }

    //发送默认的队列
    public void sendMessage(final String msg) {
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });
    }

    public static void main(String[] args) {
        @SuppressWarnings("resource")
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring-activemq.xml");
        JmsTemplate jmsTemplate = classPathXmlApplicationContext.getBean("jmsTemplate",JmsTemplate.class);
        ProducerService p = new ProducerService(jmsTemplate);
        for(int i=0;i<100;i++){
            p.sendMessage("生产者发送了一条消息:"+i);
        }
    }

}

4、消费者

4.1 基于Spring配置，自行放开spring-activemq.xml 中Message Receiver Definition处代码。此段代码参考网上

package com.sdnware.start04.activemq;

import java.text.SimpleDateFormat;
import java.util.Date;

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

public class MessageReceiver implements MessageListener {
    private SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    @Override
    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;
            try {
                String text = textMessage.getText();
                System.out.println(String.format("Received: %s", text + ",time:" + sf.format(new Date())));
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }

}

4.2 基于java代码

package com.sdnware.start04.activemq;

import java.util.concurrent.TimeUnit;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

public class JavaConsumer {

    private ConnectionFactory connectionFactory = null;
    private Connection connection = null;
    private Session session = null;
    private MessageConsumer consumer = null;
    private Destination destination = null;

    public JavaConsumer() {
        connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,
                ActiveMQConnection.DEFAULT_PASSWORD, "tcp://192.168.100.205:61616"); // ActiveMQ默认使用的TCP连接端口是61616
        try {
            connection = connectionFactory.createConnection();
            connection.start();
            //创建一个session
            //第一个参数:是否支持事务，如果为true，则会忽略第二个参数，被jms服务器设置为SESSION_TRANSACTED
           //第二个参数为false时，paramB的值可为Session.AUTO_ACKNOWLEDGE，Session.CLIENT_ACKNOWLEDGE，DUPS_OK_ACKNOWLEDGE其中一个。
           //Session.AUTO_ACKNOWLEDGE为自动确认，客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常，也会被当作正常发送成功。
           //Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后，必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功，并删除消息。
           //DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认。
            session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
            /**
             * 第一种方式：Queue
             */
            destination = session.createQueue("probeQueue");
            consumer = session.createConsumer(destination);

            /**
             * 第二种方式：Topic
             * 
             * Topic topic = session.createTopic("probeTopic"); 
             * consumer = session.createConsumer(topic);
             */
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

    public void receiver() {
        try {
            int i=0;
            while (true) {
                // 设置接收者接收消息的时间，为了便于测试，这里谁定为500s
                TextMessage message = (TextMessage) consumer.receive(500000);
                if (null != message) {
                    TimeUnit.SECONDS.sleep(2L);
                    i++;
                    System.out.println("Receiver " + message.getText());
                    if((i+1)%10 == 0){//此处为测试rollback和commit
                        session.rollback();
                    }else{
                        session.commit();
                    }

                } else {
                    break;
                }
            }
        } catch (JMSException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        JavaConsumer javaConsumer = new JavaConsumer();
        javaConsumer.receiver();
    }
}