[ActiveMQ] Apache ActiveMQ 入门案例

最新推荐文章于 2024-05-24 10:31:07 发布
最新推荐文章于 2024-05-24 10:31:07 发布
阅读量852 收藏 1
点赞数 1
分类专栏： ActiveMQ 文章标签： java 消息中间件 activemq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Konaji/article/details/75386119
版权

上文提到 [ActiveMQ]消息中间件基本概念及安装

我们安装完ActiveMQ后就可以用程序运行一下了。

首先登陆http://localhost:8161/admin，账号密码默认为admin，创建一个队列：FirstQueue

接下来创建Java项目

引入Jar:activemq-all-5.9.0.jar

P2P模型

//P2P
session.createQueue("FirstQueue");

Sender

Connection connection = null; 
try {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
            ActiveMQConnection.DEFAULT_USER,  
            ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
    connection = connectionFactory.createConnection();  
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
    Destination destination = session.createQueue("FirstQueue");
    MessageProducer producer = session.createProducer(destination);
    TextMessage message = session.createTextMessage("test");  
    producer.send(message);
} catch (Exception e) {  
    e.printStackTrace();  
} finally {  
    try {  
        if (null != connection)  
            connection.close();  
    } catch (Throwable ignore) {  
    }  
}

Receiver

Connection connection = null;  
try {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
            ActiveMQConnection.DEFAULT_USER,  
            ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
    connection = connectionFactory.createConnection(); 
    connection.start();  
    // 获取操作连接
    //自动确认
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Destination destination = session.createQueue("FirstQueue");  
    MessageConsumer consumer = session.createConsumer(destination);  
    while (true) {  
        TextMessage message = (TextMessage)consumer.receive(100000);  
        if (null != message  && message.getText().equals("test")) {  
            System.out.println("收到消息" + message.getText());  
        } else {
            System.out.println("失败消息" + message.getText());  
        }  
    }  
} catch (Exception e) {  
    e.printStackTrace();  
} finally {  
    try {  
        if (null != connection)  
            connection.close();  
    } catch (Throwable ignore) {  
    }  
}

思考:若消息在接收端处理失败怎么办?

//此时我们需要设置手动提交
Session session = connection.
                    createSession(false, Session.CLIENT_ACKNOWLEDGE);
//确认消息处理成功,消息处理成功时调用
message.acknowledge();
//消息重发,默认重发6次,消息异常时调用
//对CLIENT_ACKNOWLEDGE有效,对AUTO_ACKNOWLEDGE无效
session.recover();

Receiver 消息重发处理

Connection connection = null;  
try {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
            ActiveMQConnection.DEFAULT_USER,  
            ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
    connection = connectionFactory.createConnection(); 
    connection.start();  
    // 获取操作连接
    //自动确认
    //session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    //手动确认
    Session session = connection.
            createSession(false, Session.CLIENT_ACKNOWLEDGE);
    Destination destination = session.createQueue("FirstQueue");  
    MessageConsumer consumer = session.createConsumer(destination);  
    while (true) {  
        TextMessage message = (TextMessage)consumer.receive(100000);  
        if (null != message  && message.getText().equals("test")) {  
            System.out.println("收到消息" + message.getText());  
            //确认消息处理成功
            message.acknowledge();
        } else {
            System.out.println("失败消息" + message.getText());  
            //消息重发,默认重发6次
            //对CLIENT_ACKNOWLEDGE有效,对AUTO_ACKNOWLEDGE无效
            session.recover();
        }  
    }  
} catch (Exception e) {  
    e.printStackTrace();  
} finally {  
    try {  
        if (null != connection)  
            connection.close();  
    } catch (Throwable ignore) {  
    }  
}

以上就是P2P模型的相关使用介绍

订阅模型

//订阅
session.createTopic("FirstTopic");

Sender

Connection connection = null; 
try {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
            ActiveMQConnection.DEFAULT_USER,  
            ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
    connection = connectionFactory.createConnection();  
    connection.start();  
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
    Topic createTopic = session.createTopic("FirstTopic");
    MessageProducer producer = session.createProducer(createTopic);
    TextMessage message = session.createTextMessage("test");  
    producer.send(message);
} catch (Exception e) {  
    e.printStackTrace();  
} finally {  
    try {  
        if (null != connection)  
            connection.close();  
    } catch (Throwable ignore) {  
    }  
}

