Spring cloud集成Rabbitmq_springcloud整合rabbitmq

1、配置pom

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

2、yml配置

spring:
   #rabbit mq
   rabbitmq:

     host: 192.168.1.146
     port: 5672
     username: guest
     password: guest

3、连接、交换器、队列等设置

@Configuration
public class RabbitMqConfig {
 
	/**
	 * 组件发布EXCHANGE
	 */
	public static final String EXCHANGE_COMPONENT_PUBLISHED="exchange.component.published";
	public static final String EXCHANGE_COMPONENT_SYNCED="exchange.component.synced";
 
	public static final String EXCHANGE_EXTRACTION_TASK="exchange.extraction.task";
 
 
 
	/**
	 * 组件发布消息队列
	 */
	public static final String QUEUE_COMPONENT_PUBLISHED="queue.component.published";
 
	public static final String QUEUE_COMPONENT_SYNCED="queue.component.synced";
 
	public static final String QUEUE_EXTRACTION_TASK="queue.extraction.task";
 
 
	public static final String ROUTING_KEY_="";
 
 
	@Value("${spring.rabbitmq.host}")
	private String host;
	@Value("${spring.rabbitmq.port}")
	private int port;
 
	@Value("${spring.rabbitmq.username}")
	private String username;
	@Value("${spring.rabbitmq.password}")
	private String password;
 
 
 
 
	@Bean
	public ConnectionFactory connectionFactory() {
		CachingConnectionFactory connectionFactory = new CachingConnectionFactory(host,port);
		connectionFactory.setUsername(username);
		connectionFactory.setPassword(password);
		connectionFactory.setVirtualHost("/");
		connectionFactory.setPublisherConfirms(true);
		return connectionFactory;
	}
 
	@Bean
	public RabbitListenerContainerFactory<?> rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
		SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
		factory.setConnectionFactory(connectionFactory);
		factory.setMessageConverter(new Jackson2JsonMessageConverter());
		return factory;
	}
 
 
	/**
	 *
	 * @return
	 */
	@Bean
	public FanoutExchange exchangeComponentPublished()
	{
		return  new FanoutExchange(EXCHANGE_COMPONENT_PUBLISHED);
 
	}
 
	@Bean
	public Queue queueComponentPublished()
	{
		return  new Queue(QUEUE_COMPONENT_PUBLISHED,false);
	}
 
	@Bean
	public FanoutExchange exchangeComponentSynced()
	{
		return  new FanoutExchange(EXCHANGE_COMPONENT_SYNCED);
 
	}
 
	@Bean
	public FanoutExchange exchangeExtractionTask()
	{
		return  new FanoutExchange(EXCHANGE_EXTRACTION_TASK);
 
	}
 
	@Bean
	public Queue queueComponentSynced()
	{
		return  new Queue(QUEUE_COMPONENT_SYNCED,false);
	}
 
 
	@Bean
	public Queue queueExtractionTask()
	{
		return  new Queue(QUEUE_EXTRACTION_TASK,false);
	}
 
 
	@Bean
	public Binding componentSyncedBinding(){
		return BindingBuilder.bind(queueComponentSynced()).to(exchangeComponentSynced());
	}
 
	@Bean
	public Binding extractionTaskBinding(){
		return BindingBuilder.bind(queueExtractionTask()).to(exchangeExtractionTask());
	}
 
 
	@Bean
	public RabbitTemplate rabbitTemplate(ConnectionFactory factory){
 
		RabbitTemplate rabbitTemplate = new RabbitTemplate(factory);
 
		return rabbitTemplate;
	}
 
 
}

需要定义交换器，队列，绑定，会自动注册。

4、生产者

 
@Component
public class ExtractionTaskMessageSender {
 
	@Autowired
	private RabbitTemplate rabbitTemplate;
 
	public void send(ExtractionTaskMessage msg)
	{
 
		rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
 
 
		ObjectMapper mapper = new ObjectMapper();
 
		Message m = null;
		try {
 
			m = MessageBuilder.withBody(mapper.writeValueAsBytes(msg)).setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT).setContentType(MessageProperties.CONTENT_TYPE_JSON).build();
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
 
		rabbitTemplate.convertAndSend(RabbitMqConfig.EXCHANGE_EXTRACTION_TASK,"",msg);
 
 
	}
}

使用RabbitTemplate发送消息。

5、消费者

 
@Component
@RabbitListener(queues = RabbitMqConfig.QUEUE_EXTRACTION_TASK)
public class ExtractionTaskMessageReceiver {
 
	private static Logger logger = LoggerFactory.getLogger(ExtractionTaskMessageReceiver.class);
 
	@Autowired
	private DataExtractorFactory dataExtractorFactory;
 
	@Autowired
	private ExtractionTaskService extractionTaskService;
 
