RabbitMQ系列教程（十三）Spring AMQP API详解

最新推荐文章于 2023-01-09 01:35:17 发布
最新推荐文章于 2023-01-09 01:35:17 发布
阅读量1.8k 收藏 6
点赞数 2
分类专栏： RabbitMQ系列教程 文章标签： Spring AMQP rabbitTemplate RabbitAdmin
欢迎各位转载，转载请在文章页面中给出作者和原文链接！谢谢您配合
本文链接：https://blog.csdn.net/warybee/article/details/103265699
版权

文章目录

1.Spring AMQP简介

spring-amqp是对AMQP的一些概念的一些抽象，spring-rabbit是对RabbitMQ操作的封装实
现。主要有几个核心类 RabbitAdmin 、 RabbitTemplate 、 SimpleMessageListenerContainer 等。

  • RabbitAdmin 类完成对Exchange，Queue，Binding的操作，在容器中管理了 RabbitAdmin 类的
    时候，可以对Exchange，Queue，Binding进行自动声明。
  • RabbitTemplate 类是发送和接收消息的工具类。
  • SimpleMessageListenerContainer 是消费消息的容器。

2.创建演示项目

使用Spring Boot快速创建一个项目（不使用Spring Boot RabbitMQ特性，后续章节会介绍RabbitMQ整合Spring Boot）。项目POM文件:

    <parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.10.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-amqp</artifactId>
		</dependency>
		<!---为了使用jackson而引入，也可以单独引入jackson-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

添加RabbitMQ配置文件 RabbitMQConfig

@Component
public class RabbitMQConfig {
      @Bean
      public ConnectionFactory connectionFactory(){
          CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
          connectionFactory.setAddresses("127.0.0.1:5672");
          connectionFactory.setUsername("guest");
          connectionFactory.setPassword("guest");
          connectionFactory.setVirtualHost("/");
          return connectionFactory;
      }
      /**
     * RabbitAdmin 注入
     * @param connectionFactory
     * @return
     */
    @Bean
      public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
          RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
          rabbitAdmin.setAutoStartup(true);
          return rabbitAdmin;
      }

    /**
     * RabbitTemplate
     * @param connectionFactory
     * @return
     */
    @Bean
      public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
          RabbitTemplate rabbitTemplate=new RabbitTemplate(connectionFactory);
          return rabbitTemplate;
      }
}

3.RabbitAdmin

AMQP对四种交换机（fanout、topic、direct、headers）类型进行了封装，AMQP封装了 Queue DirectExchange、TopicExchange、FanoutExchange、HeadersExchange ,可以使用RabbitAdmin声明Exchange和Queue，并且进行Binding。
以Direct交换机为例，代码如下：

 @Autowired
 private RabbitAdmin rabbitAdmin;
 
 /**
     * direct 交换机
     */
    @Test
    public void DirectTest(){
        //声明direct交换机
        rabbitAdmin.declareExchange(new DirectExchange("test_direct_spring",true,false));
        //声明队列
        rabbitAdmin.declareQueue(new Queue("test_direct_spring_queue",true,false,false,null));
        //绑定
        rabbitAdmin.declareBinding(new
                Binding("test_direct_spring_queue",
                Binding.DestinationType.QUEUE,
                "test_direct_spring",
                "test.direct",null));
     }

运行代码，在RabbitMQ控制台中可以看到声明的交换机和队列，以及他们之间的绑定关系。

其余交换机类型的声明以及绑定与与上面代码类似，换一下类就可以了，就不贴代码了。如果对RabbitMQ交换机还不了解，可以看下之前的这几篇文章

AMQP还提供了链式编程的方式在绑定的时候声明Exchange和Queue，使用起来比上面分别声明、绑定的代码要简练，以Direct交换机为例，如下代码：

  /**
     * direct 交换机
     */
    @Test
    public void DirectTest(){
        //绑定声明一步到位
        rabbitAdmin.declareBinding(BindingBuilder.bind(
                new Queue("test_direct_spring_queue",
                        true,
                        false,
                        false,
                        null)
        ).to( new DirectExchange("test_direct_spring",true,false))
         .with("test.direct")); // with 后面绑定的是routingKey
    }

4.使用注解的方式声明Exchange、Queue并Binding

