Springboot集成RabbitMQ

最新推荐文章于 2024-06-26 09:09:54 发布
最新推荐文章于 2024-06-26 09:09:54 发布
阅读量256 收藏 1
点赞数
分类专栏： MQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012965203/article/details/106753010
版权

一、简单使用

1、创建eureka注册中心

（1）创建项目模块

（2）pom文件

        <!--eureka-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!--Eureka添加用户认证-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!--热部署依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

（3）文件application.yml配置

server:
    port: 8000

###服务名称
spring:
    application:
        name: eureka-center
    security:
        basic:
            enable: true #开启基于HTTP basic的认证
        user: #配置用户的账号信息
            name: zzq
            password: 123456

eureka:
    instance:
        hostname: localhost
    client:
        register-with-eureka: false #指定当前主机是否注册eureka server
        fetch-registry: false #指定当前主机是否从eureka server下载注册表
        service-url:
            #暴露eureka server服务地址
            defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:${server.port}/eureka

（4）eureka登录验证

package com.zzq.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    /**
     * 高版本springcloud的丢弃了配置:
     * security:
     *   basic:
     *    enabled: true
     * 所以应该使用以下方式开
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // Configure HttpSecurity as needed (e.g. enable http basic).
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.NEVER);
        http.csrf().disable();
        //注意：为了可以使用 http://${user}:${password}@${host}:${port}/eureka/ 这种方式登录,所以必须是httpBasic,
        // 如果是form方式,不能使用url格式登录
        http.authorizeRequests().anyRequest().authenticated().and().httpBasic();
    }
}

（5）开启eureka

package com.zzq;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer //开启rureka服务
@SpringBootApplication
public class EurekaServerApplication {

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

}

（6）启动效果

2、创建mq模块

（1）创建项目模块

（2）配置pom文件，主要是添加spring-boot-starter-amqp的支持

<!--eureka-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--rabbitmq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>1.5.2.RELEASE</version>
        </dependency>

（3）配置application.yml文件，文件配置rabbitmq的安装地址、端口以及账户信息

server:
  port: 8081

spring:
  application:
    name: 00-provider-8081  # 暴露微服务名称
  #链接eureka用户验证
  security:
    basic:
      enable: true #开启基于HTTP basic的认证
    user: #配置用户的账号信息
      name: zzq
      password: 123456

  rabbitmq:
    host: 112.74.216.57
    port: 5672
    username: admin
    password: admin

# 指定Eureka服务中心
eureka:
  client:
    service-url:
      defaultZone: http://zzq:123456@127.0.0.1:8000/eureka
      #defaultZone: http://eureka8100.com:8100/eureka,http://eureka8200.com:8200/eureka,http://eureka8300.com:8300/eureka
  # 指定当前客户端主机在注册中心的名称
  instance:
    instance-id: 00-provider-8081

（4）创建生成者

package com.zzq.rabbitMq;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * 生成者
 */
@Component
public class Producer {

    @Autowired
    private AmqpTemplate rabbitmqTemplate;

    public void send(String content) {
        this.rabbitmqTemplate.convertAndSend("q_hello", content);
    }

}

（5）创建消费者

package com.zzq.rabbitMq;

import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "q_hello")
public class Consumer {

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

（6）队列配置

package com.zzq.rabbitMq;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {
    @Bean
    public Queue helloQueue(){
        return new Queue("q_hello");
    }
}

（7）启动类

package com.zzq;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
public class ProviderApplication {

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

}

（8）RabbitMqController

package com.zzq.rabbitMq;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RabbitMqController {
    @Autowired
    Producer producer;
    @RequestMapping("/mq")
    public void doSome() {
        producer.send("你好");
    }
}

（9）效果

http://localhost:8081/mq

二、主题模式

（1）生产者

package com.zzq.topic;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 生成者
 */
@Component
public class TopicProducer {

    @Autowired
    private AmqpTemplate rabbitmqTemplate;

    public void send1() {
        String context = "hi, i am message 1";
        System.out.println("Producer : " + context);
        this.rabbitmqTemplate.convertAndSend("myexchange", "topic.message", context);
    }


    public void send2() {
        String context = "hi, i am messages 2";
        System.out.println("Producer : " + context);
        this.rabbitmqTemplate.convertAndSend("myexchange", "topic.messages", context);
    }



}

（2）消费者

package com.zzq.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "q_fanout_A")
public class ComsumerA {

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

package com.zzq.topic;


import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "q_topic_messages")
public class Consumer2 {
    @RabbitHandler
    public void process(String hello) {
        System.out.println("Consumer2  : " + hello);
    }
}

