amqp rabbitmq_Spring AMQP RabbitMQ示例

最新推荐文章于 2024-01-19 14:34:37 发布
最新推荐文章于 2024-01-19 14:34:37 发布
阅读量151 收藏
点赞数
文章标签： 队列 java maven spring rabbitmq
原文链接：https://www.journaldev.com/11713/spring-amqp-rabbitmq-example
版权

amqp rabbitmq

Today we will look into Spring AMQP RabbitMQ example application. We have already discussed some “Spring AMQP Basics Theoretically” and “How to install and setup RabbitMQ Server” in my previous posts. Please refer them in the following:

今天，我们将研究Spring AMQP RabbitMQ示例应用程序。 在之前的文章中，我们已经讨论了“ Spring AMQP基础知识”和“如何安装和设置RabbitMQ Server”。 请参考以下内容：

In this post, we are going to develop a Spring AMQP RabbitMQ Messaging application. Let us start it now.

在本文中，我们将开发一个Spring AMQP RabbitMQ Messaging应用程序。 让我们现在开始。

Spring AMQP RabbitMQ示例 (Spring AMQP RabbitMQ Example)

Let us start developing a Spring AMQP RabbitMQ Messaging application using Maven, Eclipse IDE and RabbitMQ Server. It is same for all other Java IDEs.

让我们开始使用Maven，Eclipse IDE和RabbitMQ Server开发Spring AMQP RabbitMQ Messaging应用程序。 对于所有其他Java IDE都是一样的。

Please do the following the steps one by one:

请一一执行以下步骤：

  1. Create a Maven Java project in Eclipse IDE

    在Eclipse IDE中创建Maven Java项目
  2. Develop Spring AMQP Publisher program

    开发Spring AMQP Publisher程序 
  3. package com.tp.spring.amqp.rabbit;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAMQPRabbitSender {
    private final String SENDER_XML = "springamqp-rabbit-sender-context.xml";
    public static void main(String[] args) throws Exception {
      AmqpTemplate amqpTemplate = (AmqpTemplate)(new ClassPathXmlApplicationContext(SENDER_XML)).getBean("amqpTemplate");
      int messagCount = 0;
	  while (messagCount < 10){
	    amqpTemplate.convertAndSend("tp.routingkey.1", "Message # " + messagCount++);
	  }
	  System.out.println( messagCount + " message(s) sent successfully.");
	}
}
  4. Configure Spring AMQP Publisher required beans : springamqp-rabbit-sender-context.xml

    配置Spring AMQP Publisher所需的bean：s​​pringamqp-rabbit-sender-context.xml 
  5. <?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
	  xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	  xmlns:rabbit="https://www.springframework.org/schema/rabbit"
	  xsi:schemaLocation="https://www.springframework.org/schema/beans 
	  https://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
	  https://www.springframework.org/schema/rabbit 
	  https://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">

	<rabbit:connection-factory id="connectionFactory" 
	host="localhost" username="tpuser" password="tpuser"/>

	<rabbit:admin connection-factory="connectionFactory"/>
	
	<rabbit:template id="amqpTemplate" connection-factory="connectionFactory"
	exchange="tpExchange"/>	
</beans>
  6. Develop Spring AMQP Consumer(Spring MDP) program

    开发Spring AMQP Consumer（Spring MDP）程序 
  7. package com.tp.spring.amqp.rabbit;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
// Spirng MDP(Message Driven POJO)
public class SpringAMQPRabbitAyncListener implements MessageListener {
	@Override
	public void onMessage(Message message) {
		System.out.println("Listener received message = " + new String(message.getBody()));
	}
}
  8. Configure Spring AMQP Consumer required beans : springamqp-rabbt-listener-context.xml

    配置Spring AMQP Consumer需要的bean：s​​pringamqp-rabbt-listener-context.xml 
  9. <?xmlversion="1.0"encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
	  xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
          xmlns:rabbit="https://www.springframework.org/schema/rabbit"
	  xsi:schemaLocation="https://www.springframework.org/schema/beans 
	  https://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
	  https://www.springframework.org/schema/rabbit
	  https://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">

	<rabbit:connection-factory id="connectionFactory" host="localhost" 
              username="tpuser" password="tpuser"/>

	<rabbit:admin connection-factory="connectionFactory"/>
	<rabbit:queue id="tpQueue"/>
	
	<rabbit:topic-exchange id="tpExchange" name="tpExchange">
		<rabbit:bindings>
			<rabbit:binding queue="tpQueue" pattern="tp.routingkey.1">
			</rabbit:binding>
		</rabbit:bindings>
	</rabbit:topic-exchange>
	
	<bean id="asyncListener" class="com.tp.spring.amqp.rabbit.SpringAMQPRabbitAyncListener"/>
	<rabbit:listener-container id="myListenerContainer" connection-factory="connectionFactory">
		<rabbit:listener ref="asyncListener" queue-names="tpQueue"/>
	</rabbit:listener-container>

