amqp java_RabbitMQ基于Spring AMQP的Java Config 简单配置实例

最新推荐文章于 2024-08-22 23:58:05 发布
最新推荐文章于 2024-08-22 23:58:05 发布
阅读量402 收藏
点赞数
文章标签： amqp java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39729784/article/details/114465663
版权

本实例尝试针对 Direct exchange、Fanout exchange、Topic exchange三种路由形式进行了消费者和生产者的集中实现，如有不对之处烦请读者指出。

1、项目基于Maven，在pom.xml中引入相关依赖。

com.rabbitmq

amqp-client

${rabbitmq.version}

org.springframework.amqp

spring-rabbit

${spring-rabbit.version}

2、RabbitMQ的Java Config 部分

package com.my.rabbitmq.appconfig;

import java.io.IOException;

import java.io.InputStream;

import java.util.Properties;

import org.apache.log4j.LogManager;

import org.apache.log4j.Logger;

import org.springframework.amqp.core.AbstractExchange;

import org.springframework.amqp.core.Binding;

import org.springframework.amqp.core.Binding.DestinationType;

import org.springframework.amqp.core.DirectExchange;

import org.springframework.amqp.core.FanoutExchange;

import org.springframework.amqp.core.TopicExchange;

import org.springframework.amqp.core.Queue;

import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;

import org.springframework.amqp.rabbit.connection.ConnectionFactory;

import org.springframework.amqp.rabbit.core.RabbitAdmin;

import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer;

import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;

import org.springframework.amqp.support.converter.AbstractMessageConverter;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import com.my.rabbitmq.util.FastJsonMessageConverter;

import com.my.rabbitmq.consumer.RabbitMQConsumer;

import com.my.rabbitmq.producer.RabbitMQProducer;

/**

*

* @description rabbitMQ config

*

* @author yuanzi

* @time 2017年8月23日 下午2:46:01

*/

@Configuration