在实际项目当中，更多的是使用Spring注解的方式。
如下代码，声明了一个topic交换机，并在交换机上绑定了queue001和queue002两个队列。添加到RabbitMQConfig类中

     @Bean
      public TopicExchange topicExchange001(){
          return new TopicExchange("topicExchange001",true,false);
      }

      @Bean
      public Queue queue001(){
        return new Queue("queue001",true,false,false);
      }

      @Bean
      public Binding binding001(){
          return BindingBuilder.bind(queue001()).to(topicExchange001()).with("spring.#");
      }

      @Bean
      public Queue queue002(){
          return new Queue("queue002",true);
      }

      @Bean
      public Binding binding002(){
          return BindingBuilder.bind(queue002()).to(topicExchange001()).with("springboot.#");
      }

5.RabbitTemplate

RabbitTemplate封装了消息发送的模板以及setConfirmCallback、和setReturnCallback等API。
使用RabbitTemplate发送一个消息：

@Test
    public void sendMsgTest(){
        //创建消息header
        MessageProperties messageProperties=new MessageProperties();
        messageProperties.getHeaders().put("desc","desc heelo");
        messageProperties.getHeaders().put("type","rabbitmq spring topic test");
        //消息类型
        messageProperties.setContentType("text/plain");
        Message message=new Message("spring rabbitmq test".getBytes(),messageProperties);
        //发送消息
        rabbitTemplate.convertSendAndReceive("topicExchange001", "spring.test", message);

       // 当消息不可达时，执行ReturnListener回调
        rabbitTemplate.setMandatory(true);
        Message message2=new Message("hello spring boot message".getBytes(),messageProperties);
        //发送消息
        rabbitTemplate.convertSendAndReceive("topicExchange001","springboot.test",message2);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (!ack){
                    // TODO 消息未被消费，执行一些操作
                }
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                // TODO 当消息不可达时 执行一些操作
            }
        });

    }

RabbitTemplate 类的convertSendAndReceive 提供了很多的重载，可以满足不同情况下的消息发送。

6.SimpleMessageListenerContainer（消息监听）

SimpleMessageListenerContainer 容器是对消费队列的监听，接下我们就使用它来进行队列的监听及消费。

       @Bean
      public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer container=new SimpleMessageListenerContainer(connectionFactory);
        //监听的消息队列，可以设置多个
        container.setQueues(queue001(),queue002());
        //消息签收模式
        container.setAcknowledgeMode(AcknowledgeMode.AUTO);
        container.setConcurrentConsumers(1);//当前消费者数量
        container.setMaxConcurrentConsumers(5);//最大消费者数量
        container.setDefaultRequeueRejected(false);//消息失败，是否重回队列
        //设置消费者的Tag唯一标识，AMQP封装了可以根据Tag进行消息的消费
        container.setConsumerTagStrategy(new ConsumerTagStrategy() {
            @Override
            public String createConsumerTag(String s) {
                return s+"_"+ UUID.randomUUID().toString();
            }
        });
        /**
         * 接收消息
         */
        container.setMessageListener(new ChannelAwareMessageListener(){

            /**
             * 接受消息
             * @param message
             * @param channel
             * @throws Exception
             */
            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                System.out.println("-------------消费者接收消息："+new String(message.getBody()));
            }
        });
      return container;  
  }

7.MessageListenerAdapter（消息监听适配器）

上面使用了setMessageListener 对消息进行简单的监听，AMQP还提供了MessageListenerAdapter 适配器，允许自定义消息委托及消息类型的转化。
接下来自定义一个消息委托，新建一个MessageDelegate 类型，如下：

public class MessageDelegate {
    /**
      * 消息接受的默认方法，可以通过MessageListenerAdapter类的setDefaultListenerMethod修改
      * @param messageBody
      */
     public void handleMessage(Message messageBody){
          System.out.println("接收到的消息："+new String(messageBody.getBody()));
     }
}

  @Bean
      public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer container=new SimpleMessageListenerContainer(connectionFactory);
        //监听的消息队列，可以设置多个
        container.setQueues(queue001(),queue002());
        //消息签收模式
        container.setAcknowledgeMode(AcknowledgeMode.AUTO);
        container.setConcurrentConsumers(1);//当前消费者数量
        container.setMaxConcurrentConsumers(5);//最大消费者数量
        container.setDefaultRequeueRejected(false);//消息失败，是否重回队列
        //设置消费者的Tag唯一标识，AMQP封装了可以根据Tag进行消息的消费
        container.setConsumerTagStrategy(new ConsumerTagStrategy() {
            @Override
            public String createConsumerTag(String s) {
                return s+"_"+ UUID.randomUUID().toString();
            }
        });
         MessageListenerAdapter adapter=new MessageListenerAdapter(new MessageDelegate());
        //adapter.setDefaultListenerMethod("customerMethod"); //可以修改消息委托类中的默认方法
        container.setMessageListener(adapter);
      return container;  
  }

