RabbitMQ使用

RabbitMQ配置

/**
 * RabbitMQ配置
 *
 */
@Configuration
@Component
@ConfigurationProperties(prefix = "rabbitmq")
public class RabbitConfig {

    public static final String payoutSyncExchange = "payoutSyncExchange";
    public static final String payoutNotify = "payoutNotify";

    @Getter
    @Setter
    public Map<String, String> exchanges = new HashMap<String, String>();

    @Getter
    @Setter
    public Map<String, String> queues = new HashMap<String, String>();

    @Getter
    @Setter
    public Map<String, String> timeout = new HashMap<String, String>();

    @Setter
    @Getter
    public String host;

    @Setter
    @Getter
    public int port;

    @Setter
    @Getter
    public String userName;

    @Setter
    @Getter
    public String password;

    @Setter
    @Getter
    public String virtualHost;

    @Setter
    @Getter
    public int nThreads;

    @Setter
    @Getter
    public boolean publisherConfirms;

    @Setter
    @Getter
    public boolean publisherReturns;

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(host + ":" + port);
        connectionFactory.setUsername(userName);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        connectionFactory.setPublisherConfirms(publisherConfirms);
        connectionFactory.setPublisherReturns(publisherReturns);
        connectionFactory.setConnectionTimeout(new Integer(timeout.get("connect")));
        return connectionFactory;
    }

    @Bean
    public TopicExchange channelApplyExchange() {
        return new TopicExchange(exchanges.get("payoutSyncExchange"), true, false);
    }

    @Bean
    public Queue payoutNotifyQueue() {
        return new Queue(queues.get("payoutNotify"), true);
    }


    @Bean
    public Binding payoutNotifyQueueBinding() {
        return BindingBuilder.bind(payoutNotifyQueue()).to(channelApplyExchange()).with(queues.get("payoutNotify"));
    }

}

yml配置

#RabbitMQ配置
rabbitmq:
  host: 10.0.17.22
  port: 5672
  userName: aaa
  password: aaa
  publisherConfirms: false
  publisherReturns: true
  virtualHost: sit-22
  exchanges:
    payoutSyncExchange: credit-admin-app-payout.topic
  queues:
    #放款成功同步请求队列（admin-app）
    payoutNotify: ha.credit.admin.payoutNotify

生产者-RabbitSender类

@Component
@Slf4j
@Scope("prototype")
public class RabbitSender {

    @Autowired
    @Getter
    private RabbitTemplate rabbitTemplate;

    @Setter
    private String exchange;

    @Setter
    private String queue;

    public void sendMessage(String message, String logKeyword) {
        rabbitTemplate.convertAndSend(exchange, queue, message);
    }

    public void sendMessage(ChannelRabbitMessage message) {
        rabbitTemplate.convertAndSend(exchange, queue, message);
    }

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend(exchange, queue, message);
    }

    public void sendMessage(Object message) {
        rabbitTemplate.convertAndSend(exchange, queue, message);
    }
}

消费者-RabbitReceiver类

@Component
@Slf4j
@Scope("prototype")
public class RabbitReceiver {

    @Autowired
    @Getter
    private RabbitTemplate rabbitTemplate;

    @Setter
    private String exchange;

    @Setter
    private String queue;

    @Setter
    private int receiveTimeout;

    /**
     * 从指定队列读取消息
     * @param logKeyword
     * @param encoding
     * @return
     * @throws Exception
     */
    public Object receiveMessage(String logKeyword,String encoding) throws Exception{
        Object obj = rabbitTemplate.receiveAndConvert(queue,receiveTimeout);
        if(obj!=null&&obj instanceof String){
            log.info(logKeyword + " 从[" + queue + "] 接收消息成功");
            return obj;
        }else if(obj!=null&&obj instanceof byte[]){
            log.info(logKeyword + " 从[" + queue + "] 接收消息成功"+new String((byte[])obj,encoding));
            return new String((byte[])obj,encoding);
        }else if(obj==null){
            log.info(logKeyword + " 从[" + queue + "] 接收消息超时！");
        }
        return obj;
    }
}

工具类RabbitMQHelper类

@Component
@Slf4j
public class RabbitMQHelper {
    @Resource
    private RabbitSender rabbitSender;
    @Resource
    private RabbitConfig rabbitConfig;
    /**
     * 放款exchange
     */
    public static final String PAYOUT_SYNC_EXCHANGE = "payoutSyncExchange";
    /*********************************
     * exchange只有一个，queue有多个
     ***************************************/
    /**
     * 放款queue
     */
    public static final String PAYOUT_NOTIFY = "payoutNotify";

    /**
     * 发送到MQ
     *
     * @param exchange
     * @param queue
     * @param message
     */
    public void send(String exchange, String queue, Object message) {
        //设置事务环境，可以使用RabbitMQ事务
        //当网络状况不稳定的时候，有可能会出现消息丢失的情况。这时，我们就需要使用RabbitMQ的事务机制，保证消息发送出去后不会丢失。
        rabbitSender.getRabbitTemplate().setChannelTransacted(true);
        rabbitSender.setExchange(rabbitConfig.getExchanges().get(exchange));
        rabbitSender.setQueue(rabbitConfig.getQueues().get(queue));
        rabbitSender.sendMessage(message);
        log.info("发送MQ成功,exchange={}, queue = {}", exchange, queue);
    }
}

使用-发送

rabbitMQHelper.send(RabbitMQHelper.PAYOUT_SYNC_EXCHANGE, RabbitMQHelper.PAYOUT_NOTIFY, payout);

使用-接收

@Slf4j
@Service
public class RabbitMQListener {

    @Resource
    private WxNewsApi wxNewsApi;

    /**
     * 放款结果queue监听
     *
     * @param message
     * @throws Exception
     */
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "ha.credit.admin.payoutNotify", autoDelete = "false"),
            exchange = @Exchange(value = "credit-admin-app-payout.topic", type = ExchangeTypes.TOPIC)
    ))
    @RabbitHandler
    public void receivePayoutNotify(XdBusiPayout payout) {
        log.info("接收到放款消息:{}", JSON.toJSONString(payout));
        //字节码转化为对象
        wxNewsApi.notifyThirdPartyPaymentResult(payout.getPutoutno());
    }
}