public class RabbitmqConfig {

private static Logger log = LogManager.getLogger(RabbitmqConfig.class);

//读取rabbitmq配置文件

private static InputStream configFile = RabbitmqConfig.class.getClassLoader()

.getResourceAsStream("rabbitmq.properties");

private static Properties rabbitmqProperties = new Properties();

static {

try {

rabbitmqProperties.load(configFile);

} catch (IOException e) {

e.printStackTrace();

}

}

//配置生产者ConnectionFactory，配置基础连接信息

@Bean(name = "ProducerConnectionFactory")

public ConnectionFactory ProducerConnectionFactory() throws IOException {

CachingConnectionFactory connectionFactory = new CachingConnectionFactory(

rabbitmqProperties.getProperty("rabbitmq.host"));

connectionFactory.setPort(Integer.parseInt(rabbitmqProperties.getProperty("rabbitmq.port")));

connectionFactory.setUsername(rabbitmqProperties.getProperty("rabbitmq.username"));

connectionFactory.setPassword(rabbitmqProperties.getProperty("rabbitmq.password"));

return connectionFactory;

}

//配置消费者ConnectionFactory，配置基础连接信息

@Bean(name = "ConsumerConnectionFactory")

public ConnectionFactory ConsumerConnectionFactory() throws IOException {

CachingConnectionFactory connectionFactory = new CachingConnectionFactory(

rabbitmqProperties.getProperty("rabbitmq.host"));

connectionFactory.setPort(Integer.parseInt(rabbitmqProperties.getProperty("rabbitmq.port")));

connectionFactory.setUsername(rabbitmqProperties.getProperty("rabbitmq.username"));

connectionFactory.setPassword(rabbitmqProperties.getProperty("rabbitmq.password"));

return connectionFactory;

}

//配置RabbitAdmin，在配置了多个ConnectionFactory的情况下，需要配置RabbitAdmin，否则无法自动在rabbitmq服务器中注册交换机队列等。

@Bean

public RabbitAdmin rabbitAdmin() throws IOException {

return new RabbitAdmin(ConsumerConnectionFactory());

}

//配置生产者Template

@Bean(name = "ProducerRabbitTemplate")

public RabbitTemplate ProducerRabbitTemplate() throws IOException {

RabbitTemplate producerRabbitTemplate = new RabbitTemplate();

producerRabbitTemplate.setConnectionFactory(ProducerConnectionFactory());

producerRabbitTemplate.setExchange(rabbitmqProperties.getProperty("rabbitmq.producerExchange"));

//配置生产者信息转换器，封装发送信息的格式

producerRabbitTemplate.setMessageConverter(ProducerMessageConverter());

return producerRabbitTemplate;

}

//配置消费者Template

@Bean(name = "ConsumerRabbitTemplate")

public RabbitTemplate ConsumerRabbitTemplate() throws IOException {

RabbitTemplate consumerRabbitTemplate = new RabbitTemplate(ConsumerConnectionFactory());

consumerRabbitTemplate.setExchange(rabbitmqProperties.getProperty("rabbitmq.consumerExchange"));

return consumerRabbitTemplate;

}

//配置生产者交换机类型

@Bean(name = "ProducerExchange")

public AbstractExchange ProducerExchange() throws IOException {

String exchangeType = rabbitmqProperties.getProperty("rabbitmq.exchangeType");

if (exchangeType.contains("F")) {

FanoutExchange fanoutExchange = new FanoutExchange(

rabbitmqProperties.getProperty("rabbitmq.producerExchange"), true, false);

log.info("ProducerExchange-Fanout 生产者：广播路由");

return fanoutExchange;

} else if (exchangeType.contains("T")) {

TopicExchange topicExchange = new TopicExchange(rabbitmqProperties.getProperty("rabbitmq.producerExchange"),

true, false);

log.info("ProducerExchange-Topic 生产者：多路广播路由");

return topicExchange;

} else {

DirectExchange directExchange = new DirectExchange(

rabbitmqProperties.getProperty("rabbitmq.producerExchange"), true, false);

log.info("ProducerExchange-Direct 生产者：直接路由");

return directExchange;

}

}

//配置消费者交换机类型

@Bean(name = "ConsumerExchange")

public AbstractExchange ConsumerExchange() throws IOException {

String exchangeType = rabbitmqProperties.getProperty("rabbitmq.exchangeType");

if (exchangeType.contains("F")) {

FanoutExchange fanoutExchange = new FanoutExchange(

rabbitmqProperties.getProperty("rabbitmq.consumerExchange"), true, false);

log.info("ProducerExchange-Fanout 消费者：广播路由");

return fanoutExchange;

} else if (exchangeType.contains("T")) {

TopicExchange topicExchange = new TopicExchange(rabbitmqProperties.getProperty("rabbitmq.consumerExchange"),

true, false);

log.info("ProducerExchange-Topic 消费者：多路广播路由");

return topicExchange;

} else {

DirectExchange directExchange = new DirectExchange(

rabbitmqProperties.getProperty("rabbitmq.consumerExchange"), true, false);

log.info("ProducerExchange-Direct 消费者：直接路由");

return directExchange;

}

}

//配置参数：生产者队列名称，重启rabbitmq服务时队列还是否存在，只被一个connection使用并且在connection关闭时queue是否被删除，当最后一个consumer取消订阅时queue是否被删除

@Bean(name = "ProducerQueue")

public Queue ProducerQueue() throws IOException {

Queue producerQueue = new Queue(rabbitmqProperties.getProperty("rabbitmq.producerQueue"), true, false, false);

return producerQueue;

}

//配置参数：消费者队列名称，重启rabbitmq服务时队列还是否存在，只被一个connection使用并且在connection关闭时queue是否被删除，当最后一个consumer取消订阅时queue是否被删除

@Bean(name = "ConsumerQueue")

public Queue ConsumerQueue() throws IOException {

Queue consumerQueue = new Queue(rabbitmqProperties.getProperty("rabbitmq.consumerQueue"), true, false, false);

return consumerQueue;

}

//配置生产者消息转换器

@Bean(name = "jsonMessageConverter")

public AbstractMessageConverter ProducerMessageConverter() {

FastJsonMessageConverter jsonMessageConverter = new FastJsonMessageConverter();

return jsonMessageConverter;

}

//配置生产者队列与交换机之间的绑定关系和routingKey

@Bean(name = "ProducerBinding")

public Binding ProducerBinding() {

Binding binding = new Binding(rabbitmqProperties.getProperty("rabbitmq.producerQueue"), DestinationType.QUEUE,

rabbitmqProperties.getProperty("rabbitmq.producerExchange"),

rabbitmqProperties.getProperty("rabbitmq.producerRoutingKey"), null);

return binding;

}

//配置消费者队列与交换机之间的绑定关系和routingKey

@Bean(name = "ConsumerBinding")

public Binding ConsumerBinding() {

Binding binding = new Binding(rabbitmqProperties.getProperty("rabbitmq.consumerQueue"), DestinationType.QUEUE,

rabbitmqProperties.getProperty("rabbitmq.consumerExchange"),

rabbitmqProperties.getProperty("rabbitmq.consumerRoutingKey"), null);

return binding;

}

//实例化生产者代码，配置生产者要投递信息的RoutingKey

@Bean(name = "RabbitMQProducer")

public RabbitMQProducer RabbitMQProducer() {

RabbitMQProducer rabbitMQProducer = new RabbitMQProducer(

rabbitmqProperties.getProperty("rabbitmq.producerSendRoutingKey"));

return rabbitMQProducer;

}

//实例化消费者代码

@Bean(name = "RabbitMQConsumer")

public RabbitMQConsumer RabbitMQConsumer() {

RabbitMQConsumer rabbitMQConsumer = new RabbitMQConsumer();

return rabbitMQConsumer;

}

//配置监听模式，当有消息到达时会通知监听在对应的队列上的监听对象

@Bean(name = "ListenerContainer")

public AbstractMessageListenerContainer MessageListenerContainer() throws IOException {

SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer();

simpleMessageListenerContainer.setConnectionFactory(ConsumerConnectionFactory());

simpleMessageListenerContainer.setQueueNames(rabbitmqProperties.getProperty("rabbitmq.consumerQueue"));

simpleMessageListenerContainer.setMessageListener(RabbitMQConsumer());

return simpleMessageListenerContainer;

}

}