在MessageDelegate 中类我们定义了一个handleMessage的方法，这是消息接受的默认方法，这是MessageListenerAdapter中定义的默认方法public static final String ORIGINAL_DEFAULT_LISTENER_METHOD = "handleMessage"; ,可以通过setDefaultListenerMethod自定义方法。

8、消息类型转化（MessageConverter）

AMQP支持消息自定义消息格式转化，我们只需要实现MessageConverter 接口，就可以把消息转化为我们需要的类型。

8.1. 定义一个把message转化为String的类型

public class TextMessageConvert implements MessageConverter {


    /**
     * Convert a Java object to a Message.
     * @param o
     * @param messageProperties
     * @return
     * @throws MessageConversionException
     */
    @Override
    public Message toMessage(Object o, MessageProperties messageProperties) throws MessageConversionException {
        return new Message(o.toString().getBytes(),messageProperties);
    }

    /**
     * Convert from a Message to a Java object.
     * @param message
     * @return
     * @throws MessageConversionException
     */
    @Override
    public Object fromMessage(Message message) throws MessageConversionException {
        String contentType = message.getMessageProperties().getContentType();
        if (contentType!=null&&contentType.contains("text")){
            return new String(message.getBody());
        }
        return message.getBody();
    }
}

消息监听代码：

 /**
     * 消息监听
     * @param connectionFactory
     * @return
     */
      @Bean
      public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer container=new SimpleMessageListenerContainer(connectionFactory);
        //监听的消息队列，可以设置多个
        container.setQueues(queue001(),queue002());
        //消息签收模式
        container.setAcknowledgeMode(AcknowledgeMode.AUTO);
        container.setConcurrentConsumers(1);//当前消费者数量
        container.setMaxConcurrentConsumers(5);//最大消费者数量
        container.setDefaultRequeueRejected(false);//消息失败，是否重回队列
        //设置消费者的Tag唯一标识，AMQP封装了可以根据Tag进行消息的消费
        container.setConsumerTagStrategy(new ConsumerTagStrategy() {
            @Override
            public String createConsumerTag(String s) {
                return s+"_"+ UUID.randomUUID().toString();
            }
        });
        MessageListenerAdapter adapter=new MessageListenerAdapter(new MessageDelegate());
        //adapter.setDefaultListenerMethod("customerMethod"); //可以修改消息委托类中的默认方法
        adapter.setMessageConverter(new TextMessageConvert());
        container.setMessageListener(adapter); 
        return container;

消息监听委托类，由于使用了 adapter.setMessageConverter(new TextMessageConvert());在handleMessage 方法中可以直接使用String类型接收。