Receiver

Connection connection = null;  
try {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
            ActiveMQConnection.DEFAULT_USER,  
            ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
    // 构造从工厂得到连接对象  
    connection = connectionFactory.createConnection(); 
    // 启动  
    connection.start();  
    //自动确认
    //session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    //手动确认
    Session session = connection.
            createSession(false, Session.CLIENT_ACKNOWLEDGE);
    Topic createTopic = session.createTopic("FirstTopic");
    MessageConsumer consumer = null;
    //非持久化方式
    consumer = session.createConsumer(createTopic);
    while (true) {  
        TextMessage message = (TextMessage)consumer.receive(100000);  
        if (null != message  && message.getText().equals("test")) {  
            System.out.println("收到消息" + message.getText());  
            //确认消息处理成功
            message.acknowledge();
        } else {
            System.out.println("失败消息" + message.getText());  
            //消息重发,默认重发6次
            //对CLIENT_ACKNOWLEDGE有效,对AUTO_ACKNOWLEDGE无效
            session.recover();
        }  
    }  
} catch (Exception e) {  
    e.printStackTrace();  
} finally {  
    try {  
        if (null != connection)  
            connection.close();  
    } catch (Throwable ignore) {  
    }  
}

思考:订阅模型中,接收端必须先启动,并且一直保持启动状态才能接收,如何改善,请继续往下看

订阅模型持久化

Mq持久化默认配置是在mq/conf/activemq.xml中

<!-- mq持久化产生文件的默认地址 -->
<persistenceAdapter>
    <kahaDB directory="${activemq.data}/kahadb"/>
</persistenceAdapter>

Sender修改send方式

/**
 * 持久化
 * DeliveryMode.PERSISTENT 持久化
 * 1 : 优先级
 * 1000*60*60*24 : 持久化的时间 毫秒
 */
producer.send(message, DeliveryMode.PERSISTENT, 1, 1000*60*60*24);

Receiver修改

//1、设置客户端ID, 可以任意写 (注:ID不能重复,多个客户端多个独立ID)
connection.setClientID("receiver-1");

//2、使用持久化方式
//consumer = session. createDurableSubscriber(createTopic, "receiver-1");

订阅模型持久化

Sender

Connection connection = null; 
try {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
            ActiveMQConnection.DEFAULT_USER,  
            ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
    connection = connectionFactory.createConnection();  
    connection.start();  
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
    Topic createTopic = session.createTopic("FirstTopic");
    MessageProducer producer = session.createProducer(createTopic);
    TextMessage message = session.createTextMessage("test");  
    //producer.send(message);
    /**
     * 持久化
     * DeliveryMode.PERSISTENT 持久化
     * 1 : 优先级
     * 1000*60*60*24 : 持久化的时间 毫秒
     */
    producer.send(message, DeliveryMode.PERSISTENT, 1, 1000*60*60*24);
} catch (Exception e) {  
    e.printStackTrace();  
} finally {  
    try {  
        if (null != connection)  
            connection.close();  
    } catch (Throwable ignore) {  
    }  
}

Receiver

Connection connection = null;  
try {
    ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
            ActiveMQConnection.DEFAULT_USER,  
            ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");  
    // 构造从工厂得到连接对象  
    connection = connectionFactory.createConnection(); 
    //设置客户端ID, 可以任意写 (注:ID不能重复,多个客户端多个独立ID)
    connection.setClientID("receiver-1");
    // 启动  
    connection.start();  
    //自动确认
    //session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    //手动确认
    Session session = connection.
            createSession(false, Session.CLIENT_ACKNOWLEDGE);
    Topic createTopic = session.createTopic("FirstTopic");
    MessageConsumer consumer = null;
    //非持久化方式
    //consumer = session.createConsumer(createTopic);
    //使用持久化方式
    consumer = session. createDurableSubscriber(createTopic, "receiver-1");
    while (true) {  
        TextMessage message = (TextMessage)consumer.receive(100000);  
        if (null != message  && message.getText().equals("test")) {  
            System.out.println("收到消息" + message.getText());  
            //确认消息处理成功
            message.acknowledge();
        } else {
            System.out.println("失败消息" + message.getText());  
            //消息重发,默认重发6次
            //对CLIENT_ACKNOWLEDGE有效,对AUTO_ACKNOWLEDGE无效
            session.recover();
        }  
    }  
} catch (Exception e) {  
    e.printStackTrace();  
} finally {  
    try {  
        if (null != connection)  
            connection.close();  
    } catch (Throwable ignore) {  
    }  
}

