rabbitmq fanout广播模式无法发给多个消费者，求大神解答

pwqpwq1111 2019-01-12 07:10:16

调试了一天了，无法解决rabbitmq的广播模式，两个消费者，一条A消费者接受到，一条B消费者接收到，不能同时接收到，必须是同一个queue,求大神解答，代码如下：

rabbitTemplate 和 cachingConnectionFactory工厂连接类

@Configuration

@EnableRabbit

public class RabbitConfiguration {



    @Autowired

    RabbitProperties properties;





    @Bean

    public CachingConnectionFactory cachingConnectionFactory(){

        CachingConnectionFactory factory = new CachingConnectionFactory();

        factory.setAddresses(properties.getAddresses());

        factory.setUsername(properties.getUsername());

        factory.setPassword(properties.getPassword());

        factory.setVirtualHost(properties.getVirtualHost());

        factory.setPublisherConfirms(true);

        return factory;

    }







    @Bean

    public RabbitAdmin rabbitAdmin() {

        return new RabbitAdmin(cachingConnectionFactory());

    }





    @Bean

    public RabbitTemplate rabbitTemplate(CachingConnectionFactory cachingConnectionFactory){

        RabbitTemplate template = new RabbitTemplate(cachingConnectionFactory);

        template.setMessageConverter(new Jackson2JsonMessageConverter());

        return template;

    }





}

queue exchange listener 声明类

@Configuration("syncRabbitConfiguration")

@EnableRabbit

public class RabbitConfiguration {





    public static final String QUEUE = "external_socket.request";

    public static final String EXCHANGE = "external_socket.request";

    @Autowired

    CachingConnectionFactory cachingConnectionFactory;



    @Autowired

    RabbitAdmin rabbitAdmin;



    @Autowired

    SocketConsumer consumer;

    @Bean

    public FanoutExchange socketExchange(){

        return new FanoutExchange(EXCHANGE);

    }

    @Bean

    public Queue socketQueue(){

        return new Queue(QUEUE);

    }



    @Bean

    public Binding socketBinding(Queue socketQueue,FanoutExchange socketExchange){

        return BindingBuilder.bind(socketQueue).to(socketExchange);

    }



    @Bean

    public SimpleMessageListenerContainer smsContainer(Queue socketQueue){

        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();

        container.setConnectionFactory(cachingConnectionFactory);

        container.setAcknowledgeMode(AcknowledgeMode.NONE);

        container.setExposeListenerChannel(true);

        container.setMaxConcurrentConsumers(1);

        container.setConcurrentConsumers(1);

        container.setRabbitAdmin(rabbitAdmin);

        container.setQueues(socketQueue);

        container.setMessageListener(consumer);

        container.setRecoveryInterval(MQConstant.Rabbit.DEFAULT_RECOVERY_INTERVAL);

        return container;

    }



}

其中container.setAcknowledgeMode(AcknowledgeMode.NONE);
container.setExposeListenerChannel(true);
container.setMaxConcurrentConsumers(1);
container.setConcurrentConsumers(1);
这几个参数我都调整过，没用，下面是消费者代码

@Service

public class SocketConsumer implements ChannelAwareMessageListener {



    @Override

    public void onMessage(Message message, Channel channel) throws Exception  {

        String body = null;

        try {

            body = new String(message.getBody(),"UTF-8");

            SimpleDataDto dto = JSONObject.parseObject(body, SimpleDataDto.class);

            System.out.println(dto.getSyncType()+":收到消息");

            if(dto.getSyncType() == null){

                List<SocketIOClient> allClient = SessionManager.getAllClient();

                for (SocketIOClient socketIOClient : allClient) {

                    socketIOClient.sendEvent(dto.getDataType(),dto.getData());

                }

            }else{

                SocketIOClient client = SessionManager.getClient(dto.getSyncType());

                if(client !=null)

                    client.sendEvent(dto.getDataType(),dto.getData());

            }

        } catch (UnsupportedEncodingException e) {

            e.printStackTrace();

        }catch (Exception e){

            e.printStackTrace();

        }



    }

}

发送代码就一行

 rabbitTemplate.convertAndSend(RabbitConfiguration.EXCHANGE,"",dataDto);

通过自带的web管理段发布消息也是一样的效果
下面是管理端的截图

exchange

queue

实在找不到办法了，求解决啊！！！！！！！！！！

...全文

1318 8 打赏收藏举报

写回复

用AI写文章

8 条回复

切换为时间正序

请发表友善的回复…

发表回复

ZZ190527029 2020-10-19

打赏
举报

你这属于工作模式,相互竞争的两个消费者,根本就不是广播,不知道你在纠结什么

川蜀程序猿 2020-06-18

打赏
举报

楼主的意思是多个消费者挂在同一个消费队列中,多个消费者都能接收到.但是因为多个消费者挂在同一个队列上,会有竞争关系,所以只有一个接收到,其他接收不到(这才是要解决的问题).看了一些博客.有一个方案是采用redis的发布订阅模式(得到消息的去通知其他的消费者)

munan56 2020-01-16

打赏
举报

引用 6 楼松月的回复:

这个问题也困扰我好久，我的做法是：生产者声明一个FANOUT交换机消费者声明一个系统产生的随机队列绑定到这个交换机上，然后往交换机发消息，只要绑定到这个交换机上都能收到消息，关键代码如下：生产者：


@Slf4j
@Component
public class RabbitHelper  {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 广播消息
     * @param exchange
     * @param message
     */
    public void broadcast(String exchange,String message){
        rabbitTemplate.convertAndSend(exchange,"",message);
    }

}

消费者：


@Slf4j
@Component
public class DownCmdConsumer {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(), //注意这里不要定义队列名称,系统会随机产生
            exchange = @Exchange(value = "填写交换机名称",type = ExchangeTypes.FANOUT)
    )
    )
    public void process(String payload) {
        log.info("receive:{}",payload)
    }
}

老哥稳，我看cloud BUS差不多也是这么做的6666

松月 2019-12-31

打赏
举报

松月 2019-12-31

打赏
举报


@Slf4j
@Component
public class RabbitHelper  {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 广播消息
     * @param exchange
     * @param message
     */
    public void broadcast(String exchange,String message){
        rabbitTemplate.convertAndSend(exchange,"",message);
    }

}

消费者：


@Slf4j
@Component
public class DownCmdConsumer {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(), //注意这里不要定义队列名称,系统会随机产生
            exchange = @Exchange(value = "填写交换机名称",type = ExchangeTypes.FANOUT)
    )
    )
    public void process(String payload) {
        log.info("receive:{}",payload)
    }
}