[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
    评论
专栏目录
Java开发中常用的消息队列工具 ActiveMQ
longzorg_cn的博客
04-17 898
同类产品： RabbitMQ 、 Kafka、Redis（List）
Apache ActiveMQ使用
wzl_csdn_001的博客
08-19 501
Apache ActiveMQ下载、安装、使用
Java中如何使用消息队列实现异步（ActiveMQ，RabbitMQ，Kafka）
qwert
04-21 2108
在上述示例代码中，生产者通过创建消息并将其发送到队列中，而消费者则监听队列并异步处理接收到的消息。消息队列可以起到解耦作用，使得生产者和消费者之间的交互更加灵活和可靠，因为消息队列具有缓冲和异步处理的特点，即使某个消费者出现故障，也不会影响消息的传递和处理。在 Java 中，可以使用 Kafka 的 Java 客户端实现消息队列的异步处理。在命令行中分别执行 TestQueue 和 TestConsumer 两个类，可以看到生产者向消息队列发送了10条消息，并由消息消费者异步处理这些消息。
activemq消息中间件
qq_46524280的博客
07-26 1203
订单秒杀系统下单之后存在在业务的流程（读取订单、库存检查、库存冻结、余额检查、余额冻结、订单生成、余额扣减、库存扣减、生成流水、余额冻结、库存解冻）RPC接口基本是同步调用，整体的服务性能遵循“木桶理论”，即整体系统的耗时取决于最慢的那个接口。比如A调用B/C/D都是50 ms，但是B调用B1花费的时间为2000 ms，那么将会拖累整个系统的服务性能。注：在设计系统时，明确达到的目标要做到系统解耦，当新的模块接进来时，要做到代码的改动最小；能够解耦。
Java 三种主流的消息中间件 RabbitMQ、Kafka 和 RocketMQ 特点以及适用，使用场景 学习总结
最新发布
weixin_44131922的博客
05-24 1627
RabbitMQ特点基于AMQP（Advanced Message Queuing Protocol）协议，这是一个开放的标准，支持多种语言客户端。支持复杂的消息路由功能，如Direct, Topic, Fanout, Headers交换机类型，能够满足不同的消息分发需求。提供高可用性配置，支持集群部署以保证消息不丢失。社区活跃，文档丰富，易于上手。适用场景当你需要一个功能全面、灵活的消息路由机制，并且对消息的可靠性要求较高时，RabbitMQ是一个好选择。
Apache ActiveMQ 集群配置详解
cuihuang1302的博客
05-12 147
构建高可用的ActiveMQ系统在生产环境中非常重要。对于apache的这个消息中间件实现高可用也非常简单，只要在Apache ActiveMQ单点基本配置基础上做一次配置变更（如果在一台设备上部署多个ActiveMQ，需要修改...
深入浅出JMS ActiveMQ
lky5387的专栏
03-23 686
深入浅出JMS(一)--JMS基本概念 摘要：The Java Message Service (JMS) API is a messaging standard that allows application components based on the Java Platform Enterprise Edition (Java EE) to create, send,
MQTT 服务器 Apache ActiveMQ 搭建
Keep Learning , Keep Improving !
09-01 9429
主页 http://activemq.apache.org/ 下载 http://activemq.apache.org/download.html http://activemq.apache.org/activemq-5155-release.html 解压到 D:\DevTools\apache-activemq-5.15.5-bin cmd 启动： cd /d...
activeMQ简单入门案例
02-09
本教程将引导你通过一个简单的入门案例了解如何使用ActiveMQ实现生产者与消费者的模式。 首先，我们需要了解ActiveMQ的基本概念。在消息队列中，生产者是发送消息的实体，而消费者则是接收和处理这些消息的实体。...
MQ之ActiveMQ.mmap
07-25
自己做的尚硅谷周阳老师ActiveMQ课程脑图，其中自己所用做案例的环境搭建都是基于docker与老师课程不一样。脑图内容涵盖视频的99%的笔记，含有自己编写的代码文件，外加了自己对一些问题的测试与回答。 消息中间件...
AcitveMQ入门案例代码　　　　　　　　
07-15
在提供的"ActiveMQ入门案例代码"中，你可能会看到如何配置ActiveMQ服务器，如何创建并连接到Queue或Topic，以及如何编写生产者和消费者类。此外，还可能包含了如何设置消息属性，如优先级、持久性等，以及如何处理...
Delphi ActiveMQ 使用帮助
10-13
- **文档内容**: 提供了从入门到进阶的指导，涵盖了从安装配置到使用案例等多方面的内容。 #### 三、关于 Apache ActiveMQ Apache ActiveMQ 是一款开源的消息中间件，它实现了 JMS 规范，并提供了丰富的特性，包括...
ActiveMQ使用
weixin_57763462的博客
04-21 804
（2）基于发布/订阅模式的传输，即根据订阅话题来接收相应数据，一个生产者可向多个消费者推送数据，与MQTT协议的实现是类似的，对MQTT协议有兴趣的可跳转到https://www.cnblogs.com/xiguadadage/p/11216463.html。ActiveMQ是一种开源的基于JMS（Java Message Servie）规范的一种消息中间件的实现，ActiveMQ的设计目标是提供标准的，面向消息的，能够跨越多语言和多系统的应用集成消息通信中间件。
ActiveMQ 简介、安装、与 Maven 项目基本使用
蚩尤后裔-汪茂雄
09-13 6916
目录 ActiveMQ 简介 ActiveMQ 5.15.9 安装 ActiveMQ 基本使用 ActiveMQ 简介 1、ActiveMQ 是 Apache 推出的一款开源免费的，完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现的消息中间件（Message Oriented Middleware,MOM） 2、ActiveMQ 最主要的功能是实现 ...
ActiveMQ详细入门教程系列（一）(1)，java企业级开发技术
m0_63174529的博客
12-05 1915
每个消息头字段都有相应的getter和setter方法。 消息属性： 如果需要除消息头字段以外的值，那么可以使用消息属性。 消息体： JMS定义的消息类型有TextMessage、MapMessage、BytesMessage、StreamMessage和ObjectMessage。 消息类型： | 属性 | 类型 | | — | — | | TextMessage | 文本消息 | | MapMessage | k/v | | BytesMessage | 字节流 | | Stream.
Java访问ActiveMQ实例
a1060916181的博客
05-24 432
第一步点开新建然后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...
ActiveMQ使用入门
qq_55917018的博客
12-24 8511
面向消息中间件 和 ActiveMQ 简介，ActiveMQ的安装和配置详解，MessageProducer的发送模式、优先级和过期时间，使用 Spring Boot 简化JMS开发，使用ActiveMQ实现抢购时的并发效率优化
MQ 系列之 ActiveMQ 基本使用
Demo_Null
08-03 5386
ActvieMQ 的基本使用
Apache ActiveMQ实践详解：入门到进阶
ActiveMQ是Apache软件基金会开发的一款开源消息代理和集成模式，它作为Java消息服务（JMS）提供商，广泛应用于分布式系统中的消息传递。本实践入门指南旨在帮助读者理解并掌握ActiveMQ的核心概念、安装与配置、特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值