订阅模型持久化到MySQL数据库

1> 在mq/lib包下放入MySQL驱动 mysql-connector-java-5.1.16-bin.jar

2> 修改mq/conf/activemq.xml

<!-- 注释掉默认持久化方式 -->
<!-- 
<persistenceAdapter>
    <kahaDB directory="${activemq.data}/kahadb"/>
</persistenceAdapter>
 -->
<!-- 使用JDBC方式持久化 -->
<persistenceAdapter>
    <jdbcPersistenceAdapter directory="${activemq.data}/data" dataSource="#MySQL-DS"/>
</persistenceAdapter>


<!-- 添加数据源 -->
<!-- MySQL DataSource -->
<bean id="MySQL-DS" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/testmq?relaxAutoCommit=true"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
    <property name="poolPreparedStatements" value="true"/>
</bean>

重启mq,即可实现持久化到数据库中

1

Spring整合ActiveMQ

引入pom文件

<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-client</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jms</artifactId>
</dependency>

MQ生产者

spring-queue.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!--监听MQ状态-->
    <bean id="activeMQTransportListener"
          class="com.sino.jms.ActiveMQTransportListener"/>

    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
    <bean id="targetConnectionFactory"
          class="org.apache.activemq.ActiveMQConnectionFactory">
        <!--非集群方式连接-->
        <!--<property name="brokerURL" value="tcp://127.0.0.1:61616"/>-->
        <!--以集群方式连接-->
        <property name="brokerURL" value="failover:(tcp://127.0.0.1:61616)"/>
        <!--
        <property name="brokerURL"
            value="failover:(tcp://localhost:61616,tcp://localhost:61617)"/>
        -->
        <!--监听mq状态-->
        <property name="transportListener" ref="activeMQTransportListener"/>
        <!--
            从ActiveMQ5.12.2 开始，为了增强这个框架的安全性,
            ActiveMQ将强制用户配置可序列化的包名,
            trustAllPackages=true是将所有包都添加为可信任
        -->
        <property name="trustAllPackages" value="true"/>
        <!--配置消息重发策略-->
        <property name="redeliveryPolicy">
            <bean class="org.apache.activemq.RedeliveryPolicy">
                <!--启用指数倍数递增的方式增加延迟时间,默认为false-->
                <property name="useExponentialBackOff" value="true"/>
                <!--
                    消息处理异常后重新处理次数,-1:无限次,0:不处理,默认为6
                    useExponentialBackOff = true 时有效
                -->
                <property name="maximumRedeliveries" value="3"/>
                <!--初始重发延迟时间(毫秒)-->
                <property name="initialRedeliveryDelay" value="100"/>
                <!--
                    启用防止冲突功能，因为消息接收时是可以使用多线程并发处理的，
                    应该是为了重发的安全性，避开所有并发线程都在同一个时间点
                    进行消息接收处理,默认为false
                -->
                <property name="useCollisionAvoidance" value="true"/>
                <!--拖延时间倍数，必须要大于1.0-->
                <property name="backOffMultiplier" value="1.5"/>
                <!--指定死信队列，需要MQ开启死信队列-->
                <!--<property name="destination" ref="queueTextDestination"/>-->
            </bean>
        </property>
    </bean>
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="connectionFactory"
          class="org.springframework.jms.connection.SingleConnectionFactory">
        <!--
            目标ConnectionFactory对应真实的
            可以产生JMS Connection的ConnectionFactory
        -->
        <property name="targetConnectionFactory" ref="targetConnectionFactory"/>
    </bean>

    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!--
            这个connectionFactory对应的是我们定义的
            Spring提供的那个ConnectionFactory对象
        -->
        <property name="connectionFactory" ref="connectionFactory"/>
        <!--内部的consumer在receive方法中阻塞的时间,默认是1秒-->
        <property name="receiveTimeout" value="3000" />
        <!-- NON_PERSISTENT非持久化 1 ，PERSISTENT持久化 2 -->
        <!--死信队列 : 缺省持久消息过期，会被送到DLQ，非持久消息不会送到DLQ-->
        <property name="deliveryMode" value="2"/>
    </bean>

    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
    <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!--
            这个connectionFactory对应的是我们定义的
            Spring提供的那个ConnectionFactory对象
        -->
        <property name="connectionFactory" ref="connectionFactory"/>
        <!--Queue队列-->
        <property name="pubSubDomain" value="false"/>
        <!--内部的consumer在receive方法中阻塞的时间,默认是1秒-->
        <property name="receiveTimeout" value="3000" />
        <!-- NON_PERSISTENT非持久化 1 ，PERSISTENT持久化 2 -->
        <!--死信队列 : 缺省持久消息过期，会被送到DLQ，非持久消息不会送到DLQ-->
        <property name="deliveryMode" value="2"/>
    </bean>

    <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
    <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!--
            这个connectionFactory对应的是我们定义的
            Spring提供的那个ConnectionFactory对象
        -->
        <property name="connectionFactory" ref="connectionFactory"/>
        <!--Topic队列-->
        <property name="pubSubDomain" value="false"/>
        <!--内部的consumer在receive方法中阻塞的时间,默认是1秒-->
        <property name="receiveTimeout" value="3000" />
        <!-- NON_PERSISTENT非持久化 1 ，PERSISTENT持久化 2 -->
        <!--死信队列 : 缺省持久消息过期，会被送到DLQ，非持久消息不会送到DLQ-->
        <property name="deliveryMode" value="2"/>
    </bean>

    <!--引入工具类，封装JMS常用方法-->
    <bean id="queueSender" class="com.sino.jms.QueueSender">
        <property name="jmsTemplate" ref="jmsQueueTemplate"/>
    </bean>
    <bean id="topicSender" class="com.sino.jms.TopicSender">
        <property name="jmsTemplate" ref="jmsTopicTemplate"/>
    </bean>


