windows安装RabbitMQ&springboot集成RabbitMQ--记录

一、安装RabbitMQ

注意：
1、RabbitMQ官网下载址：http://www.rabbitmq.com/install-windows.html
2、RabbitMq是用Erlang编程语言进行开发，所以先要安装Erlang语言开发包
3、RabbitMq和Erlang版本必须对应，查看版本对应地址：https://www.rabbitmq.com/which-erlang.html

1、安装Erlang
双击下载好的Erlang运行程序，比如这里的otp_win64_21.0.1.exe，全部点击“下一步”即可完成安装；
配置环境变量，ERLANG_HOME，添加到PATH %ERLANG_HOME%\bin;
验证是否安装成功，在命令运行窗口中输入：erl回车，看到版本号即可代表安装成功。

2、安装RabbitMq
双击下载好的RabbitMQ运行程序，比如这里的rabbitmq-server-3.7.8.exe，全部点击“下一步”即可完成安；
配置环境变量，RABBITMQ_SERVER，添加到PATH %RABBITMQ_SERVER%\sbin;
需要注意：默认安装的RabbitMQ 监听端口是5672。

3、安装管理工具RabbitMQ-Plugins
在命令窗口中切换到此次MQ的安装目录下的sbin，运行命令：rabbitmq-plugins enable rabbitmq_management即可完成插件安装；
此时可以通过访问http://localhost:15672进行测试，默认的登陆账号为：guest，密码为：guest。

4、新增用户后需要进入MQ安装目录sbin运行 rabbitmqctl set_permissions -p / admin ".*" ".*" ".*" 命令赋权。

二、springboot集成RabbitMQ

1、pom.xml引入jar包

<!--rabbitmq -->
<dependency>
    <groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2、生产者

	@Autowired
	private AmqpTemplate amqpTemplate;

	@RequestMapping("/rabbitmqSend")
	@ResponseBody
	public String rabbitmqSend(@RequestParam HashMap<String, String> paramMap) {
		String ch = paramMap.get("ch");
		String key = paramMap.get("key");
		String ms = paramMap.get("ms");

		if (ch != null && !ch.equals("")) {
			// 广播模式，一个消息被多个消费都消费，必须带上cxchange值，routingKey可有可无，消费者必须是fanout模式
			amqpTemplate.convertAndSend(ch, key, ms);
		} else {
			// 普通模式，一个消息只能被一个消息者消费，也可以带上cxchange值，但是消费者必须是Direct模式或者默认模式
			amqpTemplate.convertAndSend(key, ms);
		}

		return ms;
	}

	@RequestMapping("/rabbitmqSendObj")
	@ResponseBody
	public String rabbitmqSendObj(@RequestParam HashMap<String, String> paramMap) {
        // 发送对象
		User user = new User();
		user.setName("刘德华");
		user.setAge(66);

		amqpTemplate.convertAndSend("user.obj", user);

		return user.toString();
	}

3、消费者

package com.example.demo.rabbitmq;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import com.example.demo.bean.UserTest;

@Component
public class MqReceiver {
	// 1、不会自动创建队列，无队列时会报错
	// @RabbitListener(queues = "myQueue")
	// 2、自动创建队列
	// @RabbitListener(queuesToDeclare = @Queue("myQueue"))
	// 3、自动创建，Exchange和queue绑定

	// 测试广播模式（注意：不能填写Queue的value值，否则会默认变成DIRECT模式）
	@RabbitListener(bindings = @QueueBinding(value = @Queue(value = "", autoDelete = "false"), exchange = @Exchange(value = "fanoutExChange", type = ExchangeTypes.FANOUT)))
	public void process1(String message) {
		System.out.println("============广播接收者1");
		System.out.println(message);
		System.out.println("============");
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue(value = "", autoDelete = "false"), exchange = @Exchange(value = "fanoutExChange", type = ExchangeTypes.FANOUT)))
	public void process2(String message) {
		System.out.println("============广播接收者2");
		System.out.println(message);
		System.out.println("============");
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue(value = "", autoDelete = "false"), exchange = @Exchange(value = "fanoutExChange", type = ExchangeTypes.FANOUT)))
	public void process3(String message) {
		System.out.println("============广播接收者3");
		System.out.println(message);
		System.out.println("============");
	}

	// 测试普通模式
	@RabbitListener(bindings = @QueueBinding(value = @Queue("myQueue"), exchange = @Exchange("myExChange"), key = "myQueue"))
	public void ordinary1(String message) {
		System.out.println("============普通接收者1");
		System.out.println(message);
		System.out.println("============");
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue("myQueue"), exchange = @Exchange("myExChange"), key = "myQueue"))
	public void ordinar2(String message) {
		System.out.println("============普通接收者2");
		System.out.println(message);
		System.out.println("============");
	}

	// 测试接受实体类
	@RabbitListener(queues = "user.obj")
	public void receivObj(User user) {
		System.out.println("============bean接收者");
		System.out.println(user.getName());
		System.out.println(user.getAge());
		System.out.println("============");
	}
}

4、生产者和消费者如果需要发送和接收实体类，被发送和接受的实体类必须实现序列化的接口

public class User implements Serializable {
	private static final long serialVersionUID = 1L;
    ...
}

5、生产者发送实体类配置

package com.example.demo.rabbitmq;

import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/*
 * 定义发送类型为json格式
 */

@Configuration
public class RabbitConfig {

	@Bean
	public RabbitTemplate rabbitTemplate(final ConnectionFactory connectionFactory) {
		final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
		rabbitTemplate.setMessageConverter(producerJackson2MessageConverter());
		return rabbitTemplate;
	}

	@Bean
	public Jackson2JsonMessageConverter producerJackson2MessageConverter() {
		return new Jackson2JsonMessageConverter();
	}
}

6、消费者接收实体类配置

package com.example.demo.rabbitmq;

import org.springframework.amqp.rabbit.annotation.RabbitListenerConfigurer;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory;

/*
 * 定义接收类型为json格式
 */

@Configuration
public class RabbitListenerConfig implements RabbitListenerConfigurer {

	@Override
	public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
		registrar.setMessageHandlerMethodFactory(messageHandlerMethodFactory());
	}

	@Bean
	MessageHandlerMethodFactory messageHandlerMethodFactory() {
		DefaultMessageHandlerMethodFactory messageHandlerMethodFactory = new DefaultMessageHandlerMethodFactory();
		messageHandlerMethodFactory.setMessageConverter(consumerJackson2MessageConverter());
		return messageHandlerMethodFactory;
	}

	@Bean
	public MappingJackson2MessageConverter consumerJackson2MessageConverter() {
		return new MappingJackson2MessageConverter();
	}
}