```java
public class MessageDelegate {
    /**
      * 消息接受的默认方法，可以通过MessageListenerAdapter类的setDefaultListenerMethod修改
      * @param messageBody
      */
     public void handleMessage(String messageBody){
          System.out.println("接收到的消息："+messageBody);
     }
}

发送消息的代码与上面的一样。运行代码测试一下吧！！！

8.2 发消息JSON格式的消息，转化为Map

  • 新建一个实体类Order
public class Order{

    private String id;

    private String title;

    private String desc;

    public Order() {
    }

    public Order(String id, String title, String desc) {
        this.id = id;
        this.title = title;
        this.desc = desc;
    }
    ..........省略get set
  }
  • 使用AMQP封装Jackson2JsonMessageConverter 对消息进行转化
 /**
     * 消息监听
     * @param connectionFactory
     * @return
     */
      @Bean
      public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer container=new SimpleMessageListenerContainer(connectionFactory);
        //监听的消息队列，可以设置多个
        container.setQueues(queue001(),queue002());
        //消息签收模式
        container.setAcknowledgeMode(AcknowledgeMode.AUTO);
        container.setConcurrentConsumers(1);//当前消费者数量
        container.setMaxConcurrentConsumers(5);//最大消费者数量
        container.setDefaultRequeueRejected(false);//消息失败，是否重回队列
        //设置消费者的Tag唯一标识，AMQP封装了可以根据Tag进行消息的消费
        container.setConsumerTagStrategy(new ConsumerTagStrategy() {
            @Override
            public String createConsumerTag(String s) {
                return s+"_"+ UUID.randomUUID().toString();
            }
        });
         MessageListenerAdapter adapter=new MessageListenerAdapter(new MessageDelegate());
         // Jackson2JsonMessageConverter消息转化
        Jackson2JsonMessageConverter jackson2JsonMessageConverter=new Jackson2JsonMessageConverter();
        adapter.setMessageConverter(jackson2JsonMessageConverter);
        container.setMessageListener(adapter);
        return container;
  • 消息监听委托类
/**
      * JSON格式的消息 转化为Map
      * @param messageBody
      */
     public void handleMessage(Map messageBody){
          System.out.println("JSON格式的消息 接收到的消息："+messageBody.get("id")+":"+messageBody.get("title")+":"+messageBody.get("desc"));
     }
  • 消息发送
@Test
    public void sendMsgTest2() throws JsonProcessingException {

        Order order=new Order("1","订单title1","订单描述");
        ObjectMapper objectMapper=new ObjectMapper();
        String json = objectMapper.writeValueAsString(order);

        MessageProperties messageProperties=new MessageProperties();
        messageProperties.setContentType("application/json");
        Message message=new Message(json.getBytes(),messageProperties);
        // 当消息不可达时，执行ReturnListener回调
        rabbitTemplate.setMandatory(true);

        //消息的唯一主键，实际生产项目可根据业务逻辑设计
        CorrelationData correlationData=new CorrelationData();
        correlationData.setId(UUID.randomUUID().toString());
        //发送消息
        rabbitTemplate.convertSendAndReceive("topicExchange001", "spring.test", message,correlationData);
    }

8.3 发消息JSON格式的消息，转化为实体对象

  • AMQP提供了默认的 DefaultJackson2JavaTypeMapper 转化类，在上一步的基础上只需要设置Jackson2JsonMessageConverter类的 setJavaTypeMapper(Jackson2JavaTypeMapper javaTypeMapper) 方法。
    PS：在转化之前需要添加实体类，所在包路径，DefaultJackson2JavaTypeMapper默认信任包名只有两个如下：
public class DefaultJackson2JavaTypeMapper extends AbstractJavaTypeMapper
		implements Jackson2JavaTypeMapper, ClassMapper {
    // 可以转化的类型  
	private static final List<String> TRUSTED_PACKAGES =
			Arrays.asList(
					"java.util",
					"java.lang"
			);
  • 消息监听类
--------------------省略一些代码，与上面介绍的代码一致--------------------
 MessageListenerAdapter adapter=new MessageListenerAdapter(new MessageDelegate());
        Jackson2JsonMessageConverter jackson2JsonMessageConverter=new Jackson2JsonMessageConverter();

        DefaultJackson2JavaTypeMapper javaTypeMapper=new DefaultJackson2JavaTypeMapper();
        //添加信任包名称，不然会转化失败
        javaTypeMapper.setTrustedPackages("com.warybee.mqspring.entity");

        jackson2JsonMessageConverter.setJavaTypeMapper(javaTypeMapper);

        adapter.setMessageConverter(jackson2JsonMessageConverter);
        container.setMessageListener(adapter);
  • 消息监听委托类
/**
      * JSON格式的消息 转化为Java实体对象
      * @param order
      */
     public void handleMessage(Order order){
          System.out.println("order 接收到的消息："+order.getId()+"-"+order.getTitle()+"-"+order.getDesc());
     }
  • 发送消息
 /**
     * 发送JSON消息，转化为Java对象
     * @throws JsonProcessingException
     */
    @Test
    public void sendMsgTest3() throws JsonProcessingException {

        Order order=new Order("1","订单title2","订单描述");
        ObjectMapper objectMapper=new ObjectMapper();
        String json = objectMapper.writeValueAsString(order);

        MessageProperties messageProperties=new MessageProperties();
        messageProperties.setContentType("application/json");
        Message message=new Message(json.getBytes(),messageProperties);
        //发送消息
        rabbitTemplate.convertSendAndReceive("topicExchange001", "spring.test", message);

    }

本文示例代码下载：https://gitee.com/warybee/mqspring.git

RabbitMQ系列文章目录

1、RabbitMQ Windows/CentOS7平台安装手册
2、RabbitMQ中一些重要概念
3、RabbitMQ Exchange类型之Direct Exchange
4、RabbitMQ Exchange类型之Topic Exchange
5、RabbitMQ Exchange类型之fanout Exchange
6、RabbitMQ Exchange类型之headers Exchang
7、Confirm消息确认机制
8、RabbitMQ中ReturnListener的使用
9、RabbitMQ消费端限流
10、ACK确认机制与消息补偿
11、RabbitMQ队列/消息的生存时间（Time-To-Live）
12、RabbitMQ死信队列(Dead Letter Exchanges)
13、Spring AMQP API详解
14、Spring Boot整合RabbitMQ

warybee
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMQ 的消息持久化与 Spring AMQP 的实现详解
08-25
主要介绍了RabbitMQ 的消息持久化与 Spring AMQP 的实现剖析详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot整合RabbitMQ图文过程以及RabbitTemplate常用API介绍
最新发布
DaenCode的博客
09-08 329
SpringBoot整合RabbitMQ图文过程以及RabbitTemplate常用API介绍
Rabbit MQ ——API的使用（三）
补
10-19 376
RabbitMq有很多使用方式，里面我将常用的几种方式列出，以便日后回故： 一，原生java API方式 ： maven依赖： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> ...
RabbitMQ系列【16】AmqpTemplate接口详解
记录知识、锤炼自我
11-30 3026
是提供的一个RabbitMQ消息操作模板类，在之前我们使用它完成了简单的消息发送。主要提供了发送消息、接收消息以及其他附加功能，内部封装了RabbitMQ原生API，大大简化了使用RabbitMQ操作。主要实现了和。
RabbitMQ的6种工作模式的学习记录,普通MAVEN和springboot项目整合rabbitmq的API详解
weixin_44012722的博客
09-14 630
RabbitMQ后台管理页面 RabbitMQ6种工作模式介绍 1.RabbitMQ后台管理页面 是rabbitmq的后台管理页面http://localhost:15672 默认的用户 guest 密码 guest 1.1 创建用户 #进入rabbitmq的安装目录下的sbin目录下有提供的命令 rabbitmqctl add_user <用户名> <密码> 1.2 用户等级 用户等级名称 登录控制台 查看所有信息 制定策略 rabbitmq进行管理 admini
【RabbitMQ】学习笔记-p2（SpringAMQP）
小皮皮LL的博客
11-15 1352
视频指路????B站黑马微服务超级推荐！！ SpringAMQP 1.初识SpringAMQP SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。 SpringAmqp的官方地址：https://spring.io/projects/spring-amqp 什么是SpringAMQP？ SpringAMQP提供了三个功能： 自动声明队列、交换机及其绑定关系 基于注解的监听器模式，异步接收消息 封装了RabbitTemplat
spring rabbitmq amqp
03-16
spring rabbitmq amqp
java rabbitmq spring springAMQP 代码包 project
07-10
java rabbitmq spring springAMQP 代码包 project
RabbitMQ系列教程1
08-03
yum list installed | grep dockerdocker run -it --rm --name rabbitmq -p 5672:5672
spring amqp 配置实现rabbitmq 路由
09-02
spring amqp 配置实现rabbitmq 路由
Spring AMQP API(Spring AMQP 开发文档).CHM
08-31
Spring AMQP API(Spring AMQP 开发文档).CHM 官网 Spring AMQP API。Spring AMQP 开发文档。
RabbitMQ 跟 springBoot 整合，相关组件
gpweixing的博客
02-15 1021
RabbitMQ和SpringBoot整合使用的组件列表： RabbitAdmin：      RabbitAdmin 可以用来声明exchange，queue，binding。发送消息等操作 SpringAMQP 声明      通过@Bean注解方式声明交换机和队列。 RabbitTemplate 消息模板      我们在与springAMQP整合的时候进行发送消息的关键类
个人笔记之rabbitTemplate及amqpTemplate发布模式
热门推荐
weixin_44004647的博客
03-12 3万+
rabbitTemplate及amqpTemplate发布模式 不足之处欢迎留言 1、rabbitTemplate和amqpTemplate有什么关系？ 源码中会发现rabbitTemplate实现自amqpTemplate接口，使用起来并无区别，需引入spring-boot-starter-amqp依赖。 2、组成 生产者 消息队列 消费者 交换机： 隔离生产者和消息队列，充当二者...
RabbitMQ——实战篇1（原生API）
zhouhengzhe的博客
02-03 1290
实战篇mu目录RabbitMQ实战1、简单模式 HelloWorld1.1、生成者代码1.2、消费者代码2、工作队列模式 Work Queue2.1、生产者2.2、消费者3、发布订阅模式 Publish/subscribe3.1、生产者3.2、消费者4、路由模式 Routing4.1、生产者4.2、消费者5、通配符模式 Topic5.1、生产者5.2、消费者 RabbitMQ实战 注意：只要是exchange都需要自己在rabbitmq服务端配置，也就是界面上 依赖 <dependencies>
SpringBoot如何整合rabbitMq原生api
石果果的博客
05-16 377
SpringBoot如何整合rabbitMq原生api 文章目录SpringBoot如何整合rabbitMq原生api前言一、springboot启动器spi思想是什么？二、spring装载和管理单例bean的生命周期对理解springboot整合中间件原生api到底有多大地帮助？1.两个核心接口:其一是BeanPostProcess，其二是Smartinitializingsingleton2.时序图总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着springboot启动器自动装配思想的
rabbitMQ- API -Spring
weixin_58678891的博客
09-22 124
1.流量削峰 订单存储的解耦 为了进行流量削峰,我们引入 rabbitmq 消息队列,当购物系统产生订单后,可以把订单数据发送到消息队列;而订单消费者应用从消息队列接收订单消息,并把订单保存到数据库 这样,当流量激增时,大量订单会暂存在rabbitmq中,而订单消费者可以从容地从消息队列慢慢接收订单,向数据库保存 1.0 导入商城项目 1.课前资料\elasticsearch\pd商城.zip 2.pd-web文件夹解压到 rabbitmq 工程目录 3.在 rabbitmq 工程中导入模块 4.使用 s
Rabbitmq之JAVA 原生API基本使用
qq_42058998的博客
01-09 221
Rabbitmq 原生api使用
Rabbitmq的原生javaAPI讲解
qq_40837310的博客
10-12 438
说明 实际生产中一般是使用springboot封装的Template等组件来操作Rabbitmq的，但是如果了解了原生的API的使用，可以更好的理解Rabbitmq的特性和对springboot封装的组件的使用原理有一定了解。 关键的类 ConnectionFactory 从字面上看是连接工厂的意思，实际上该对象就是一个连接工厂对象，主要用于创建一个连接到Rabbitmq服务器的tcp连接。 基本的方法： ConnectionFactory factory = new ConnectionFactory()
【RabbitMQ】原生Api学习之入门篇
菲林都已拆走
12-06 556
【RabbitMQ】 原生代码学习之入门篇1.总体概述 参考文献：《RabbitMQ实战指南》 1.总体概述
rabbitmq教程(安装与使用详解,spring集成)
04-30
RabbitMQ是一个功能强大的消息中间件平台，可以被广泛应用于企业级架构中，为不同的应用程序之间提供高效的消息通信机制。本文将从安装、使用和Spring集成三方面详解RabbitMQ教程。 首先，在安装方面，需要先在官网下载并安装Erlang和RabbitMQ。安装完成后，需要启动RabbitMQ服务器，使用命令行输入“rabbitmq-server start”即可。接下来，就可以在浏览器上访问RabbitMQ控制面板，进行一些必要的配置。 其次，在使用方面，需要了解RabbitMQ中最基础的概念，即消息、队列和交换机。首先，生产者将消息发送到RabbitMQ中的交换机，然后交换机根据路由键将消息分发到对应的队列，最后消费者从队列中获取消息并处理。同时，还需掌握RabbitMQ的一些常用操作，如创建、发送、接收和删除消息等。 最后，在集成Spring方面，可以使用Spring AMQP框架来方便地集成RabbitMQ。具体而言，首先需要在pom.xml文件中导入spring-boot-starter-amqp依赖，并在application.yml中配置RabbitMQ相关信息。然后，在代码中使用RabbitTemplate来发送和接收消息，使用@RabbitListener注解来声明一个消息监听器方法。此外，还需掌握Spring AMQP的其他一些特性，如消息确认机制、声明式事务、消息转换和死信队列等。 总之，RabbitMQ教程不仅需要掌握其基础概念和操作方法，还需要了解其在企业级架构中的应用和与Spring整合的技巧。只有掌握了这些关键点，才能更好地利用RabbitMQ提高应用程序之间的通信效率和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

warybee

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

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

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

打赏作者

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

抵扣说明：

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

余额充值