</beans>

ActiveMQTransportListener (MQ状态监听)

package com.sino.jms;

import org.apache.activemq.transport.TransportListener;
import java.io.IOException;

public class ActiveMQTransportListener implements TransportListener {

    /**
     * 对消息传输命令进行监控
     * @param command
     */
    @Override
    public void onCommand(Object command) {
        System.out.println("ActiveMQ Execute Cmd");
    }

    /**
     * 对监控到的异常进行触发
     * @param e
     */
    @Override
    public void onException(IOException e) {
        System.out.println("****************↓↓↓异常↓↓↓*****************");
        e.printStackTrace();
        System.out.println("ActiveMQ Exception Occurred");
    }

    /**
     * 当failover时触发
     */
    @Override
    public void transportInterupted() {
        System.out.println("ActiveMQ Server Connection Is Broken...");
        System.out.println("transportInterupted -> 消息服务器连接发生中断...");
    }

    /**
     * 监控到failover恢复后进行触发
     */
    @Override
    public void transportResumed() {
        System.out.println("ActiveMQ Server Reconnected ...");
        System.out.println("transportResumed -> 消息服务器连接已恢复...");
    }
}

MQ工具类

Sender.java

package com.sino.jms;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.Session;
import java.io.Serializable;
import java.util.Map;

/**
 * 队列消息发送类
 */
public class Sender {

    private JmsTemplate jmsTemplate;

    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    /**
     * 发送一条消息到指定的队列（目标）
     * @param queueName 队列名称
     * @param message 消息内容
     */
    public void send(String queueName,
                     final Serializable message) {
        jmsTemplate.send(queueName, new MessageCreator() {
            public Message createMessage(Session session)
                    throws JMSException {
                return session.createObjectMessage(message);
            }
        });
    }