</beans>
  10. Develop Spring AMQP Rabbit Container program to initialize Spring IOC Container

    开发Spring AMQP Rabbit Container程序以初始化Spring IOC Container 
  11. package com.tp.spring.amqp.rabbit;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAMQPRabbitlListenerContainer {
	public static void main(String[] args) {
        // Initialize Spring IOC Container
        new ClassPathXmlApplicationContext("springamqp-rabbt-listener-context.xml");
	}
}
  12. Final pom.xml file

    最终的pom.xml文件 
  13. <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.tp</groupId>
	<artifactId>spring-amqp-rabbitmq</artifactId>
	<name>spring-amqp-rabbitmq</name>
	<packaging>jar</packaging>
	<version>1.0.0</version>
	<properties>
		<java-version>1.6</java-version>
		<org.springframework-version>3.1.1.RELEASE</org.springframework-version>
		<org.aspectj-version>1.6.10</org.aspectj-version>
		<org.slf4j-version>1.6.6</org.slf4j-version>
	</properties>
	<dependencies>
		<!-- Spring -->
		<dependency>
		  <groupId>org.springframework</groupId>
		  <artifactId>spring-context</artifactId>
		  <version>${org.springframework-version}</version>
		  <exclusions>
			<!-- Exclude Commons Logging in favor of SLF4j -->
			<exclusion>
				<groupId>commons-logging</groupId>
				<artifactId>commons-logging</artifactId>
			 </exclusion>
		  </exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
				
		<!-- AspectJ -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${org.aspectj-version}</version>
		</dependency>	
		<!-- Logging -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${org.slf4j-version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.15</version>
			<exclusions>
				<exclusion>
					<groupId>javax.mail</groupId>
					<artifactId>mail</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.jms</groupId>
					<artifactId>jms</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jdmk</groupId>
					<artifactId>jmxtools</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jmx</groupId>
					<artifactId>jmxri</artifactId>
				</exclusion>
			</exclusions>
			<scope>runtime</scope>
		</dependency>

		<!-- @Inject -->
		<dependency>
			<groupId>javax.inject</groupId>
			<artifactId>javax.inject</artifactId>
			<version>1</version>
		</dependency>
				
		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
	
		<!-- Test -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.7</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit</artifactId>
			<version>1.1.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-amqp</artifactId>
			<version>1.1.4.RELEASE</version>
		</dependency>
	</dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.9</version>
                <configuration>
                    <additionalProjectnatures>
                        <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
                    </additionalProjectnatures>
                    <additionalBuildcommands>
                        <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
                    </additionalBuildcommands>
                    <downloadSources>true</downloadSources>
                    <downloadJavadocs>true</downloadJavadocs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <compilerArgument>-Xlint:all</compilerArgument>
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <mainClass>org.test.int1.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  14. Our Final Maven Project Structure

    我们最终的Maven项目结构

使用RabbitMQ服务器测试Spring AMQP RabbitMQ示例 (Test Spring AMQP RabbitMQ Example with RabbitMQ Server)

  1. Run AMQP Publisher and observe messages in RabbitMQ Queue

    运行AMQP Publisher并观察RabbitMQ队列中的消息

  2. Here we can see that AMQP Publisher sent 10 messages successfully.

    在这里我们可以看到AMQP Publisher成功发送了10条消息。

  3. RabbitMQ console is showing 10 messages in the queue

    RabbitMQ控制台在队列中显示10条消息

  4. Here we can see that our RabbitMQ queue has received 10 messages successfully from AMQP Publisher.

    在这里，我们可以看到RabbitMQ队列已成功从AMQP Publisher接收到10条消息。

  5. Run AMQP Consumer and observe messages in Eclipse IDE

    运行AMQP Consumer，并在Eclipse IDE中观察消息

  6. Here we can see that AMQP Consumer receives each message one by one from RabbitMQ queue.

    在这里，我们可以看到AMQP消费者从RabbitMQ队列中逐条接收每个消息。

  7. RabbitMQ console is showing 0 messages in the queue

    RabbitMQ控制台在队列中显示0条消息

  8. Here we can observe that RabbitMQ queue has 0 messages that means AMQP Consumer has received all messages successfully.

    在这里我们可以观察到RabbitMQ队列中有0条消息，这意味着AMQP消费者已成功接收了所有消息。

NOTE: With this knowledge of Spring AMQP RabbitMQ Messaging, you can read more about Spring AMQP API and learn new things. And also go through RabbitMQ Server documentation to get more details about Exchanges, Queues etc.

注意：有了Spring AMQP RabbitMQ消息的知识，您可以阅读有关Spring AMQP API的更多信息并学习新知识。 并仔细阅读RabbitMQ Server文档以获取有关Exchange，队列等的更多详细信息。

NOTE: As I told you in my previous post, both Spring AMQP API and RabbitMQ Server are from The Pivotal Team.

注意：正如我在上一篇文章中告诉您的那样，Spring AMQP API和RabbitMQ Server均来自The Pivotal Team 。

That’s it all about developing Spring AMQP RabbitMQ Messaging Example. We will discuss and develop Spring AMQP ActiveMQ Messaging Example in my coming posts.

这就是开发Spring AMQP RabbitMQ消息传递示例的全部内容。 我们将在我的后续文章中讨论和开发Spring AMQP ActiveMQ消息传递示例。

Further Reading: Apache ActiveMQ.

进一步阅读： Apache ActiveMQ 。

翻译自: https://www.journaldev.com/11713/spring-amqp-rabbitmq-example

amqp rabbitmq

cunchi4221
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AmqpTemplate-发送-接收-消息
sn_gis的专栏
11-17 5万+
AmqpTemplate-简介     就像Spring Framework和其它一些项目提供了一些高度抽象，Spring AMQP提供的‘template’扮演者关键的角色。定义者主要操作的接口是AmqpTemplate。这些操作包含了发送和接收消息的一般操作。换种说法，它们不是某个实现所专有的，所以AMQP存在于名称里。这个接口的实现与AMQP协议的实现紧密关联。不像JMS，
Spring Boot 中的 AmqpTemplate 是什么，原理，如何使用
程序员徐师兄的博客
07-01 908
AmqpTemplate 是 Spring AMQP 的核心接口，它提供了一种发送和接收消息的方式，以及一些其他的 AMQP 操作。在 Spring Boot 中使用 AmqpTemplate 非常简单，我们只需要定义一个 Bean，并注入 AmqpTemplate 实例即可。除了发送和接收消息之外，AmqpTemplate 还可以用来声明队列和交换机，以及绑定队列和交换机。在使用 AmqpTemplate 时，我们只需要关注业务逻辑，而不需要关注 AMQP 协议的具体实现。
RabbitMQ系列【16】AmqpTemplate接口详解
记录知识、锤炼自我
11-30 3097
是提供的一个RabbitMQ消息操作模板类，在之前我们使用它完成了简单的消息发送。主要提供了发送消息、接收消息以及其他附加功能，内部封装了RabbitMQ原生API，大大简化了使用RabbitMQ操作。主要实现了和。
个人笔记之rabbitTemplate及amqpTemplate发布模式
热门推荐
weixin_44004647的博客
03-12 3万+
rabbitTemplate及amqpTemplate发布模式 不足之处欢迎留言 1、rabbitTemplate和amqpTemplate有什么关系？ 源码中会发现rabbitTemplate实现自amqpTemplate接口，使用起来并无区别，需引入spring-boot-starter-amqp依赖。 2、组成 生产者 消息队列 消费者 交换机： 隔离生产者和消息队列，充当二者...
SpringAMQP中AmqpTemplate发送接收消息
Keep learing, and stay fast
11-04 2280
Spring AMQP提供了一个扮演核心角色的“模板”，定义操作的接口是AmqpTemplate , 接口操作涵盖了发送和接收消息的一般行为 . 因此他包含了发送和接收消息的所有基本操作. 模板接口的每一个实现都依赖特定的客户端类库， 目前只有RabbitTemplate。
rabbitmq_sample_app:这是带有rabbitmq和swiftmailer的示例应用程序
04-28
#RabbitMQ带有Swift Mailer的示例应用程序这是描述与RabbitMQ和Swift Mailer一起使用的示例应用程序 基础信息 create_incoming_queue.php-这是一个用于在名为“ messages”的MAIN传入队列中创建虚拟条目的文件。 ...
spring rabbitmq amqp
03-16
spring rabbitmq amqp
java rabbitmq spring springAMQP 代码包 project
07-10
java rabbitmq spring springAMQP 代码包 project
RabbitMq与Spring整合实例
01-28
RabbitMq与Spring整合实例，整个工程采用maven,具体过程看博文： http://blog.csdn.net/evankaka/article/details/50495437
rabbitmq 路由spring-amqp实现
08-29
rabbitmq 路由spring-amqp 配置实现
SpringBoot-整合RabbitMQAmqpTemplate
最新发布
Programming Is My Favorite
01-19 353
AMQP并不属于JMS范畴，AMQP和JMS的区别与联系如下：JMS定义了消息中间件的规范，从而实现对消息操作的统一；RabbitMQ与JMS规范的架构区别： JMS规范中的消息生产者和消费者都是直接与消息目的耦合的，消息生产者向消息目的发送消息，消息消费者从消息目的读取消息；而RabbitMQ则增加了Exchange的概念，通过Exchange对消息生产者与消息消费者做了进一步隔离——消息生产者向Exchange发送消息，消息消费者从消息队列读取消息，Exchange则负责将消息分发到各消息队列。
spring amqp AmqpTemplate（4）
xiaoliuliu2050的专栏
07-08 2617
与Spring框架和相关项目提供的许多其他高级抽象一样，Spring AMQP提供了一个“模板”，它扮演着核心角色。定义主要操作的接口称为AmqpTemplate。这些操作涵盖了发送和接收消息的一般行为。换句话说，它们对于任何实现都不是惟一的——因此名称中有“AMQP”。另一方面，该接口的一些实现与AMQP协议的实现绑定在一起。与JMS本身是接口级API不同，AMQP是一个线级协议。该协议的实现提...
SpringBoot：整合RabbitMQ（基本概念，消息模型，AmqpTemplate ）
燕双嘤
09-11 1465
高级消息队列协议（Advanced Message Queuing Protocol，AMQP）是一种与平台无关的、线路级（wire-level）的消息中间件协议。
springboot集成rabbitmq示例，以及RabbitTemplate 和 AmqpTemplate用法区别
festone000的专栏
04-27 2865
问题背景 感觉rabbit的使用非常混乱，有很多的包，乱七八糟，有时候行有时候不行。 而且很多的包名称还完全一样（当然，namesapce不同），导致出现一些奇怪的问题。 经过艰难的尝试，大概终于理清楚了。 就像是rabbitmq是一个开源产品，人人都可以用。 A公司封装了一套， 包名为：com.rabbitmq.client.*** 里面有：RabbitTemplate、com.rabbitmq.client.ConnectionFactory等类。 B公司封装了一套， 包名为：org.springfr
AMQP基本作用
qq_61421352的博客
10-16 634
spring cloud集成rabbitMQ
RabbitMQ第一个实操小案例
越努力越幸运的博客
11-07 562
然后，我们创建两个Module，一个叫publisher（发布者），一个叫consumer（消费者），为了尽可能地干净，我用IDEA，直接创建了两个空白的Maven工程。这里，我又跑去发送了两次，可以看到，我们都可以正常的接收到消息。下面，我们来写一个最简单的实例，首先，创建一个空白的Module作为父工程。里面一共有7个Demo，下面我们就根据他给的Demo进行实操，熟悉一下我们的RabbitMq。前面的两种，是最基本的，只有发布者和订阅者和一个队列，并没有我们的交换机。OK，发送我们会了，那么接收呢？
springamqp整合rabbitmq
feinifi的博客
09-25 1009
springamqp是利用spring核心技术实现访问基于AMQP协议的消息服务器的解决方案，是spring的一个子项目，他并不是一个具体的实现，而是提供了高级接口，具体实现springamqp的项目有spring-rabbit，这里介绍如何整合springamqp、rabbitmq。 构建maven项目，引入spring-rabbit依赖。 &lt;dependency&gt; ...
java amqptemplate_Spring AMQP 1.6完整参考指南-第三部分
weixin_31359991的博客
03-02 752
Queue Affinity 和 LocalizedQueueConnectionFactory当在集群中使用HA队列时,为了获取最佳性能,可以希望连接到主队列所在的物理broker. 虽然CachingConnectionFactory可以配置为使用多个broker 地址; 这会失败的，client会尝试按顺序来连接.LocalizedQueueConnectionFactory使用管理插件提供...
RabbitMQ整合Spring AMQP实战！（全）
java专栏的博客
08-12 8208
前言 1. AMQP 核心组件 RabbitAdmin SpringAMQP声明 RabbitTemplate SimpleMessageListenerContainer MessageListenerAdapter MessageConverter 2. RabbitAdmin RabbitAdmin类可以很好的才注意RabbitMQ,在Spring中直接进行诸如即可。 ...
rabbitmq AMQP_DELIVERY_NONPERSISTENT 是什么
04-28
AMQP_DELIVERY_NONPERSISTENT 是 RabbitMQ 中的一个消息传递模式。在这种模式下，消息会被立即发送给消费者，但不会被持久化到磁盘上，因此如果 RabbitMQ 服务器在发送消息之后崩溃，这些消息将会丢失。这种模式适合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值