GVKun编程网logo

如何让Spring RabbitMQ创建一个新的队列？（rabbitmq添加队列）

8

此处将为大家介绍关于如何让SpringRabbitMQ创建一个新的队列？的详细内容，并且为您解答有关rabbitmq添加队列的相关问题，此外，我们还将为您介绍关于RabbitMQ(三)SpringBo

此处将为大家介绍关于如何让Spring RabbitMQ创建一个新的队列？的详细内容，并且为您解答有关rabbitmq添加队列的相关问题，此外，我们还将为您介绍关于RabbitMQ (三) SpringBoot2.x 集成 RabbitMQ、rabbitmq 中有没有类似 redis 中 set 类型的队列？、RabbitMQ 入门 与 RabbitMQ 在 Spring Boot 中的使用、RabbitMQ 入门：在 Spring Boot 应用中整合 RabbitMQ的有用信息。

本文目录一览：

如何让Spring RabbitMQ创建一个新的队列？（rabbitmq添加队列）

如何让Spring RabbitMQ创建一个新的队列？（rabbitmq添加队列）

根据我对Rabbit-mq的（有限的）经验，如果您为尚不存在的队列创建新的侦听器，则会自动创建该队列。我试图将Spring AMQP项目与rabbit-
mq一起使用来设置侦听器，但是却出现错误。这是我的xml配置：

<rabbit:connection-factory id="rabbitConnectionFactory" host="172.16.45.1" username="test" password="password" /><rabbit:listener-container connection-factory="rabbitConnectionFactory"  >    <rabbit:listener ref="testQueueListener" queue-names="test" /></rabbit:listener-container><bean id="testQueueListener"> </bean>

我在RabbitMq日志中得到了这个：

=ERROR REPORT==== 3-May-2013::23:17:24 ===connection <0.1652.0>, channel 1 - soft error:{amqp_error,not_found,"no queue ''test'' in vhost ''/''",''queue.declare''}

还有来自AMQP的类似错误：

2013-05-03 23:17:24,059 ERROR [org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer] (SimpleAsyncTaskExecutor-1) - Consumer received fatal exception on startuporg.springframework.amqp.rabbit.listener.FatalListenerStartupException: Cannot prepare queue for listener. Either the queue doesn''t exist or the broker will not allow us to use it.

从堆栈跟踪中可以看出，队列是在“被动”模式下创建的-任何人都可以指出我如何不使用被动模式来创建队列，这样我就不会看到此错误？还是我想念其他东西？

答案1

小编典典

解决我问题的方法似乎是添加一个管理员。这是我的xml：

<rabbit:listener-container connection-factory="rabbitConnectionFactory"  >    <rabbit:listener ref="orderQueueListener" queues="test.order" /></rabbit:listener-container><rabbit:queue name="test.order"></rabbit:queue><rabbit:admin id="amqpAdmin" connection-factory="rabbitConnectionFactory"/><bean id="orderQueueListener">   </bean>

RabbitMQ (三) SpringBoot2.x 集成 RabbitMQ

RabbitMQ (三) SpringBoot2.x 集成 RabbitMQ

3-1 RabbitMQ 整合 SpringBoot2.x 生产者发送消息

创建 SpringBoot 项目
application.properties 配置

spring.rabbitmq.host=192.168.152.128
spring.rabbitmq.port=5672
spring.rabbitmq.username=root
spring.rabbitmq.password=root

创建 SendService.java

 

SpringBoot 主运行类

3-2 RabbitMQ 整合 SpringBoot2.x 消费者接受消息

创建 SpringBoot 项目
application.properties 配置和上面项目一样 导入 rabbitmq 依赖

创建 ReveiveService.java

 

 SpringBoot 主运行类

 

3-3 使用 JSON 传递消息

发送和接收的 SpringBoot 工程添加 fastjson 依赖

 

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.36</version>
</dependency>

 


发送和接收的 SpringBoot 工程添加 User 实体类

 

 修改 SendService.java

 

 

修改 ReceiveService.java

 

 

 

3-4 使用监听器接收消息 (否则 ReceiveService 无法实时接收消息)
接收消息的 SpringBoot 工程添加 RabbitMQListener.java

