rabbit安裝及使用

三、RibbitMQ
1、解压缩：tar -xvf otp_src_19.3.tar.gz

2、重命名文件夹为erlang：mv otp_src_19.3 ./erlang

3、配置安装 ：cd erlang
./configure --prefix=/usr/erlang --without-javac

4、对源代码进行编译，运行如下命令：make

5、开始安装： make install

6、运行以下命令编辑/etc/profile文件:vim /etc/profile
export PATH=$PATH:/usr/erlang/bin

7、保存，然后运行以下命令使环境变量立即生效：source /etc/profile

8、验证erlang是否安装成功： erl

开始安装rabbitMQ
9、 解压xxx.xz 后缀文件：xz -d xxxx.xz

10、解压xxx.tar后缀文件：tar -xf xxxx.tar

11、安装mq需要插件
安装python
yum install python -y

安装simpleJson
yum install xmlto -y
yum install python-simplejson -y

12、移动并命名：mv rabbit-server /usr/rabbitmq
vim /etc/profile
export PATH=$PATH:/usr/erlang/bin:$PATH:/usr/rabbitmq/sbin
source /etc/profile
13、启动服务5672服务 cd rabbitmq/sbin :rabbitmq-sever

14、rabbitmqctl stop 停止服务

15、 Possibly caused by authentication failure解决方案
在远程机器上安装上RabbitMQ后，然后会一直出现认证失败的错误，即Possibly caused by authentication failure。此错误的导致原因是账号密码错误。官网上给的例子都是在本地使用系统默认的guest用户连接的，而没有给出远程连接的例子。对于这个guest用户是刚刚安装好rabbitmq-server时候，系统自动创建的一个名为“/”的virtual host，同时也会创建一个用户名和密码都是guest的用户，并且拥有“/ virtual host”的所有访问权限。并且此guest只是允许从localhost访问。所以在本机上运行官方示例是没问题的，一旦切换到远程机器访问的话，单纯的修改localhost字段是不行的。
这里的解决办法是新建一个对rabbitmq具有所有权限的用户，然后用此用户的信息进行远程访问。
解决办法如下：
(1)添加新用户：rabbitmqctl add_user root 123456

(2)赋administrator权限：rabbitmqctl set_user_tags root administrator

(3)设置ip： rabbitmqctl set_permissions -p / root ".*" ".*" ".*"

 1.pom.xml

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

2.application.properties

#rabbitmq
spring.rabbitmq.host=192.168.146.130
spring.rabbitmq.port=5672
spring.rabbitmq.username=root
spring.rabbitmq.password=123456

spring.rabbitmq.virtual-host=/
#消费者数量
spring.rabbitmq.listener.simple.concurrency= 10
spring.rabbitmq.listener.simple.max-concurrency= 10
#消费者每次从队列获取的消息数量
spring.rabbitmq.listener.simple.prefetch= 1
#消费者自动启动
spring.rabbitmq.listener.simple.auto-startup=true
#消费失败，自动重新入队
spring.rabbitmq.listener.simple.default-requeue-rejected= true
#启用发送重试
spring.rabbitmq.template.retry.enabled=true
spring.rabbitmq.template.retry.initial-interval=1000
spring.rabbitmq.template.retry.max-attempts=3
spring.rabbitmq.template.retry.max-interval=10000
spring.rabbitmq.template.retry.multiplier=1.0

4.

package com.imooc.miaosha.rabbitmq;

import java.util.HashMap;
import java.util.Map;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.HeadersExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MQConfig {

public static final String MIAOSHA_QUEUE = "miaosha.queue";
public static final String QUEUE = "queue";
public static final String TOPIC_QUEUE1 = "topic.queue1";
public static final String TOPIC_QUEUE2 = "topic.queue2";
public static final String HEADER_QUEUE = "header.queue";
public static final String TOPIC_EXCHANGE = "topicExchage";
public static final String FANOUT_EXCHANGE = "fanoutxchage";
public static final String HEADERS_EXCHANGE = "headersExchage";

/**
* Direct模式 交换机Exchange
* */
@Bean
public Queue queue() {
return new Queue(MIAOSHA_QUEUE, true);
}

/**
* Topic模式 交换机Exchange
* */
@Bean
public Queue topicQueue1() {
return new Queue(TOPIC_QUEUE1, true);
}
@Bean
public Queue topicQueue2() {
return new Queue(TOPIC_QUEUE2, true);
}
@Bean
public TopicExchange topicExchage(){
return new TopicExchange(TOPIC_EXCHANGE);
}
@Bean
public Binding topicBinding1() {
return BindingBuilder.bind(topicQueue1()).to(topicExchage()).with("topic.key1");
}
@Bean
public Binding topicBinding2() {
return BindingBuilder.bind(topicQueue2()).to(topicExchage()).with("topic.#");
}
/**
* Fanout模式 交换机Exchange
* */
@Bean
public FanoutExchange fanoutExchage(){
return new FanoutExchange(FANOUT_EXCHANGE);
}
@Bean
public Binding FanoutBinding1() {
return BindingBuilder.bind(topicQueue1()).to(fanoutExchage());
}
@Bean
public Binding FanoutBinding2() {
return BindingBuilder.bind(topicQueue2()).to(fanoutExchage());
}
/**
* Header模式 交换机Exchange
* */
@Bean
public HeadersExchange headersExchage(){
return new HeadersExchange(HEADERS_EXCHANGE);
}
@Bean
public Queue headerQueue1() {
return new Queue(HEADER_QUEUE, true);
}
@Bean
public Binding headerBinding() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("header1", "value1");
map.put("header2", "value2");
return BindingBuilder.bind(headerQueue1()).to(headersExchage()).whereAll(map).match();
}


}