	@Autowired
	private ExtractionDataService extractionDataService;
 
 
	@RabbitHandler
	public void process(@Payload ExtractionTaskMessage msg) {
		try {
			
 
		} catch (DataExtractionException e)
		{
			logger.error( "",e.getMessage());
		}
		catch (Exception e) {
			//异常处理
			logger.error(e.getMessage());
		}
	}
 
}

使用 @RabbitListener 进行监听，@RabbitHandler定义消息处理方法。

在进行监听时，会查询所有@RabbitHandler注解的消息处理方法，如果没有参数类型匹配的方法，则异常。

@RabbitListener 注意

• 消息处理方法参数是由 MessageConverter 转化，若使用自定义 MessageConverter 则需要在 RabbitListenerContainerFactory 实例中去设置（默认 Spring 使用的实现是 SimpleRabbitListenerContainerFactory）

• 消息的 content_type 属性表示消息 body 数据以什么数据格式存储，接收消息除了使用 Message 对象接收消息（包含消息属性等信息）之外，还可直接使用对应类型接收消息 body 内容，但若方法参数类型不正确会抛异常：

  • application/octet-stream：二进制字节数组存储，使用 byte[]
  • application/x-java-serialized-object：java 对象序列化格式存储。使用 Object、相应类型（反序列化时类型应该同包同名，否者会抛出找不到类异常）
  • text/plain：文本数据类型存储。使用 String
  • application/json：JSON 格式。使用 Object、相应类型

注意：@RabbitListener注解在类上或方法上，行为不一样。在类上，消费方法参数类型不可以设置为Message。在方法上，方法类型可以为Message

MessageConvert

• 涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte[] 数组的解析
• RabbitMQ 的序列化是指 Message 的 body 属性，即我们真正需要传输的内容，RabbitMQ 抽象出一个 MessageConvert 接口处理消息的序列化，其实现有 SimpleMessageConverter（默认）、Jackson2JsonMessageConverter 等
• 当调用了 convertAndSend 方法时会使用 MessageConvert 进行消息的序列化
• SimpleMessageConverter 对于要发送的消息体 body 为 byte[] 时不进行处理，如果是 String 则转成字节数组,如果是 Java 对象，则使用 jdk 序列化将消息转成字节数组，转出来的结果较大，含class类名，类相应方法等信息。因此性能较差
• 当使用 RabbitMQ 作为中间件时，数据量比较大，此时就要考虑使用类似 Jackson2JsonMessageConverter 等序列化形式以此提高性能

设置MessageConvert

Json格式

    public RabbitListenerContainerFactory<?> rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        return factory;
    }

 自定义

    public RabbitListenerContainerFactory<?> rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new MessageConverter() {
            @Override
            public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException {
                return null;
            }
 
            @Override
            public Object fromMessage(Message message) throws MessageConversionException {
                try(ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(message.getBody()))){
                    return (User)ois.readObject();
                }catch (Exception e){
                    e.printStackTrace();
                    return null;
                }
            }
        });
 
        return factory;
    }

@Payload 与 @Headers

• 使用 @Payload 和 @Headers 注解可以消息中的 body 与 headers 信息

@RabbitListener(queues = "debug")
public void processMessage1(@Payload String body, @Headers Map<String,Object> headers) {
    System.out.println("body："+body);
    System.out.println("Headers："+headers);
}

• 也可以获取单个 Header 属性

@RabbitListener(queues = "debug")
public void processMessage1(@Payload String body, @Header String token) {
    System.out.println("body："+body);
    System.out.println("token："+token);
}
 

通过 @RabbitListener 注解声明 Binding

• 通过 @RabbitListener 的 bindings 属性声明 Binding（若 RabbitMQ 中不存在该绑定所需要的 Queue、Exchange、RouteKey 则自动创建，若存在则抛出异常）

@RabbitListener(bindings = @QueueBinding(
        exchange = @Exchange(value = "topic.exchange",durable = "true",type = "topic"),
        value = @Queue(value = "consumer_queue",durable = "true"),
        key = "key.#"
))
public void processMessage1(Message message) {
    System.out.println(message);
}

@RabbitListener 和 @RabbitHandler 搭配使用

• @RabbitListener 可以标注在类上面，需配合 @RabbitHandler 注解一起使用
• @RabbitListener 标注在类上面表示当有收到消息的时候，就交给 @RabbitHandler 的方法处理，具体使用哪个方法处理，根据 MessageConverter 转换后的参数类型

@Component
@RabbitListener(queues = "consumer_queue")
public class Receiver {
 
    @RabbitHandler
    public void processMessage1(String message) {
        System.out.println(message);
    }
 
    @RabbitHandler
    public void processMessage2(byte[] message) {
        System.out.println(new String(message));
    }
    
}