@Component("rabbitMQListener")
public class RabbitMQListener {
    //指定当前方法是RabbitMQ的一个监听器的方法，用于监听某些队列，如果队列中拥有新的消息则直接进行消息的接收
    @RabbitListener(queues = {"myQueue"})//参数 queues 是一个数组的参数，用于指定被监听的消息队列名称
    public void listenerReceive(Message message){//自定义的接收消息的方法，参数是一个Message对象，这个对象就是我们的消息数据
        try {
            //使用消息对象调用getBody方法获取具体的消息数据，并转换成对应的json字符串
            String jsonData=new String(message.getBody(),"UTF-8");
            //使用FastJSON将json字符串转换成对象
            User user= JSONObject.parseObject(jsonData,User.class);
            System.out.println(user.getId()+"    "+user.getName());

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}


修改消息接收的主运行类

 

rabbitmq 中有没有类似 redis 中 set 类型的队列？

rabbitmq 中有没有类似 redis 中 set 类型的队列？

如果没有，该如何确保队列中数据是不重复的呢呢

RabbitMQ 入门 与 RabbitMQ 在 Spring Boot 中的使用

RabbitMQ 入门 与 RabbitMQ 在 Spring Boot 中的使用

##Message Broker 与 AMQP 简介

Message Broker 是一种消息验证、传输、路由的架构模式，其设计目标主要应用于下面这些场景：

  • 消息路由到一个或多个目的地

  • 消息转化为其他的表现方式

  • 执行消息的聚集、消息的分解，并将结果发送到他们的目的地，然后重新组合相应返回给消息用户

  • 调用 Web 服务来检索数据

  • 响应事件或错误

  • 使用发布 - 订阅模式来提供内容或基于主题的消息路由

  • AMQP 是 Advanced Message Queuing Protocol 的简称，它是一个面向消息中间件的开放式标准应用层协议。AMQP 定义了这些特性：

  • 消息方向

  • 消息队列

  • 消息路由（包括：点到点和发布 - 订阅模式）

  • 可靠性

  • 安全性 ##RabbitMQ

本文要介绍的 RabbitMQ 就是以 AMQP 协议实现的一种中间件产品，它可以支持多种操作系统，多种编程语言，几乎可以覆盖所有主流的企业级技术平台。

## 安装

在 RabbitMQ 官网的下载页面 https://www.rabbitmq.com/download.html 中，我们可以获取到针对各种不同操作系统的安装包和说明文档。这里，我们将对几个常用的平台一一说明。

下面我们采用的 Erlang 和 RabbitMQ Server 版本说明：

Erlang/OTP 19.1 RabbitMQ Server 3.6.5 ##Windows 安装

1、安装 Erland，通过官方下载页面 http://www.erlang.org/downloads 获取 exe 安装包，直接打开并完成安装。 2、安装 RabbitMQ，通过官方下载页面 https://www.rabbitmq.com/download.html 获取 exe 安装包。 3、下载完成后，直接运行安装程序。 4、RabbitMQ Server 安装完成之后，会自动的注册为服务，并以默认配置启动起来。 这里写图片描述

##Mac OS X 安装

在 Mac OS X 中使用 brew 工具，可以很容易的安装 RabbitMQ 的服务端，只需要按如下命令操作即可：

1、brew 更新到最新版本，执行：brew update 2、安装 Erlang，执行：brew install erlang 3、安装 RabbitMQ Server，执行：brew install rabbitmq 4、通过上面的命令，RabbitMQ Server 的命令会被安装到 /usr/local/sbin，并不会自动加到用户的环境变量中去，所以我们需要在.bash_profile 或.profile 文件中增加下面内容：

PATH=$PATH:/usr/local/sbin 这样，我们就可以通过 rabbitmq-server 命令来启动 RabbitMQ 的服务端了。

##Ubuntu 安装

在 Ubuntu 中，我们可以使用 APT 仓库来进行安装

1、安装 Erlang，执行：apt-get install erlang

echo ''deb http://www.rabbitmq.com/debian/ testing main''
sudo tee /etc/apt/sources.list.d/rabbitmq.list

3、更新 APT 仓库的 package list，执行 sudo apt-get update 命令

4、安装 Rabbit Server，执行 sudo apt-get install rabbitmq-server 命令 ##Rabbit 管理

我们可以直接通过配置文件的访问进行管理，也可以通过 Web 的访问进行管理。下面我们将介绍如何通过 Web 进行管理。

  • 执行 rabbitmq-plugins enable rabbitmq_management 命令，开启 Web 管理插件，这样我们就可以通过浏览器来进行管理了。
 -> rabbitmq-plugins enable rabbitmq_management
The following plugins have been enabled:
  mochiweb
  webmachine
  rabbitmq_web_dispatch
  amqp_client
  rabbitmq_management_agent
  rabbitmq_management
Applying plugin configuration to rabbit@PC-201602152056... started 6 plugins.
  • 打开浏览器并访问：http://localhost:15672/，并使用默认用户 guest 登录，密码也为 guest。我们可以看到如下图的管理页面： 这里写图片描述

从图中，我们可以看到之前章节中提到的一些基本概念，比如：Connections、Channels、Exchanges、Queue 等。第一次使用的读者，可以都点开看看都有些什么内容，熟悉一下 RabbitMQ Server 的服务端。

  • 点击 Admin 标签，在这里可以进行用户的管理。 ##Spring Boot 整合

下面，我们通过在 Spring Boot 应用中整合 RabbitMQ，并实现一个简单的发送、接收消息的例子来对 RabbitMQ 有一个直观的感受和理解。

在 Spring Boot 中整合 RabbitMQ 是一件非常容易的事，因为之前我们已经介绍过 Starter POMs，其中的 AMQP 模块就可以很好的支持 RabbitMQ，下面我们就来详细说说整合过程：

  • 新建一个 Spring Boot 工程，命名为：“rabbitmq-hello”。
  • 在 pom.xml 中引入如下依赖内容，其中 spring-boot-starter-amqp 用于支持 RabbitMQ。
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.3.7.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
  • 在 application.properties 中配置关于 RabbitMQ 的连接和用户信息，用户可以回到上面的安装内容，在管理页面中创建用户。
spring.application.name=rabbitmq-hello

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=spring
spring.rabbitmq.password=123456
  • 创建消息生产者 Sender。通过注入 AmqpTemplate 接口的实例来实现消息的发送，AmqpTemplate 接口定义了一套针对 AMQP 协议的基础操作。在 Spring Boot 中会根据配置来注入其具体实现。在该生产者，我们会产生一个字符串，并发送到名为 hello 的队列中。
@Component
public class Sender {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send() {
        String context = "hello " + new Date();
        System.out.println("Sender : " + context);
        this.rabbitTemplate.convertAndSend("hello", context);
    }

}
  • 创建消息消费者 Receiver。通过 @RabbitListener 注解定义该类对 hello 队列的监听，并用 @RabbitHandler 注解来指定对消息的处理方法。所以，该消费者实现了对 hello 队列的消费，消费操作为输出消息的字符串内容。
@Component
@RabbitListener(queues = "hello")
public class Receiver {

    @RabbitHandler
    public void process(String hello) {
        System.out.println("Receiver : " + hello);
    }

}
  • 创建 RabbitMQ 的配置类 RabbitConfig，用来配置队列、交换器、路由等高级信息。这里我们以入门为主，先以最小化的配置来定义，以完成一个基本的生产和消费过程。
@Configuration
public class RabbitConfig {

    @Bean
    public Queue helloQueue() {
        return new Queue("hello");
    }

}
  • 创建应用主类：
@SpringBootApplication
public class HelloApplication {

    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class, args);
    }

}
  • 创建单元测试类，用来调用消息生产：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = HelloApplication.class)