（3）交换机绑定

package com.zzq.topic;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TopicRabbitConfig {

    final static String message = "q_topic_message";
    final static String messages = "q_topic_messages";

    @Bean
    public Queue queueMessage() {
        return new Queue(TopicRabbitConfig.message);
    }

    @Bean
    public Queue queueMessages() {
        return new Queue(TopicRabbitConfig.messages);
    }

    /**
     * 声明一个Topic类型的交换机
     * @return
     */
    @Bean
    TopicExchange exchange() {
        return new TopicExchange("myexchange");
    }

    /**
     * 绑定Q到交换机,并且指定routingKey
     * @param queueMessage
     * @param exchange
     * @return
     */
    @Bean
    Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) {
        return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
    }

    /**
     * #匹配一个或者多个词,*匹配一个词
     * @param queueMessages
     * @param exchange
     * @return
     */
    @Bean
    Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) {
        return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");
    }
}

（4）测试

package com.zzq.topic;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RabbitTopicMqController {
    @Autowired
    TopicProducer producer;

    @RequestMapping("/mq/topic/send1")
    public void send1() {
        producer.send1();
    }
    @RequestMapping("/mq/topic/send2")
    public void send2() {
        producer.send2();
    }
}

（5）效果

三、Fanout Exchange（订阅模式）

Fanout 就是我们熟悉的广播模式或者订阅模式，给Fanout交换机发送消息，绑定了这个交换机的所有队列都收到这个消息

（1）配置队列,绑定交换机

package com.zzq.fanout;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutRabbitConfig {

    @Bean
    public Queue aMessage() {
        return new Queue("q_fanout_A");
    }

    @Bean
    public Queue bMessage() {
        return new Queue("q_fanout_B");
    }

    @Bean
    public Queue cMessage() {
        return new Queue("q_fanout_C");
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("myfanoutExchange");
    }

    @Bean
    Binding bindingExchangeA(Queue aMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(aMessage).to(fanoutExchange);
    }

    @Bean
    Binding bindingExchangeB(Queue bMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(bMessage).to(fanoutExchange);
    }

    @Bean
    Binding bindingExchangeC(Queue cMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(cMessage).to(fanoutExchange);
    }
}

（2）生产者

package com.zzq.fanout;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class FanoutProducer {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send() {
        String context = "hi, fanout msg ";
        System.out.println("Sender : " + context);
        this.rabbitTemplate.convertAndSend("myfanoutExchange","", context);
    }
}

（3）消费者

创建3个消费者