    public void sendString(String queueName,
                     final String message) {
        jmsTemplate.send(queueName, new MessageCreator() {
            public Message createMessage(Session session)
                    throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }

}

QueueSender.java

package com.sino.jms;

import org.springframework.jms.core.JmsTemplate;

/**
 * 队列消息发送类
 */
public class QueueSender extends Sender {

    private JmsTemplate jmsTemplate;

    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        super.setJmsTemplate(jmsTemplate);
    }

}

TopicSender.java

package com.sino.jms;

import org.springframework.jms.core.JmsTemplate;

/**
 * 订阅消息发送
 */
public class TopicSender extends Sender {

    private JmsTemplate jmsTemplate;

    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        super.setJmsTemplate(jmsTemplate);
    }

}

MQ生产消息Demo

    @Autowired
    private QueueSender queueSender;

    @Autowired
    private TopicSender topicSender;

    @RequestMapping("/delByIds")
    public Result delByIds (Long[] ids){
        queueSender.send("Sino.Queue.Solr.Delete",ids);
        topicSender.send("Sino.Topic.Page.Delete",ids);
    }

MQ消费者(注解版)

在以上生产者的基础上，继续配置消费者

spring-mq-consume-annotation.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:context="http://www.springframework.org/schema/context"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/jms
       http://www.springframework.org/schema/jms/spring-jms.xsd">

    <import resource="spring-mq.xml"/>

    <bean id="jmsListenerContainerFactory"
          class="org.springframework.jms.config.DefaultJmsListenerContainerFactory">
        <property name="connectionFactory" ref="connectionFactory"/>
        <!--开启事务-->
        <property name="sessionTransacted" value="true"/>
        <!--设置手动确认提交-->
        <property name="sessionAcknowledgeMode" value="2"/>
    </bean>
    <!--开启注解-->
    <jms:annotation-driven container-factory="jmsListenerContainerFactory"/>

</beans>

消费者

@Component
public class ListenerAnnotationDemo extends MessageListenerAdapter {