3、rabbitmq.properties 文件

#单一交换机配置参数

#rabbitmq server地址

rabbitmq.host = 127.0.0.1

#rabbitmq 端口

rabbitmq.port = 5672

#生产者队列名称

rabbitmq.producerQueue = d_queue_producer

#生产者RoutingKey

rabbitmq.producerRoutingKey = d_key_producer

#消费者队列名称

rabbitmq.consumerQueue = d_queue_consumer

#消费者RoutingKey

rabbitmq.consumerRoutingKey = d_key_consumer

#交换机类型 D为单一传播交换机类型，F为广播交换机类型，T为多路广播交换机类型

rabbitmq.exchangeType = D

#生产者需要绑定的交换机

rabbitmq.producerExchange = d_exchange

#消费者需要绑定的交换机

rabbitmq.consumerExchange = d_exchange

#rabbitmq用户名称

rabbitmq.username = guest

#rabbitmq用户密码

rabbitmq.password = guest

#rabbitmq生产者发送消息时的RoutingKey

rabbitmq.producerSendRoutingKey = d_key_consumer

---------------------------------------------分割线----------------------------------------------

#广播交换机配置参数，广播交换机下routingKey失效

#rabbitmq server地址

rabbitmq.host = 127.0.0.1

#rabbitmq 端口

rabbitmq.port = 5672

#生产者队列名称

rabbitmq.producerQueue = f_queue_producer

#生产者RoutingKey

rabbitmq.producerRoutingKey = f_key_producer

#消费者队列名称

rabbitmq.consumerQueue = f_queue_consumer

#消费者RoutingKey

rabbitmq.consumerRoutingKey = f_key_consumer

#交换机类型 D为单一传播交换机类型，F为广播交换机类型，T为多路广播交换机类型

rabbitmq.exchangeType = F

#生产者需要绑定的交换机

rabbitmq.producerExchange = f_exchange

#消费者需要绑定的交换机

rabbitmq.consumerExchange = f_exchange

#rabbitmq用户名称

rabbitmq.username = guest

#rabbitmq用户密码

rabbitmq.password = guest

#rabbitmq生产者发送消息时的RoutingKey

rabbitmq.producerSendRoutingKey = f_test

---------------------------------------------分割线----------------------------------------------

#多路广播交换机配置参数

#配置rootingkey时，“#”表示0个或若干个关键字，“*”表示一个关键字。例如“log.*”能与“log.warn”匹配，无法

#与“log.warn.timeout”匹配；但是“log.#”能与上述两者匹配

#rabbitmq server地址

rabbitmq.host = 127.0.0.1

#rabbitmq 端口

rabbitmq.port = 5672

#生产者队列名称

rabbitmq.producerQueue = t_queue_producer

#生产者RoutingKey

rabbitmq.producerRoutingKey = t_key_producer

#消费者队列名称

rabbitmq.consumerQueue = t_queue_consumer

#消费者RoutingKey

rabbitmq.consumerRoutingKey = #.test

#交换机类型 D为单一传播交换机类型，F为广播交换机类型，T为多路广播交换机类型

rabbitmq.exchangeType = T

#生产者需要绑定的交换机

rabbitmq.producerExchange = t_exchange2

#消费者需要绑定的交换机

rabbitmq.consumerExchange = t_exchange2

#rabbitmq用户名称

rabbitmq.username = guest

#rabbitmq用户密码

