RabbitMQ使用RabbitListen监听消息获取队列的消息------RabbitMQ

最新推荐文章于 2024-09-29 14:45:20 发布
最新推荐文章于 2024-09-29 14:45:20 发布
阅读量504 收藏 12
点赞数 25
分类专栏： # RabbitMQ 消息中间件 # Spring-Boot框架 文章标签： spring cloud spring boot 后端 分布式 微服务 rabbitmq java-rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75960169/article/details/142634481
版权 
package com.alatus.mall.cart.web;

import com.alatus.mall.cart.service.CartService;
import com.alatus.mall.cart.vo.Cart;
import com.alatus.mall.cart.vo.CartItem;
import com.alatus.mall.cart.vo.UserInfoTo;
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import java.util.concurrent.ExecutionException;

@Controller
public class CartController {
    @Autowired
    private CartService cartService;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private AmqpAdmin amqpAdmin;
    @GetMapping("/sendMessage")
    public void sendMessage(){
        UserInfoTo userInfoTo = new UserInfoTo(1L,"2323");
        rabbitTemplate.convertAndSend("helloWorld","hello",userInfoTo);
    }
    @GetMapping("/cart.html")
    public String cartListPage(Model model) throws ExecutionException, InterruptedException {
        Cart cart = cartService.getCart();
        model.addAttribute("cart",cart);
        return "cartList";
    }
    @GetMapping("/deleteItem")
    public String deleteItem(@RequestParam("skuId")Long skuId){
        cartService.deleteItem(skuId);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/createExchange")
    public void createExchange() throws InterruptedException {
//        声明交换机
        DirectExchange directExchange = new DirectExchange("helloWorld",true,false);
        amqpAdmin.declareExchange(directExchange);
//        队列不能有排他性,要都能连接到这个队列才是正确的
        Queue helloJava = new Queue("helloJava", true, false,false);
        amqpAdmin.declareQueue(helloJava);
        Thread.sleep(2000);
        Binding binding = new Binding("helloJava", Binding.DestinationType.QUEUE,"helloWorld","hello",null);
        amqpAdmin.declareBinding(binding);
    }
    @GetMapping("/countItem")
    public String countItem(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num){
        cartService.changeItemCount(skuId,num);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCart")
    public String addToCart(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num, RedirectAttributes model) throws ExecutionException, InterruptedException {
        if(num > 0){
            cartService.addToCart(skuId,num);
//            RedirectAttributes的addAttribute会自动拼串,自动以参数的形式携带数据
//            RedirectAttributes的addFlashAttribute()会保存在session里面,但是仅可以取一次值
            model.addAttribute("skuId",skuId);
            return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
        }
        return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
    }
    @GetMapping("/checkItem")
    public String checkItem(@RequestParam("skuId")Long skuId,@RequestParam("check")Integer check){
        cartService.checkItem(skuId,check);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCartSuccess.html")
    public String addToCartSuccessPage(@RequestParam("skuId")Long skuId,Model model){
        CartItem cartItem = cartService.getCartItem(skuId);
        model.addAttribute("item",cartItem);
        return "success";
    }
}

package com.alatus.mall.cart.web;

import com.alatus.mall.cart.service.CartService;
import com.alatus.mall.cart.vo.Cart;
import com.alatus.mall.cart.vo.CartItem;
import com.alatus.mall.cart.vo.UserInfoTo;
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import java.util.concurrent.ExecutionException;

@Controller
public class CartController {
    @Autowired
    private CartService cartService;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private AmqpAdmin amqpAdmin;
    @GetMapping("/sendMessage")
    public void sendMessage(){
        UserInfoTo userInfoTo = new UserInfoTo(1L,"2323");
        rabbitTemplate.convertAndSend("helloWorld","hello",userInfoTo);
    }
    @GetMapping("/cart.html")
    public String cartListPage(Model model) throws ExecutionException, InterruptedException {
        Cart cart = cartService.getCart();
        model.addAttribute("cart",cart);
        return "cartList";
    }
    @GetMapping("/deleteItem")
    public String deleteItem(@RequestParam("skuId")Long skuId){
        cartService.deleteItem(skuId);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/createExchange")
    public void createExchange() throws InterruptedException {
//        声明交换机
        DirectExchange directExchange = new DirectExchange("helloWorld",true,false);
        amqpAdmin.declareExchange(directExchange);
//        队列不能有排他性,要都能连接到这个队列才是正确的
        Queue helloJava = new Queue("helloJava", true, false,false);
        amqpAdmin.declareQueue(helloJava);
        Thread.sleep(2000);
        Binding binding = new Binding("helloJava", Binding.DestinationType.QUEUE,"helloWorld","hello",null);
        amqpAdmin.declareBinding(binding);
    }
    @GetMapping("/countItem")
    public String countItem(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num){
        cartService.changeItemCount(skuId,num);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCart")
    public String addToCart(@RequestParam("skuId") Long skuId, @RequestParam("num") Integer num, RedirectAttributes model) throws ExecutionException, InterruptedException {
        if(num > 0){
            cartService.addToCart(skuId,num);
//            RedirectAttributes的addAttribute会自动拼串,自动以参数的形式携带数据
//            RedirectAttributes的addFlashAttribute()会保存在session里面,但是仅可以取一次值
            model.addAttribute("skuId",skuId);
            return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
        }
        return "redirect:http://cart.alatusmall.com/addToCartSuccess.html";
    }
    @GetMapping("/checkItem")
    public String checkItem(@RequestParam("skuId")Long skuId,@RequestParam("check")Integer check){
        cartService.checkItem(skuId,check);
        return "redirect:http://cart.alatusmall.com/cart.html";
    }
    @GetMapping("/addToCartSuccess.html")
    public String addToCartSuccessPage(@RequestParam("skuId")Long skuId,Model model){
        CartItem cartItem = cartService.getCartItem(skuId);
        model.addAttribute("item",cartItem);
        return "success";
    }
}

package com.alatus.mall.product;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class UserInfoTo {
    private Long userId;
    private String userKey;
}
package com.alatus.mall.product;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class UserInfoTo {
    private Long userId;
    private String userKey;
}

 

package com.alatus.mall.product.service.impl;

import com.alatus.mall.product.UserInfoTo;
import com.alatus.mall.product.dao.SkuInfoDao;
import com.alatus.mall.product.entity.SkuImagesEntity;
import com.alatus.mall.product.entity.SkuInfoEntity;
import com.alatus.mall.product.entity.SpuInfoDescEntity;
import com.alatus.mall.product.service.*;
import com.alatus.mall.product.vo.SkuItemSaleAttrVo;
import com.alatus.mall.product.vo.SkuItemVo;
import com.alatus.mall.product.vo.SpuItemAttrGroupVo;
import com.rabbitmq.client.Channel;
import org.apache.commons.lang.StringUtils;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;

@Service("pmsSkuInfoService")
public class SkuInfoServiceImpl extends ServiceImpl<SkuInfoDao, SkuInfoEntity> implements SkuInfoService {
    @Autowired
    private SkuImagesService skuImagesService;
    @Autowired
    private SpuInfoDescService spuInfoDescService;
    @Autowired
    private AttrGroupService attrGroupService;
    @Autowired
    private SkuSaleAttrValueService skuSaleAttrValueService;
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        QueryWrapper<SkuInfoEntity> queryWrapper = new QueryWrapper<>();
        String key = (String) params.get("key");
        if(!StringUtils.isEmpty(key) && !"0".equalsIgnoreCase(key)){
            queryWrapper.and((wrapper) -> {
                wrapper.eq("sku_id",key).or().like("sku_name",key);
            });
        }
        String catelogId = (String) params.get("catelogId");
        if(!StringUtils.isEmpty(catelogId) && !"0".equalsIgnoreCase(catelogId)){
            queryWrapper.eq("catalog_id",catelogId);
        }
        String brandId = (String) params.get("brandId");
        if(!StringUtils.isEmpty(brandId) && !"0".equalsIgnoreCase(brandId)){
            queryWrapper.eq("brand_id",brandId);
        }
        String min = (String) params.get("min");
        if(!StringUtils.isEmpty(min) && !"0".equalsIgnoreCase(min)){
            queryWrapper.ge("price",min);
        }
        String max = (String) params.get("max");
        if(!StringUtils.isEmpty(max) && !"0".equalsIgnoreCase(max)){
            try{
                BigDecimal maxPrice = new BigDecimal(max);
                if(maxPrice.compareTo(new BigDecimal("0")) == 1){
                    queryWrapper.le("price",max);
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
        IPage<SkuInfoEntity> page = this.page(
                new Query<SkuInfoEntity>().getPage(params),
                queryWrapper
        );
        return new PageUtils(page);
    }
    @Override
    public void saveSkuInfo(SkuInfoEntity skuInfoEntity) {
        this.baseMapper.insert(skuInfoEntity);
    }
    @Override
    public List<SkuInfoEntity> getSkusBySpuId(Long spuId) {
        return this.list(new QueryWrapper<SkuInfoEntity>().eq("spu_id",spuId));
    }
    @RabbitListener(queues = "helloJava")
    public void getInfo(Message message, UserInfoTo userInfoTo, Channel channel){
//        这里的消息是AMQP核心包的消息
//        消息体
        byte[] body = message.getBody();
//        消息头属性
        MessageProperties messageProperties = message.getMessageProperties();
        System.out.println(userInfoTo);
    }
    @Override
    public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
        SkuItemVo skuItemVo = new SkuItemVo();
//        设置基本信息
        CompletableFuture<SkuInfoEntity> skuInfo = CompletableFuture.supplyAsync(() -> {
            SkuInfoEntity skuInfoEntity = getById(skuId);
            skuItemVo.setInfo(skuInfoEntity);
            return skuInfoEntity;
        }, threadPoolExecutor);
        CompletableFuture<Void> skuImages = CompletableFuture.runAsync(() -> {
            //        设置sku的图片信息
            List<SkuImagesEntity> images = skuImagesService.getBySkuId(skuId);
            skuItemVo.setImages(images);
        }, threadPoolExecutor);
        CompletableFuture<Void> saleAttr = skuInfo.thenAcceptAsync((res) -> {
            //        设置spu的销售属性组合
            List<SkuItemSaleAttrVo> skuItemSaleAttrVos = skuSaleAttrValueService.getSaleAttrsBySpuId(res.getSpuId());
            skuItemVo.setSaleAttr(skuItemSaleAttrVos);
        }, threadPoolExecutor);
        CompletableFuture<Void> spuDesc = skuInfo.thenAcceptAsync((res) -> {
            //        获取spu的介绍
            SpuInfoDescEntity spuInfoDesc = spuInfoDescService.getById(res.getSpuId());
            skuItemVo.setDesc(spuInfoDesc);
        }, threadPoolExecutor);
        CompletableFuture<Void> spuAttrGroup = skuInfo.thenAcceptAsync((res) -> {
            //        获取SPU的规格参数信息
            List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
            skuItemVo.setGroupAttrs(attrGroupVos);
        }, threadPoolExecutor);
//        等待所有任务完成后会返回数据
        CompletableFuture.allOf(skuInfo,skuImages,saleAttr,spuDesc,spuAttrGroup).get();
        return skuItemVo;
    }
}
package com.alatus.mall.product.service.impl;

import com.alatus.mall.product.UserInfoTo;
import com.alatus.mall.product.dao.SkuInfoDao;
import com.alatus.mall.product.entity.SkuImagesEntity;
import com.alatus.mall.product.entity.SkuInfoEntity;
import com.alatus.mall.product.entity.SpuInfoDescEntity;
import com.alatus.mall.product.service.*;
import com.alatus.mall.product.vo.SkuItemSaleAttrVo;
import com.alatus.mall.product.vo.SkuItemVo;
import com.alatus.mall.product.vo.SpuItemAttrGroupVo;
import com.rabbitmq.client.Channel;
import org.apache.commons.lang.StringUtils;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;

@Service("pmsSkuInfoService")
public class SkuInfoServiceImpl extends ServiceImpl<SkuInfoDao, SkuInfoEntity> implements SkuInfoService {
    @Autowired
    private SkuImagesService skuImagesService;
    @Autowired
    private SpuInfoDescService spuInfoDescService;
    @Autowired
    private AttrGroupService attrGroupService;
    @Autowired
    private SkuSaleAttrValueService skuSaleAttrValueService;
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        QueryWrapper<SkuInfoEntity> queryWrapper = new QueryWrapper<>();
        String key = (String) params.get("key");
        if(!StringUtils.isEmpty(key) && !"0".equalsIgnoreCase(key)){
            queryWrapper.and((wrapper) -> {
                wrapper.eq("sku_id",key).or().like("sku_name",key);
            });
        }
        String catelogId = (String) params.get("catelogId");
        if(!StringUtils.isEmpty(catelogId) && !"0".equalsIgnoreCase(catelogId)){
            queryWrapper.eq("catalog_id",catelogId);
        }
        String brandId = (String) params.get("brandId");
        if(!StringUtils.isEmpty(brandId) && !"0".equalsIgnoreCase(brandId)){
            queryWrapper.eq("brand_id",brandId);
        }
        String min = (String) params.get("min");
        if(!StringUtils.isEmpty(min) && !"0".equalsIgnoreCase(min)){
            queryWrapper.ge("price",min);
        }
        String max = (String) params.get("max");
        if(!StringUtils.isEmpty(max) && !"0".equalsIgnoreCase(max)){
            try{
                BigDecimal maxPrice = new BigDecimal(max);
                if(maxPrice.compareTo(new BigDecimal("0")) == 1){
                    queryWrapper.le("price",max);
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
        IPage<SkuInfoEntity> page = this.page(
                new Query<SkuInfoEntity>().getPage(params),
                queryWrapper
        );
        return new PageUtils(page);
    }
    @Override
    public void saveSkuInfo(SkuInfoEntity skuInfoEntity) {
        this.baseMapper.insert(skuInfoEntity);
    }
    @Override
    public List<SkuInfoEntity> getSkusBySpuId(Long spuId) {
        return this.list(new QueryWrapper<SkuInfoEntity>().eq("spu_id",spuId));
    }
    @RabbitListener(queues = "helloJava")
    public void getInfo(Message message, UserInfoTo userInfoTo, Channel channel){
//        这里的消息是AMQP核心包的消息
//        消息体
        byte[] body = message.getBody();
//        消息头属性
        MessageProperties messageProperties = message.getMessageProperties();
        System.out.println(userInfoTo);
    }
    @Override
    public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
        SkuItemVo skuItemVo = new SkuItemVo();
//        设置基本信息
        CompletableFuture<SkuInfoEntity> skuInfo = CompletableFuture.supplyAsync(() -> {
            SkuInfoEntity skuInfoEntity = getById(skuId);
            skuItemVo.setInfo(skuInfoEntity);
            return skuInfoEntity;
        }, threadPoolExecutor);
        CompletableFuture<Void> skuImages = CompletableFuture.runAsync(() -> {
            //        设置sku的图片信息
            List<SkuImagesEntity> images = skuImagesService.getBySkuId(skuId);
            skuItemVo.setImages(images);
        }, threadPoolExecutor);
        CompletableFuture<Void> saleAttr = skuInfo.thenAcceptAsync((res) -> {
            //        设置spu的销售属性组合
            List<SkuItemSaleAttrVo> skuItemSaleAttrVos = skuSaleAttrValueService.getSaleAttrsBySpuId(res.getSpuId());
            skuItemVo.setSaleAttr(skuItemSaleAttrVos);
        }, threadPoolExecutor);
        CompletableFuture<Void> spuDesc = skuInfo.thenAcceptAsync((res) -> {
            //        获取spu的介绍
            SpuInfoDescEntity spuInfoDesc = spuInfoDescService.getById(res.getSpuId());
            skuItemVo.setDesc(spuInfoDesc);
        }, threadPoolExecutor);
        CompletableFuture<Void> spuAttrGroup = skuInfo.thenAcceptAsync((res) -> {
            //        获取SPU的规格参数信息
            List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
            skuItemVo.setGroupAttrs(attrGroupVos);
        }, threadPoolExecutor);
//        等待所有任务完成后会返回数据
        CompletableFuture.allOf(skuInfo,skuImages,saleAttr,spuDesc,spuAttrGroup).get();
        return skuItemVo;
    }
}
Rabbit的java-based配置方法RabbitTemplateConfiguration
glenshappy的专栏
02-22 546
package it.automobile.imageservice.messaging.configuration; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; import lombok.RequiredArgsCo.
RabbitMQ集成进Spring项目以AMQP的形式------RabbitMQ
春风若有怜花意，可否许我再少年
09-29 874
RabbitMQ集成进Spring项目以AMQP的形式------RabbitMQ
RabbitTemplate的创建与配置
qq_37436172的博客
04-05 4144
RabbitTemplate是我们在与SpringAMQP整合的时候进行发送消息的关键类该类提供了丰富的发送消息的方法，包括可靠性消息投递、回调监听消息接口ConfirmCallback、返回值确认接口ReturnCallback等等同样我们需要注入到Spring容器中，然后直接使用。在与spring整合时需要实例化，但是在与Springboot整合时，只需要添加配置文件即可首先将其注入到bean里面：如果自己不注入。
万能RabbitTemplate使用模板
weixin_43626889的博客
08-26 3743
文章目录前言一、RabbitMqConfig二、RabbitmqSend三、MsgReceiver四、MsgReceiverB总结 前言 类的介绍： RabbitMqConfig：消息队列配置类，包括拿到application的配置，定义队列，交换机，交换机绑定队列指定routingkey RabbitmqSend：消息发送类，使用时直接将此自动注入然后使用，主要的方法就是将消息放入每个routkey指定的队列中 MsgReceiver：负责接受消息并处理他们 一、RabbitMqConfig @Co
257、商城业务-消息队列-RabbitTemplate使用
pyd1040201698的博客
09-18 320
vue 中如何使用rabbitMQ 监听消息队列
01-20
在Vue项目中集成RabbitMQ来监听消息队列是一个常见的需求，这可以帮助应用程序实时处理后台产生的数据。在本文中，我们将探讨如何使用STOMP库（通过WebSocket）与RabbitMQ进行交互，因为RabbitMQ不直接支持...
Windows c++中RabbitMQ-c特殊消息队列的保姆教程（csdn）————程序.pdf
12-04
RabbitMQ-c是一个C语言编写的轻量级RabbitMQ客户端库，适合在C++项目中使用。 在本文档中，我们将专注于在Windows 10上安装RabbitMQ和RabbitMQ-c，并在C++环境中创建一个简单的客户端。以下是详细的步骤和知识点： ...
nodejs-rabbitmq：简单的RabbitMQ发布者消费者应用程序，通过快速路由发送消息
02-19
我们需要声明一个队列，并使用`consume()`方法监听队列。当有新消息到达时，RabbitMQ会调用我们提供的回调函数，处理接收到的消息。 5. **Express框架**：尽管在标题和描述中没有提到，但`express`标签表明这个项目...
108、AMQP消息队列-RabbitMQ1
08-04
然后，通过`messenger:consume`命令，Symfony应用监听并处理队列中的消息。 总结：本案例主要介绍了如何在Symfony应用中集成RabbitMQ作为消息队列，利用Docker容器部署RabbitMQ服务，配置`.env`文件进行连接，并...
RabbitMQ学习笔记 - RabbitMQ消息监听容器
qq_30068375的博客
03-22 2686
RabbitMQ消息监听 调用线程实时监听RabbitMQ队列中的消息然后进行业务处理 SimpleMessageListenerContainer 1、SimpleMessageListenerContainer进行很多设置，消费者的配置项进行设置，可以满足监听队列（多个队列）、自动启动、自动声明功能 2、简单消息监听容器     1）设置事务特性、事务管理器、事务属性、事务容量（并发）、是否开启事务、回滚消息等     2
SpringBoot学习之路---使用RabbitTemplate操作RabbitMq
热门推荐
LeslieLau的博客
04-28 2万+
在学习了RabbitMq之后，我们知道当打开RabbitMq服务时，访问15672端口可以进入web管理界面，并且可以在里面操作，如发送消息，从某个队列中接受消息。但是我们平时在程序实际运行中，不可能一直手动地来完成这些操作(因为我们不知道什么时候需要发送接受消息，而且这样效率很低)。在基于消息队列的程序中，我们需要编写程序来完成从消息队列自动收发消息的操作，这一篇就来记录怎么使用java来完成这...
消息驱动：如何使用 Rabbit Template 集成 RabbitMQ？
我乐了的博客
02-04 1759
上图中，不同的路由算法存在不同的 Exchange 类型，而 AMQP 规范中指定了直接式交换器（Direct Exchange）、广播式交换器（Fanout Exchange）、主题式交换器（Topic Exchange）和消息头式交换器（Header Exchange）这几种 Exchange 类型，不过这一讲我们将重点介绍直接式交换器。消息中包含一个路由键（Routing Key），它由消息发送者产生，并提供给 Exchange 路由这条消息的标准。
Rabbittemplate所有方法.简介.
LLL778888的博客
04-28 2986
csdn的chatgpt
SpringBoot整合RabbitMQ系列--RabbitTemplate的配置
IT利刃出鞘的博客
05-29 3377
本文用实例介绍SpringBoot整合RabbitMQ时RabbitTemplate的配置。
Spring Boot 中的 RabbitTemplate 是什么，原理，如何使用
it_xushixiong的博客
07-01 3241
本文介绍了 RabbitTemplate 的原理、使用方法和常见应用场景。RabbitTemplate 是 Spring Boot 应用程序中与 RabbitMQ 集成的关键组件，它封装了 AMQP 协议的细节，提供了简单的 API 来进行消息发送和接收。通过本文的介绍，读者可以了解 RabbitTemplate 的基本原理和使用方法，并在实际项目中使用 RabbitTemplate 实现异步任务处理和发布订阅模式等应用场景。
RabbitMQ使用RabbitHandler和RabbitListener实现监听消息并获取不同类型的消息------RabbitMQ
最新发布
春风若有怜花意，可否许我再少年
09-29 928
RabbitMQ使用RabbitHandler和RabbitListener实现监听消息并获取不同类型的消息------RabbitMQ
使用RabbitMQ时，ConnectionFactory和RabbitTemplate的配置问题
qq_60638478的博客
08-07 311
2.如果使用的是普通Spring项目，则需要手动配置ConnectionFactory和RabbitTemplate。
Spring boot项目--RabbitMq配置
04-17 164
1、引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactI...
RabbitMQ消息队列深入使用教程及集群搭建
资源摘要信息:"RabbitMQ消息队列的使用" RabbitMQ是一种流行的开源消息代理软件，也是一个在分布式系统中实现可靠消息传递的解决方案。它使用高级消息队列协议（AMQP）实现，支持多种消息模式，包括点对点消息传递...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值