public class HelloApplicationTests {

    @Autowired
    private Sender sender;

    @Test
    public void hello() throws Exception {
        sender.send();
    }

}

  • 完成程序编写之后，下面开始尝试运行。首先确保 RabbitMQ Server 已经开始，然后进行下面的操作：

  • 启动应用主类，从控制台中，我们看到如下内容，程序创建了一个访问 127.0.0.1:5672 中 springcloud 的连接。

o.s.a.r.c.CachingConnectionFactory       : Created new connection: SimpleConnection@29836d32 [delegate=amqp://springcloud@127.0.0.1:5672/]

  • 同时，我们通过 RabbitMQ 的控制面板，可以看到 Connection 和 Channels 中包含当前连接的条目。

  • 运行单元测试类，我们可以看到控制台中输出下面的内容，消息被发送到了 RabbitMQ Server 的 hello 队列中。

Sender : hello Sun Sep 25 11:06:11 CST 2016
  • 切换到应用主类的控制台，我们可以看到类似如下输出，消费者对 hello 队列的监听程序执行了，并输出了接受到的消息信息。
Receiver : hello Sun Sep 25 11:06:11 CST 2016
  • 通过上面的示例，我们在 Spring Boot 应用中引入 spring-boot-starter-amqp 模块，进行简单配置就完成了对 RabbitMQ 的消息生产和消费的开发内容。然而在实际应用中，我们还有很多内容没有演示，这里不做更多的讲解，读者可以自行查阅 RabbitMQ 的官方教程，有更全面的了解。

完整示例：Chapter5-2-1

开源中国：http://git.oschina.net/didispace/SpringBoot-Learning/tree/master/Chapter5-2-1 GitHub：https://github.com/dyc87112/SpringBoot-Learning/tree/master/Chapter5-2-1

RabbitMQ 入门：在 Spring Boot 应用中整合 RabbitMQ

RabbitMQ 入门：在 Spring Boot 应用中整合 RabbitMQ

在上一篇随笔中我们认识并安装了 RabbitMQ，接下来我们来看下怎么在 Spring Boot 应用中整合 RabbitMQ。

先给出最终目录结构：

 

搭建步骤如下：

  1. 新建 maven 工程 amqp
  2. 修改 pom 文件，引入 spring-boot-starter-amqp 和 spring-boot-starter-test 
    <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.sam</groupId>
    <artifactId>amqp</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>

    <properties>
        <javaVersion>1.8</javaVersion>
    </properties>
    <dependencies>
        <!-- 引入amqp依赖，它能很好的支持RabbitMQ -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!-- 引入test依赖，这次需要用到JUnit -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>
  3. 新建 application.properties 配置文件，主要就是配置下连接 RabbitMQ 的信息： 
    spring.application.name=rabbitmq-hello
#config rabbitmq info
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
  4. 新建启动类，这里没什么特殊的，就是普通的 spring boot 启动类 
    /**
 * 这里没什么特殊的地方，就是普通的spring boot 配置
 *
 */
@SpringBootApplication
public class RabbitMQApp {

    public static void main(String[] args) {
        SpringApplication.run(RabbitMQApp.class, args);
    }
}
  5. 创建生产者类，通过 AmqpTemplate 实现消息的发送，AmqpTemplate 接口定义了一套针对 AMQP 协议的基础操作。在 Spring Boot 中会根据配置来注入具体的实现。这里我们会产生一个字符串，并发送到名为 hello 的队列中。 
    @Component
public class Sender {

    @Autowired
    AmqpTemplate rabbitmqTemplate;

    /**
     * 发送消息
     */
    public void send() {
        String content = "Sender says:" + "''hello， I''m sender''";
        System.out.println(content);
        rabbitmqTemplate.convertAndSend("hello", content);
    }
}
  6. 创建消费者类，需要用到 @RabbitListener 来定义对 hello 队列的监听，并用 @RabbitHandler 注解来指定对消息处理的方法。我们这里实现了对 hello 队列的消费。 
    /**
 * 通过@RabbitListener对hello队列进行监听
 *
 */
@Component
@RabbitListener(queues="hello")
public class Receiver {

    /**
     * 通过@RabbitHandler声明的方法，对hello队列中的消息进行处理
     */
    @RabbitHandler
    public void receiver(String str) {
        System.out.println("Receiver says:[" + str + "]");
    }
}
  7. 编写 RabbitMQ 的配置类，配置类可以配置队列、交换器、路由等高级信息。我们这里为了简单，只配置队列，其他的采用默认配置。 
    /**
 * rabbitmq配置类，
 * 为了简单，我们这里只配置了Queue
 * 至于exchanges、brokers等用的默认配置
 *
 */
@Configuration
public class RabbitConfig {

    @Bean
    public Queue helloQueue() {
        return new Queue("hello");
    }
    
    
}
  8. 编写测试类，用来调用消息生产者 
    @RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes=RabbitMQApp.class)