rabbitmq.password = guest

#rabbitmq生产者发送消息时的RoutingKey

rabbitmq.producerSendRoutingKey = t.test

4、生产者代码

package com.my.rabbitmq.producer;

import javax.annotation.Resource;

import org.apache.log4j.LogManager;

import org.apache.log4j.Logger;

import org.springframework.amqp.rabbit.core.RabbitTemplate;

/**

* @description RabbitMQ消息发送

*

* @author yuanzi

* @time 2017年8月1日 下午3:16:08

*/

public class RabbitMQProducer {

private static Logger log = LogManager.getLogger(RabbitMQProducer.class);

@Resource(name = "ProducerRabbitTemplate")

private RabbitTemplate rabbitTemplate;

private String routingKey;

public RabbitMQProducer(String routingKey) {

this.routingKey = routingKey;

}

public void sendDataToQueue(Object message) {

rabbitTemplate.convertAndSend(this.routingKey, message);

log.info("rabbitMQ producer send message:" + message);

}

}

5、消费者代码

package com.my.rabbitmq.consumer;

import org.apache.log4j.LogManager;

import org.apache.log4j.Logger;

import org.springframework.amqp.core.Message;

import org.springframework.amqp.core.MessageListener;

/**

*

* @description RabbitMQ消息接收

*

* @author yuanzi

* @time 2017年8月23日 下午3:38:03

*/

public class RabbitMQConsumer implements MessageListener {

private static Logger log = LogManager.getLogger(RabbitMQConsumer.class);

public void onMessage(Message message) {

String data = new String(message.getBody());

log.info("rabbitMQ consumer receive message：" + data);

}

}

6、消息转换器的配置

package com.my.rabbitmq.util;

import java.io.UnsupportedEncodingException;

import org.springframework.amqp.core.Message;

import org.springframework.amqp.core.MessageProperties;

import org.springframework.amqp.support.converter.AbstractMessageConverter;

import org.springframework.amqp.support.converter.MessageConversionException;

import net.sf.json.JSONObject;

/**

*

* @description 对发送的信息进行json格式的封装

*

* @author yuanzi

* @time 2017年8月1日 下午3:13:30

*/

public class FastJsonMessageConverter extends AbstractMessageConverter {

public static final String DEFAULT_CHARSET = "UTF-8";

@SuppressWarnings("static-access")

@Override

protected Message createMessage(Object message, MessageProperties messageProperties) {

byte[] bytes = null;

JSONObject json = new JSONObject();

json.put("data", message);

try {

bytes = json.toString().getBytes(this.DEFAULT_CHARSET);

} catch (UnsupportedEncodingException e) {

throw new MessageConversionException("Failed to convert Message content:" + e);

}

if (bytes != null) {

messageProperties.setContentLength(bytes.length);

}

messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);

messageProperties.setContentEncoding(this.DEFAULT_CHARSET);

return new Message(bytes, messageProperties);

}

@Override

public Object fromMessage(Message message) throws MessageConversionException {

return null;

}

}

