RabbitMQ使用RabbitHandler和RabbitListener实现监听消息并获取不同类型的消息------RabbitMQ

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

import com.alatus.mall.product.CartItem;
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.RabbitHandler;
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")
@RabbitListener(queues = "helloJava")
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));
    }
//    同一个消息只会有一个人收到,并不会导致重复消费
//    消息接收,需要一个消息处理完,才能消费第二条
    @RabbitHandler
    public void getInfo(Message message, UserInfoTo userInfoTo, Channel channel){
//        这里的消息是AMQP核心包的消息
//        消息体
        byte[] body = message.getBody();
//        消息头属性
        MessageProperties messageProperties = message.getMessageProperties();
        System.out.println(userInfoTo);
    }
    @RabbitHandler
    public void getInfo1(Message message, CartItem cartItem, Channel channel){
//        这里的消息是AMQP核心包的消息
//        消息体
        byte[] body = message.getBody();
//        消息头属性
        MessageProperties messageProperties = message.getMessageProperties();
        System.out.println(cartItem);
    }
    @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.CartItem;
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.RabbitHandler;
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")
@RabbitListener(queues = "helloJava")
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));
    }
//    同一个消息只会有一个人收到,并不会导致重复消费
//    消息接收,需要一个消息处理完,才能消费第二条
    @RabbitHandler
    public void getInfo(Message message, UserInfoTo userInfoTo, Channel channel){
//        这里的消息是AMQP核心包的消息
//        消息体
        byte[] body = message.getBody();
//        消息头属性
        MessageProperties messageProperties = message.getMessageProperties();
        System.out.println(userInfoTo);
    }
    @RabbitHandler
    public void getInfo1(Message message, CartItem cartItem, Channel channel){
//        这里的消息是AMQP核心包的消息
//        消息体
        byte[] body = message.getBody();
//        消息头属性
        MessageProperties messageProperties = message.getMessageProperties();
        System.out.println(cartItem);
    }
    @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.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.math.BigDecimal;
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(){
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 0){
                UserInfoTo userInfoTo = new UserInfoTo();
                userInfoTo.setUserKey("2323");
                userInfoTo.setUserId(1L);
                rabbitTemplate.convertAndSend("helloWorld","hello",userInfoTo);
            }
            else{
                CartItem cartItem = new CartItem();
                cartItem.setCount(1);
                cartItem.setCheck(true);
                cartItem.setPrice(new BigDecimal(1000));
                rabbitTemplate.convertAndSend("helloWorld","hello",cartItem);
            }
        }
    }
    @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.math.BigDecimal;
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(){
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 0){
                UserInfoTo userInfoTo = new UserInfoTo();
                userInfoTo.setUserKey("2323");
                userInfoTo.setUserId(1L);
                rabbitTemplate.convertAndSend("helloWorld","hello",userInfoTo);
            }
            else{
                CartItem cartItem = new CartItem();
                cartItem.setCount(1);
                cartItem.setCheck(true);
                cartItem.setPrice(new BigDecimal(1000));
                rabbitTemplate.convertAndSend("helloWorld","hello",cartItem);
            }
        }
    }
    @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";
    }
}
旧约Alatus
关注
专栏目录
Springboot RabbitMq源码解析之RabbitListener注解
翻身已碰头的博客
02-19 1万+
Springboot RabbitMq源码解析之配置类 Springboot RabbitMq源码解析之消息发送 Springboot RabbitMq源码解析之消费者容器SimpleMessageListenerContainer Springboot RabbitMq源码解析之consumer管理和AmqpEvent ...
Java调用rabbitmq监听_RabbitMQ：@RabbitListener 与 @RabbitHandler 及 消息序列化
weixin_31109487的博客
02-25 2994
添加 @RabbitListener 注解来指定某方法作为消息消费的方法，例如监听某 Queue 里面的消息MessageConvert涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte[] 数组的解析RabbitMQ 的序列化是指 Message 的 body 属性，即我们真正需要传输的内容，RabbitMQ 抽象出一个 Me...
RabbitMQ集成进Spring项目以AMQP的形式------RabbitMQ
最新发布
春风若有怜花意，可否许我再少年
09-29 874
RabbitMQ集成进Spring项目以AMQP的形式------RabbitMQ
Rabbitmq - rabbitmq Listener监听
程序员路同学
11-13 5873
rabbitmq 监听配置以及listener参数讲解
Java接收rabbitmQ消息_RabbitMQ (1) 消息的发送与接收
weixin_35724794的博客
02-24 396
本例子为简单的消息发送与接收，主机地址与端口均采用默认值。如Send1 ,声明Queue后消息被注入通道，(实际msg仍然先注入了默认的Exchange)消息发送端：package sunf.rabbitMQTest;import java.io.IOException;import com.rabbitmq.client.Channel;import com.rabbitmq.client....
@RabbitListener详解
weixin_42599558的博客
02-14 3046
@RabbitListener 是用于在 Spring AMQP 中消息监听的注解。它允许在 Spring 应用程序中声明消息监听器。在使用 @RabbitListener 注解的方法上，可以接收来自 RabbitMQ 队列的消息。这些方法可以通过使用 @RabbitHandler 注解标记，并在方法中声明一个参数来表示要接收的消息。 例如： @RabbitListener(queues = "q...
RabbitMQ之基于注解声明队列交换机：使用@RabbitListener实现消息监听
Takumilove的博客
08-03 1276
通过使用注解，我们可以方便地在Spring Boot应用中实现RabbitMQ的消息监听和处理。它不仅简化了配置流程，还增强了代码的可读性和可维护性。在实际项目中，我们可以根据业务需求，灵活定义队列、交换机及其绑定关系，实现复杂的消息路由逻辑。
springboot-rabbitmq-demo.zip
04-17
这种方式可以实现多路复用，一个类可以监听多个队列，或者一个方法可以处理多种类型的消息。 RabbitMQ还提供了交换机（Exchange）和绑定（Binding）的概念，可以实现更复杂的路由策略。例如，你可以创建一个交换机...
RabbitMQ-Day1-Code
06-29
RabbitMQ-Day1-Code 这个主题涵盖了初学者在接触RabbitMQ时可能会遇到的基础概念和实践操作，主要围绕两个核心组件——生产者（Producer）和消费者（Consumer）进行，通过SpringBoot框架实现。在这个入门教程中，...
java rabbitmq动态注册，监听实现
09-22
在这个场景中，"java rabbitmq动态注册，监听实现"涉及到的主要知识点是利用Spring Boot框架与RabbitMQ集成，动态配置消费者，并实现实时监听消息。 1. **Spring Boot与RabbitMQ集成**： Spring Boot简化了...
Hanlder、HandlerThread、AsyncTask处理机制的相关Demo代码
10-16
有关于Handler、HandlerThread、AsyncTask消息处理机制的相关Demo代码
@RabbitListener(quques=“ “）用法注意（RabbitMq）
qq_43237354的博客
07-15 2245
通过使用SpEL表达式，可以在运行时动态地获取和注入属性值，而不需要使用静态变量。注解中，指定的队列名称需要是常量。这意味着它必须是编译时确定的，而不能是在运行时动态计算的。是Spring表达式语言（SpEL）的一种写法，用于在Spring框架中动态获取属性值。这种写法，@rabbitListener会报错，队列名字我们没有使用常量。属性需要接受一个常量，以便在应用程序启动时就能确定要监听的队列。所以我们在配置文件里获得的变量，不可以直接使用。表示要引用的属性的键。注解中的队列名称中。
@RabbitListener 注解详解
weixin_42118323的博客
09-06 862
RabbitListener 注解是 Spring AMQP 提供的注解，用于简化 RabbitMQ 消息监听器的创建，我们在方法上添加 @RabbitListener 注解，就可以将方法注册为消息监听器，监听 RabbitMQ 的消息，本篇我们来分析一下 @RabbitListener 注解的使用详解。如有错误的地方欢迎指出纠正。
@RabbitListener注解
热门推荐
Va1mZzz的博客
10-18 3万+
I. 配置 首先创建一个 SpringBoot 项目，用于后续的演示 springboot 版本为2.2.1.RELEASE rabbitmq 版本为3.7.5 依赖配置文件 pom.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <ve..
RabbitMQ--集成Springboot--02--RabbitListener注解
zhou920786312的博客
10-24 1085
就由指定的方法进行处理。
RabbitMQ 学习笔记 -- 07 初探@RabbitListener
yorsola的博客
08-03 4243
Message 在消息传递的过程中，实际上传递的对象为 org.springframework.amqp.core.Message ，它主要由两部分组成： MessageProperties // 消息属性 byte[] body // 消息内容 如下使用 Message 类型接收数据，当监听到队列 hello中有消息时则会进行接收并处理,MessageConvert 会直接转换成消息类型，并绑定在对应被注解的方法中。 消息处理方法参数是由 MessageConverter 转化，若
RabbitListener的“内心深处”
weixin_51938350的博客
05-06 620
@RabbitListener注解和RabbitHandler注解 ConnectFactory 和 RabbitListenerContainerFactory
Springboot RabbitMq源码解析之RabbitListener注解 (四)
959
12-04 5897
RabbitListener注解源码解析
django rabbitmq RabbitListener
08-05
在提供的引用中，引用和引用展示了两个使用RabbitMQ进行消息监听的消费者代码示例。这些代码使用了Spring框架的@Component注解和@RabbitListener注解来定义RabbitMQ队列的监听器。其中，引用的消费者代码是监听队列A的消息，而引用的消费者代码是监听队列B的消息。具体的消息处理逻辑在@RabbitHandler注解标注的方法中实现。 至于引用中的内容，它提供了关于RabbitMQ的一些说明。RabbitMQ是一种流行的开源消息队列系统，使用erlang语言开发。它具有活跃的社区，维护和更新速度较快，性能稳定，因此受到许多企业的喜爱。 综上所述，RabbitListener是Django中用于实现RabbitMQ消息队列监听的注解。通过使用RabbitListener注解，可以方便地定义消息监听器并处理接收到的消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值