springboot整合rabbitmq

springboot整合rabbitmq

新建springboot项目，添加依赖

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

添加配置

spring:
  rabbitmq:
    host: 192.168.137.100
    port: 5672
    username: guest
    password: guest
    virtual-host: /mes

这样就可以用个了，这个配置和直接连接时是一样的

helloword（直连）

//使用springboot的测试类，然后注入RabbitTemplate模板类
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void helloWorldProvider(){
    rabbitTemplate.convertAndSend("hello","hhh");//给hello队列发送消息
}

@Component//交给spring容器管理
@RabbitListener(queuesToDeclare = @Queue("hello"))//监听hello队列,在@Queue中还有很多的参数，就是原来申明时的那些参数
public class Consumer {

    @RabbitHandler//接收到消息时的回调方法
    public void getMessage(String message){
        System.out.println(message);
    }
}

如果直接运行生产者，没有消费者的话，在web管理界面是看不到队列信息的，只有当消费者有了才会出现队列，也就是说是消费者创建的队列

work queue （任务）

//使用springboot的测试类，然后注入RabbitTemplate模板类
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void workProvider(){
    for (int i = 0; i < 5; i++) {
        rabbitTemplate.convertAndSend("work","这里是work模型"+i);//给work队列发送5条消息
    }
}

@Component("workConsumer")//前面定义了一个consumer，所以这里就另写一个
public class Consumer {

	@RabbitListener(queuesToDeclare = @Queue("work"))
	public void consumer1(String message){
		System.out.println("consumer1:"+message);
	}

	@RabbitListener(queuesToDeclare = @Queue("work"))
	public void consumer2(String message){
		System.out.println("consumer2:"+message);
	}
}
//平均分配
consumer1:这里是work模型0
consumer2:这里是work模型1
consumer1:这里是work模型2
consumer2:这里是work模型3

这种模型默认是轮询分发，如果有100条消息，消费者1需要消费50条，消费者2需要消费50条，如果消费者1处理任务时间太长，我们需要消费者2多处理一点，消费1少处理一点，能者多劳，可以添加吐下配置，设置为1后，会使用公平分发，也就是你现在空了就消费，没空我就不给你消息消费

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1

fanout （广播）

//使用springboot的测试类，然后注入RabbitTemplate模板类
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void fanoutProvider() {
	rabbitTemplate.convertAndSend("fanout", "", "这里是fanout模型");
}

@Component("fanoutConsumer")
public class Consumer {
	@RabbitListener(bindings = {
			@QueueBinding(value = @Queue,//直接使用@Queue就是创建的临时队列
					exchange = @Exchange(value = "fanout", type = "fanout"))
	})
	public void consumer1(String message) {
		System.out.println("consumer1"+message);
	}

	@RabbitListener(bindings = {
			@QueueBinding(value = @Queue,
					exchange = @Exchange(value = "fanout", type = "fanout"))
	})
	public void consumer2(String message) {
		System.out.println("consumer2"+message);
	}
}
consumer2这里是work模型
consumer1这里是work模型

Routing （路由）

//使用springboot的测试类，然后注入RabbitTemplate模板类
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void routingProvider() {
	rabbitTemplate.convertAndSend("routing", "red", "这里是routing模型");
}

@Component("routingConsumer")
public class Consumer {
	@RabbitListener(bindings = {
			@QueueBinding(value = @Queue,
					exchange = @Exchange(value = "routing",type = "direct"),
					key = {"red","green","blue"})
	})
	public void consumer1(String message) {
		System.out.println("consumer1"+message);
	}


	@RabbitListener(bindings = {
			@QueueBinding(value = @Queue,
					exchange = @Exchange(value = "routing",type = "direct"),
					key = {"red","green"})
	})
	public void consumer2(String message) {
		System.out.println("consumer2"+message);
	}

	@RabbitListener(bindings = {
			@QueueBinding(value = @Queue,
					exchange = @Exchange(value = "routing",type = "direct"),
					key = {"green","blue"})
	})
	public void consumer3(String message) {
		System.out.println("consumer3"+message);
	}
	
	@RabbitListener(bindings = {
			@QueueBinding(value = @Queue,
					exchange = @Exchange(value = "routing",type = "direct"),
					key = {"green","blue"})
	})
	public void consumer4(String message) {
		System.out.println("consumer4"+message);
	}
}
red
consumer4这里是routing模型
consumer2这里是routing模型
consumer1这里是routing模型
----
green
consumer3这里是routing模型
consumer1这里是routing模型
consumer2这里是routing模型
----
blue
consumer1这里是routing模型
consumer3这里是routing模型
consumer4这里是routing模型

Topics （动态路由）

//使用springboot的测试类，然后注入RabbitTemplate模板类
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void topicProvider() {
	rabbitTemplate.convertAndSend("topic", "red.green.blue", "这里是topic模型");
}

@Component("topicConsumer")
public class Consumer {
	@RabbitListener(bindings = @QueueBinding(value = @Queue,
			exchange = @Exchange(value = "topic", type = "topic"),
			key ={"red.*.blue"}))
	public void consumer1(String message) {
		System.out.println("consumer1"+message);
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue,
			exchange = @Exchange(value = "topic", type = "topic"),
			key ={"red.#"}))
	public void consumer2(String message) {
		System.out.println("consumer2"+message);
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue,
			exchange = @Exchange(value = "topic", type = "topic"),
			key ={"#.blue"}))
	public void consumer3(String message) {
		System.out.println("consumer3"+message);
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue,
			exchange = @Exchange(value = "topic", type = "topic"),
			key ={"*.green.blue"}))
	public void consumer4(String message) {
		System.out.println("consumer4"+message);
	}
}
red.green.blue
consumer4这里是topic模型
consumer1这里是topic模型
consumer3这里是topic模型
consumer2这里是topic模型
----
red.green
consumer2这里是topic模型
----
green.blue
consumer3这里是topic模型

*:代表一个单词，可以为任何单词，但是不能为空，不然匹配不到
#:代表任何，可以有，可以没有，也就是代表0到多个单词