rabbit，springboot简单测试

rabbit 分布式消息中间件

1、pom文件

<dependency>
     <groupId>org.springframework.amqp</groupId>
     <artifactId>spring-rabbit</artifactId>
     <version>2.0.4.RELEASE</version>
</dependency>

2、application.yml配置

spring:
rabbitmq:
host: 172.25.241.65
port: 5672
virtual-host: /datashare
username: user_task
password: user_task
publisher-confirms: true # 消息发送到交换机确认机制,是否确认回调
publisher-returns: true # 消息发送到交换机确认机制,是否返回回调
listener:
simple:
acknowledge-mode: auto #自动应答
concurrency: 10 #并发消费者的初始化值
max-concurrency: 20 #并发消费者的最大值
prefetch: 5 #每个消费者每次监听时可拉取处理的消息数量
retry:
enabled: true #是否支持重试

3、RabbitConfig配置类

import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.DirectExchange;
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.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration
public class RabbitConfig {
@Value("$spring.rabbitmq.host")privateStringhost;@Value("${spring.rabbitmq.port}")
private int port;
@Value("$spring.rabbitmq.username")privateStringusername;@Value("${spring.rabbitmq.password}")
private String password;
@Value("${spring.rabbitmq.virtual-host}")
private String mqRabbitVirtualHost;

public static final String EXCHANGE_A = "exchange_task_calc_topica";


public static final String QUEUE_A = "queue_task_calca";

public static final String ROUTINGKEY_A = "key_calc_taska";
@Bean
public ConnectionFactory connectionFactory() {
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory(host,port);
    connectionFactory.setUsername(username);
    connectionFactory.setPassword(password);
    connectionFactory.setVirtualHost(mqRabbitVirtualHost);
    connectionFactory.setPublisherConfirms(true);
    return connectionFactory;
}

@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
//必须是prototype类型
public RabbitTemplate rabbitTemplate() {
    RabbitTemplate template = new RabbitTemplate(connectionFactory());
    return template;
}
/**
 * 针对消费者配置
 * 1. 设置交换机类型
 * 2. 将队列绑定到交换机
 FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念
 HeadersExchange ：通过添加属性key-value匹配
 DirectExchange:按照routingkey分发到指定队列
 TopicExchange:多关键字匹配
 */
@Bean
public DirectExchange defaultExchange() {
    return new DirectExchange(EXCHANGE_A);
}
/**
 * 获取队列A
 * @return
 */
@Bean
public Queue queueA() {
    return new Queue(QUEUE_A); //队列持久
}
@Bean
public Binding binding() {
    return BindingBuilder.bind(queueA()).to(defaultExchange()).with(RabbitConfig.ROUTINGKEY_A);
}

4、RabbitProducer

import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RabbitProducer implements RabbitTemplate.ConfirmCallback{

	private final Logger logger = LoggerFactory.getLogger(this.getClass());
	//由于rabbitTemplate的scope属性设置为ConfigurableBeanFactory.SCOPE_PROTOTYPE，所以不能自动注入

// private RabbitTemplate rabbitTemplate;
@Autowired
RabbitTemplate rabbitTemplate;
/**
* 构造方法注入rabbitTemplate
*/
@Autowired
public RabbitProducer(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
rabbitTemplate.setConfirmCallback(this); //rabbitTemplate如果为单例的话，那回调就是最后设置的内容
}
public void sendMsg(String content) {
CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
rabbitTemplate.convertAndSend(RabbitConfig.EXCHANGE_A, RabbitConfig.ROUTINGKEY_A, content, correlationId);
//把消息放入ROUTINGKEY_A对应的队列当中去，对应的是队列A
// this.rabbitTemplate.convertAndSend(“queue_task_calca”, content);
}
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
logger.info(" 回调id:" + correlationData);
if (ack) {
logger.info(“消息成功消费”);
} else {
logger.info(“消息消费失败:” + cause);
}
}
}

5、rabbitConsumer

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import com.test.kafkatest.config.RabbitConfig;

@Component

public class RabbitConsumer {
private final Logger logger = LoggerFactory.getLogger(this.getClass());

@RabbitListener(queues = RabbitConfig.QUEUE_A)
public void process(String content) {
    logger.info("接收处理队列A当中的消息： " + content);
}

}

6、测试controller

import javax.annotation.Resource;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.test.kafkatest.config.RabbitProducer;

@RestController
@RequestMapping(“hello”)
public class OneController {

 @Resource
 private RabbitProducer producer;
 
@RequestMapping("/message")
public void hello() {
	for (int i = 0; i < 10; i++) {
        this.producer.sendMsg("hellorabbit");
    }
}

}

7、输出结果