    //concurrency="5-10" 允许的并发数
    //@JmsListener(destination="queue_text1",concurrency="5-10")
    @JmsListener(destination="queue_text")
    public void onMessagehehe(Message message, Session session)
            throws JMSException {
        try {
            TextMessage textMessage = (TextMessage) message;
            System.out.println("接收到消息: " + textMessage.getText());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MQ消费者(XML版1.0)

spring-queue-consume.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:context="http://www.springframework.org/schema/context"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd 
       http://www.springframework.org/schema/jms 
       http://www.springframework.org/schema/jms/spring-jms.xsd">

    <import resource="spring-mq.xml"/>

    <!--这个是队列目的地，点对点的  文本信息-->
    <bean id="queueTextDestination"
          class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg value="queue_text"/>
    </bean>

    <bean id="myMessageListener" class="com.sino.jms.queue.QueueListener"></bean>
    <bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="destination" ref="queueTextDestination" />
        <property name="messageListener" ref="myMessageListener" />
        <!--开启事务-->
        <property name="sessionTransacted" value="true"/>
        <!--设置手动确认提交-->
        <property name="sessionAcknowledgeMode" value="2"/>
    </bean>

    <!--如果配置多个队列或订阅,将上面的三个Bean重新配置一遍即可-->

</beans>

QueueListener.java (消费者)

public class QueueListener implements MessageListener {

    @Override
    public void onMessage(Message message) {
        try {
            TextMessage textMessage = (TextMessage) message;
            System.out.println("接收到消息: " + textMessage.getText());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

MQ消费者(XML版2.0)

spring-queue-consume.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:context="http://www.springframework.org/schema/context"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/jms
       http://www.springframework.org/schema/jms/spring-jms.xsd">

    <import resource="spring-mq.xml"/>

    <bean id="myMessageListener" class="com.sino.jms.queue.QueueListener"/>
    <jms:listener-container
            destination-type="queue" container-type="default"
            connection-factory="connectionFactory" acknowledge="client" >
        <!-- 可写多个监听器 -->
        <jms:listener destination="queue_text" ref="myMessageListener"/>
    </jms:listener-container>
</beans>

开启MQ死信队列

修改mq的配置文件(conf/activemq.xml) , 打开如下地方的注释即可

<policyEntry topic=">" >
    <deadLetterStrategy>
        <individualDeadLetterStrategy queuePrefix= "DLQ." 
                                      useQueueForQueueMessages= "true" />
    </deadLetterStrategy>
    <pendingMessageLimitStrategy>
        <constantPendingMessageLimitStrategy limit="1000"/>
    </pendingMessageLimitStrategy>
</policyEntry>

至此,Mq在Java中的应用就介绍完了

Jia的博客
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
activemq项目实例
03-07
activeMQ java资源 windows平台 点对点、发布订阅、集成spring 自己写的案例
Apache ActiveMQ消息中间件的基本使用
psiitoy的专栏
04-28 827
Apache ActiveMQ是Apache软件基金会所研发的开放源码消息中间件；由于ActiveMQ是一个纯Java程式，因此只需要操作系统支援Java虚拟机，ActiveMQ便可执行。 支持Java消息服务 (JMS) 1.1 版本 Spring Framework 集群 (Clustering) 支持的编程语言包括：C、C++、C#、Delphi、Erlang、Adobe Fla
Java 三种主流的消息中间件 RabbitMQ、Kafka 和 RocketMQ 特点以及适用，使用场景 学习总结
最新发布
weixin_44131922的博客
05-24 1530
RabbitMQ特点基于AMQP（Advanced Message Queuing Protocol）协议，这是一个开放的标准，支持多种语言客户端。支持复杂的消息路由功能，如Direct, Topic, Fanout, Headers交换机类型，能够满足不同的消息分发需求。提供高可用性配置，支持集群部署以保证消息不丢失。社区活跃，文档丰富，易于上手。适用场景当你需要一个功能全面、灵活的消息路由机制，并且对消息的可靠性要求较高时，RabbitMQ是一个好选择。
activemq java 实例_java 消息机制 ActiveMQ入门实例
weixin_34017901的博客
02-13 144
1.下载ActiveMQ去官方网站下载：http://activemq.apache.org/我下载的时候是 ActiveMQ 5.14.0 Release版2.运行ActiveMQ解压缩apache-activemq-5.14.0-bin.zip，然后双击apache-activemq-5.14.0-bin\apache-activemq-5.14.0\bin\win64\activemq.ba...
消息中间件之ActiveMQ的基本使用
积跬步，至千里。
06-24 451
ActiveMQ是Apache软件基金会所研发的开放源代码消息中间件；由于ActiveMQ是一个纯Java程序，因此只需要操作系统支持Java虚拟机，ActiveMQ便可执行。
[消息中间件]ActiveMQ详细入门使用教程
疯一样的女子
05-30 533
ActiveMQ介绍 MQ是消息中间件，是一种在分布式系统中应用程序借以传递消息的媒介，常用的有ActiveMQ，RabbitMQ，kafka。ActiveMQ是Apache下的开源项目，完全支持JMS1.1和J2EE1.4规范的JMS Provider实现。 特点： 1、支持多种语言编写客户端 2、对spring的支持，很容易和spring整合 ...
apache-activemq-5.16.5
12-27
Apache ActiveMQ是业界广泛使用的开源消息中间件，它基于Java消息服务（JMS）标准，提供了高度可扩展、可靠的异步通信能力。标题"apache-activemq-5.16.5"指的是该软件的一个特定版本，即5.16.5版本，通常每个新版本...
apache-activemq-5.17.3
12-27
Apache ActiveMQ是开源的、基于Java消息服务（JMS）的应用服务器，它是Apache软件基金会的一部分。这个名为"apache-activemq-5.17.3"的压缩包包含了ActiveMQ的5.17.3版本，这是一个稳定且功能丰富的发布版本。在深入...
activeMQ简单入门案例
02-09
本教程将引导你通过一个简单的入门案例了解如何使用ActiveMQ实现生产者与消费者的模式。 首先，我们需要了解ActiveMQ的基本概念。在消息队列中，生产者是发送消息的实体，而消费者则是接收和处理这些消息的实体。...
Apache-ActiveMQ教程.docx
09-13
Apache ActiveMQ 是一个开源的消息中间件，它实现了Java消息服务（JMS）1.1规范，适用于J2EE 1.4及更高版本的环境。ActiveMQ因其广泛的语言支持（包括Java、C、C++、AJAX、ACTIONSCRIPT等）、多协议支持（如STOMP、...
Sping整合ActiveMq案例.zip
08-01
在IT行业中，Spring框架是Java领域最常用的轻量级应用框架之一，而ActiveMQ则是Apache组织提供的一个开源消息中间件，常用于实现应用程序间的异步通信。本案例将重点讲解如何将Spring与ActiveMQ整合，以实现高效的...
java操作activeMQ(java项目代码及jar包可运行,队列和订阅模式)
01-26
java操作activeMQ(java项目代码及jar包可运行,队列和订阅模式)
了解 Apache ActiveMQ
bcbobo21cn的专栏
05-18 323
这个是消息中间件；如果做消息开发可能会用到； Apache ActiveMQ简介 简介 Apache ActiveMQ是Apache软件基金会的一个开源项目，是一个基于消息的通信中间件。ActiveMQ是JMS的一个具体实现，支持JMS的两种消息模型。ActiveMQ使用AMQP协议集成多平台应用，使用STOMP协议通过websockets在Web应用程序之间交换消息，使用MQTT协议管理物联网设备。（参考ActiveMQ官网） JMS JMS（Java Message Service），是一个基于消
Java中Activemq的使用
m0_46336269的博客
04-10 1105
什么是Activemq Activemq是一种消息中间件，也就是在两个服务中间负责消息的传递和消息队列。就好比菜市场和饭店的关系中，菜市场就是生产者，饭店就是消费者，蔬菜说就是消息，运输车就是中间件，负责将菜市场中的蔬菜运送到饭店中，饭店再根据菜进行下一步骤。同时Activemq可以以队列的方式进行数据的传输，可以防止数据消费者，也就是接收数据的一方由于数据量过大而引发问题。 设置maven ...
java操作activemq使用
爱笑的冷眸
09-03 250
activemq使用 1，安装并运行activemq 开启activemq 查看状态 2，浏览器运行查看 3，编写java测试代码 测试producer public void produceQueue() throws Exception{ //创建工厂连接 ConnectionFactory connectionFactory = new ActiveMQConnect...
ActiveMQ 入门实战(2)--Java 操作 ActiveMQ
09-07 555
ActiveMQ 入门实战(2)--Java 操作 ActiveMQ 本文主要介绍使用 JMS 1.1 API 来操作 ActiveMQ，文中所使用到的软件版本：Java 1.8.0_191、ActiveMQ "Classic" 5.16.2、ActiveMQ Artemis 2.17.0。 1、Java 操作ActiveMQ "Classic" 使用 JMS 1.1 的 API操作 ActiveMQ "Classic"。 1.1、引入依赖 <dependency> <
ActiveMQ详细入门教程系列（一）(1)，java企业级开发技术
m0_63174529的博客
12-05 1912
每个消息头字段都有相应的getter和setter方法。 消息属性： 如果需要除消息头字段以外的值，那么可以使用消息属性。 消息体： JMS定义的消息类型有TextMessage、MapMessage、BytesMessage、StreamMessage和ObjectMessage。 消息类型： | 属性 | 类型 | | — | — | | TextMessage | 文本消息 | | MapMessage | k/v | | BytesMessage | 字节流 | | Stream.
ActiveMQ使用
weixin_57763462的博客
04-21 801
（2）基于发布/订阅模式的传输，即根据订阅话题来接收相应数据，一个生产者可向多个消费者推送数据，与MQTT协议的实现是类似的，对MQTT协议有兴趣的可跳转到https://www.cnblogs.com/xiguadadage/p/11216463.html。ActiveMQ是一种开源的基于JMS（Java Message Servie）规范的一种消息中间件的实现，ActiveMQ的设计目标是提供标准的，面向消息的，能够跨越多语言和多系统的应用集成消息通信中间件。
Java访问ActiveMQ实例
a1060916181的博客
05-24 431
第一步点开新建然后other 里面的maven里面的maven project。groud id 与packed需要前面写com.xxxxx。 新建完成。 2.在pom.xml添加依赖 添加完后。添加jar 在java里面添加 先new一下。之后添加外部jar 新建java文件 新建后添加此代码 消息生产者TopicPublisher.java package com.activemq.ActiveMQ; import org.apache.activemq.Active...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值