5入隊

package com.imooc.miaosha.rabbitmq;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.imooc.miaosha.redis.RedisService;

@Service
public class MQSender {

private static Logger log = LoggerFactory.getLogger(MQSender.class);

@Autowired
AmqpTemplate amqpTemplate ;

public void sendMiaoshaMessage(MiaoshaMessage mm) {
String msg = RedisService.beanToString(mm);
log.info("send message:"+msg);
amqpTemplate.convertAndSend(MQConfig.MIAOSHA_QUEUE, msg);
}

// public void send(Object message) {
// String msg = RedisService.beanToString(message);
// log.info("send message:"+msg);
// amqpTemplate.convertAndSend(MQConfig.QUEUE, msg);
// }
//
// public void sendTopic(Object message) {
// String msg = RedisService.beanToString(message);
// log.info("send topic message:"+msg);
// amqpTemplate.convertAndSend(MQConfig.TOPIC_EXCHANGE, "topic.key1", msg+"1");
// amqpTemplate.convertAndSend(MQConfig.TOPIC_EXCHANGE, "topic.key2", msg+"2");
// }
//
// public void sendFanout(Object message) {
// String msg = RedisService.beanToString(message);
// log.info("send fanout message:"+msg);
// amqpTemplate.convertAndSend(MQConfig.FANOUT_EXCHANGE, "", msg);
// }
//
// public void sendHeader(Object message) {
// String msg = RedisService.beanToString(message);
// log.info("send fanout message:"+msg);
// MessageProperties properties = new MessageProperties();
// properties.setHeader("header1", "value1");
// properties.setHeader("header2", "value2");
// Message obj = new Message(msg.getBytes(), properties);
// amqpTemplate.convertAndSend(MQConfig.HEADERS_EXCHANGE, "", obj);
// }

}

6.接受

package com.imooc.miaosha.rabbitmq;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.imooc.miaosha.domain.MiaoshaOrder;
import com.imooc.miaosha.domain.MiaoshaUser;
import com.imooc.miaosha.redis.RedisService;
import com.imooc.miaosha.service.GoodsService;
import com.imooc.miaosha.service.MiaoshaService;
import com.imooc.miaosha.service.OrderService;
import com.imooc.miaosha.vo.GoodsVo;

@Service
public class MQReceiver {

private static Logger log = LoggerFactory.getLogger(MQReceiver.class);

@Autowired
RedisService redisService;

@Autowired
GoodsService goodsService;

@Autowired
OrderService orderService;

@Autowired
MiaoshaService miaoshaService;

@RabbitListener(queues=MQConfig.MIAOSHA_QUEUE)
public void receive(String message) {
log.info("receive message:"+message);
MiaoshaMessage mm = RedisService.stringToBean(message, MiaoshaMessage.class);
MiaoshaUser user = mm.getUser();
long goodsId = mm.getGoodsId();

GoodsVo goods = goodsService.getGoodsVoByGoodsId(goodsId);
int stock = goods.getStockCount();
if(stock <= 0) {
return;
}
//判断是否已经秒杀到了
MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(user.getId(), goodsId);
if(order != null) {
return;
}
//减库存 下订单 写入秒杀订单
miaoshaService.miaosha(user, goods);
}

// @RabbitListener(queues=MQConfig.QUEUE)
// public void receive(String message) {
// log.info("receive message:"+message);
// }
//
// @RabbitListener(queues=MQConfig.TOPIC_QUEUE1)
// public void receiveTopic1(String message) {
// log.info(" topic queue1 message:"+message);
// }
//
// @RabbitListener(queues=MQConfig.TOPIC_QUEUE2)
// public void receiveTopic2(String message) {
// log.info(" topic queue2 message:"+message);
// }
//
// @RabbitListener(queues=MQConfig.HEADER_QUEUE)
// public void receiveHeaderQueue(byte[] message) {
// log.info(" header queue message:"+new String(message));
// }
//

}