public class HelloTest {

    @Autowired
    private Sender sender;

    /**
     * 调用生产者进行消息发送
     */
    @Test
    public void hello() throws Exception{
        sender.send();
    }
}
  9. 运行启动类，启动后控制台会有下面的提示内容：

     

  10. 执行测试类，在测试类的控制台会打印我们打的 log 内容

　　

　　

　　切换到 amqp 应用的控制台，能看到打印：

　　

　　

　　在管理页面中我们能看到 Connections 和 Channels 中包含了当前连接的条目：

 

 在整个生产和消费的过程中，生产和消费是一个异步操作，这是分布式系统中要使用消息代理的重要原因。

关于如何让Spring RabbitMQ创建一个新的队列？和rabbitmq添加队列的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于RabbitMQ (三) SpringBoot2.x 集成 RabbitMQ、rabbitmq 中有没有类似 redis 中 set 类型的队列？、RabbitMQ 入门 与 RabbitMQ 在 Spring Boot 中的使用、RabbitMQ 入门：在 Spring Boot 应用中整合 RabbitMQ的相关知识，请在本站寻找。

本文标签：

上一篇Java：将科学计数法转换为常规int（java怎么把科学计数法转换成数字）

下一篇检查附加的事件处理程序是否有任何DOM元素（检查附加内容中）

相关文章