package com.zzq.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "q_fanout_A")
public class ComsumerA {

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

 

package com.zzq.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "q_fanout_B")
public class ComsumerB {

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

package com.zzq.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "q_fanout_C")
public class ComsumerC {

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

（4）测试

package com.zzq.fanout;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FanoutController {
    @Autowired
    private FanoutProducer producer;

    @RequestMapping("/mq/fanout")
    public void send1() throws Exception {
        producer.send();
    }
}

结果如下，三个消费者都收到消息：

q_fanout_A  : hi, fanout msg /n
q_fanout_B  : hi, fanout msg /n
q_fanout_C  : hi, fanout msg /n

推荐学习 ：https://blog.csdn.net/hellozpc/article/details/81436980

2014Team
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解Spring Boot 配置多个RabbitMQ
08-30
本篇文章主要介绍了Spring Boot 配置多个RabbitMQ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot使用rabbitmq的简单教程
loveliukaiji的博客
03-27 340
在springboot中使用rabbitmq
【RabbitMQ实战】Springboot 整合RabbitMQ组件，多种编码示例，带你实践 看完这一篇就够了
最新发布
qq_39666711的博客
06-26 771
该篇文章内容较多，包括有RabbitMQ一些理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout多种交换机的使用，同时简单介绍对消息回调、手动确认等。例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。这里面的每一种使用都包含实际编码示例，供大家理解，共同进步，如有不足。还请指教。
微服务: 04-springboot中rabbitmq的yml或properties配置,消息回收,序列化方式
pingzhuyan的博客
07-18 2577
rabbitmq的连接配置, 以及回收机制配置, 修改默认java序列化方式#beta版 rabbitmq V3.0.1 版本启动测试 pzy===============================================>#基础配置#发送确认机制设置#发布消息成功到交换器后会触发回调方法(默认禁用none)#消息发布不可达目的地的时候 才进行回退# 队列设置#设置每次预抓取的数量是3,处理完之前不收下一条 默认250# 手动确认模式# 开启rabbit初始化重试机制。
Springboot 整合RabbitMq ，用心看完这一篇就够了
热门推荐
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
SpringBoot整合RabbitMQ（基础）
asasasasasawqwqwqw的博客
06-15 3731
x显而易见：与发布订阅模式不同的是，此模式需要将交换机与队列通过routingKey绑定，并且生产者可以通过指定routingKey,可以将消息发送到指定队列中。可以看到：与路由模式不同的是topic支持通配符模式的路由key；特别的是"*“只能代替一个单词；可以看到两个消费之都接收了生产者所有的消息；与工作队列不同的是，工作队列的消费者只消费部分消息，而此模式是消费所有。可以看到两个消费者都成功消费量word队列中的消息。可以看到对应队列中产生了消息。③创建消费者（多个）③创建消费者（多个）
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
SpringBoot集成RabbitMQ的方法(死信队列) SpringBoot集成RabbitMQ的方法是指使用SpringBoot框架集成RabbitMQ消息队列的方法，RabbitMQ是一种基于AMQP协议的开源消息队列软件。该方法可以实现消息的异步处理，提高...
rabbitmq基础+springboot集成rabbitmq
10-14
**SpringBoot集成RabbitMQ** Spring Boot提供了方便的RabbitMQ支持，简化了配置和操作。集成RabbitMQ需要以下步骤： 1. 添加依赖：在`pom.xml`中引入`spring-boot-starter-amqp`依赖。 2. 配置：在`application....
SpringBoot集成Rabbitmq简单案例
03-15
在压缩包`springBoot+rabbitmq`中，可能包含了上述代码的示例项目，你可以下载并运行它，以便更好地理解和实践这个简单的Spring Boot与RabbitMQ集成案例。通过这种方式，你可以快速上手并掌握Spring Boot中RabbitMQ...
springboot集成rabbitMQ
01-19
Springboot整合rabbitMQ 一、准备环节 确保rabbitmq服务运行正常，安装请查找rabbitmq安装教程 确保springboot运行正常，so easy 不多介绍 二、集成rabbitMQ
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4566
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
springboot整合rabbitMQ
同一片天空
04-25 324
springboot整合rabbitMQ引入依赖创建子工程相应的生产者和消费的配置每一个模块都需要新建一个主启动类生产者消费者01消费者02 springboot引入了相关的依赖后，提供一个工具类RabbitTemplate.发送功能使用这个工具类可以发送消息。 引入依赖 引入rabbitMQ的依赖，web启动项，template rabbitMQ的依赖: 启动类加载。读取配置文件： springboot自动装配原理: 引用starter启动依赖时，把对应的自动装配类加载进去，该自动装配类可以读取appli
Springboot 整合 RabbitMQ高级特性 & 真实业务应用
qq_51033936的博客
11-01 1500
🐇🐇前言:我们的RabbitMQ经常被用来做⚡秒杀类业务⚡,所以在商城类项目中充当着一个很重要的中间件,关于它的高级特性和企业级项目中的一些重点问题的解决方案在这里我会进行详细的总结, 并在最后展示一部分。
SpringBoot整合实现RabbitMQ
weixin_39956506的博客
01-30 4660
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。创建2个springboot项目，一个 mq-rabbitmq-producer（生产者），一个mq-rabbitmq-consumer（消费者）。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。
rabbitmq-spring-boot-start配置使用手册
qq_34905631的博客
03-13 1538
rabbitmq-spring-boot-start配置使用手册。
RabbitMq 快速与springboot整合
ringBey的博客
07-29 349
Rabbitmq与springboot快速整合
2020-11-10
qq_51986815的博客
11-10 196
2020-11-10 发布 大数据生态系统 Hadoop是一个用Java写好的软件，只要计算机安装好了jdk就可以部署Hadoop. 在这里插入图片描述HDFS，是Hadoop Distributed File System的简称，是Hadoop抽象文件系统的一种实现。Hadoop抽象文件系统可以与本地系统、Amazon S3等集成，甚至可以通过Web协议（webhsfs）来操作。HDFS的文件分布在集群机器上，同时提供副本进行容错及可靠性保证。例如客户端写入读取文件的直接操作都是分布在集群各个机器上的，没
Springboot整合RabbitMQ
weixin_49076273的博客
06-02 1万+
一、Springboot整合RabbitMQ的代码实现 1.引入Springboot整合RabbitMQ的依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> &l
SpringBoot 集成rabbitmq
07-28
SpringBoot集成RabbitMQ可以通过以下步骤实现。首先，在配置文件中添加RabbitMQ的连接信息。例如，在application.yml文件中配置RabbitMQ的主机、端口、用户名和密码等信息。\[1\]然后，引入SpringBoot整合RabbitMQ的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2014Team

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值