weixin_39729784
关注
RabbitMQ：SpringAMQP研究
流楚丶格念的博客
07-13 1478
SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。SpringAmqp的官方地址：https://spring.io/projects/spring-amqp 二话不说啊，翻译 AMQP（Advanced Message Queuing Protocol），是用于在应用程序之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求。 Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送
java mq 补偿_RabbitMQ整合Spring Booot【消费者补偿幂等问题】
weixin_35734408的博客
02-17 227
如果消费者 运行时候 报错了packagecom.toov5.msg.SMS;importorg.springframework.amqp.rabbit.annotation.RabbitHandler;importorg.springframework.amqp.rabbit.annotation.RabbitListener;importorg.springframework.stereoty...
rabbitmq.config
08-04
rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件
RabbitMQ基础教程之Spring&JavaConfig使用篇
小灰灰blog的专栏
06-01 776
RabbitMQ基础教程之Spring使用篇 相关博文，推荐查看: RabbitMq基础教程之安装与测试 RabbitMq基础教程之基本概念 RabbitMQ基础教程之基本使用篇 RabbitMQ基础教程之使用进阶篇 在实际的应用场景中，将RabbitMQ和Spring结合起来使用的时候可能更加频繁，网上关于Spring结合的博文中，大多都是xml的方式，这篇博文，则主要介绍下利用Jav...
RabbitMQ 最新版 安装，配置，java接入使用（详细教程）
最新发布
qyhua的专栏
08-22 1337
RabbitMQ 最新版 安装，配置，java接入使用（详细教程）
rabittmq java spring_RabbitMQ基础教程之Spring&JavaConfig使用篇
weixin_33352924的博客
02-21 227
RabbitMQ基础教程之Spring使用篇相关博文，推荐查看:在实际的应用场景中，将RabbitMQ和Spring结合起来使用的时候可能更加频繁，网上关于Spring结合的博文中，大多都是xml的方式，这篇博文，则主要介绍下利用JavaConfig的结合，又会是怎样的I. Spring中RabbitMQ的基本使用姿势1. 准备开始之前，首先添加上必要的依赖，主要利用 spring-rabbit ...
Spring 以JavaConfig的方式整合RabbitMQ
Coder_Joker的博客 joke a joker
05-24 1042
大体流程:    1.ConnectionFactory    2.配置RabbitTemplate    3.RabbitAdmin    4.声明Queue and Bind Queue with Exchange and RoutingKey    5.配置MessageListenerContainer具体详情:     1:@Bean public ConnectionFactory c...
rabittmq java spring_Java RabbitMQ配置和使用，基于SpringBoot
weixin_29433715的博客
02-21 180
package rabbitmq.demo;import com.rabbitmq.client.AMQP;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.amqp.core.AmqpAdmin;import org.springframework.amqp.core.Binding;...
详解Spring Boot 配置多个RabbitMQ
08-30
本文将详细介绍如何在 Spring Boot 中配置多个 RabbitMQ 实例。 配置多个 RabbitMQ 实例 为了配置多个 RabbitMQ 实例，我们需要在 application.properties 文件中添加相关的配置信息。例如： ``` spring.rabbitmq....
rabbitmq-advanced-spring-boot-starter：一个通用库，用于通过spring boot amqp上的扩展名与rabbit mq进行消息传递
01-30
Rabbitmq高级 用于通过RabbitMq（Spring Boot amqp的扩展）进行消息传递的通用库。 注意：如果您已经在使用Spring Cloud Stream，则可能不需要此... 您可以在“ rabbitmq.auto-config”下的application.yml中配置交换
spring-cloud-config + spring-cloud-bus-amqp实现分布式集群配置动态更新
08-05
总结来说，Spring Cloud Config 和 Spring Cloud Bus AMQP 的组合，借助于RabbitMQ，为我们提供了一个强大的分布式配置管理和动态更新机制。通过这种解决方案，我们可以高效地管理大规模微服务集群的配置，提高系统...
rabbitmq配置文件 rabbitmq.config
11-04
rabbitmq配置文件，用于rabbitmq管理
amqp的Java例子代码解析---生产者
phenixzhong的专栏
10-15 846
/**  * Licensed to the Apache Software Foundation (ASF) under one or more  * contributor license agreements.  See the NOTICE file distributed with  * this work for additional information regarding cop...
java中使用rabbitmq
zjg
03-10 2762
mq常用于业务解耦、流量削峰和异步通信,rabbitmq是使用范围较广,比较稳定的一款开源产品,接下来我们使用springboot的starter来引入rabbitmq,了解mq的几种使用模式,通过几个简单的案例，让你可以快速地了解到该使用哪种模式来对应业务场景，使用rabbitmq看这一篇就够了，下方附安装链接。回到顶部安装看这里官方文档官方网站其他项目，可参考官方案例路漫漫其修远兮，吾将上下而求索。
JAVA操控RabbitMQ
CV工程师呀
06-21 185
RabbitMQ基础操作方法
rabbitmq java 配置_RabbitMQ安装配置以及java的连接配置demo-Go语言中文社区
weixin_39870092的博客
02-25 430
一、在linux环境下安装1、安装Erlang环境(RabbitMQ需要Erlang环境支持)cd/usr/local/src/mkdirrabbitmqcdrabbitmqwgethttp://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpmrpm-Uvherlang-solutions-1.0-1.noa...
RabbitMQ基于Spring AMQP的Java Config 简单配置实例
weixin_34082789的博客
08-23 466
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ基础介绍与在java中使用-入门
热门推荐
T
02-03 7万+
前言：MQ做应用解耦，流量削峰 这些是常识，RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库 常用的主流的MQ有四个 ActiveMQ: Apache下的一个子项目。使用Java完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现，少量代码就可以高效地实现高级应用场景。可插拔的传输协议支持，比如：
SpringBoot与RabbitMQ实战配置与应用实例
文章的核心部分展示了两种配置RabbitMQ的方式：一种是基于JavaConfig，即通过自定义配置类来管理RabbitMQ的连接和消费者行为，这种方式便于模块化管理和扩展。另一种没有明确指出，但可以推测可能是基于XML配置或者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值