RabbitMQ在项目中的实用场景

一、结合properties文件 进行有关的配置Bean的配置

1.properties文件

spring.rabbitmq.host=localhost
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

2.config文件配置

@Configuration
@EnableConfigurationProperties(RabbitProperties.class)
public class RabbitMqConfig {
    @Autowired
    private RabbitProperties rabbitProperties;

    @Bean(name = "connectionFactory")
    @Primary
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setUsername(rabbitProperties.getUsername());
        connectionFactory.setPassword(rabbitProperties.getPassword());
        connectionFactory.setHost(rabbitProperties.getHost());
        connectionFactory.setPort(rabbitProperties.getPort());
        connectionFactory.setVirtualHost(rabbitProperties.getVirtualHost());
        connectionFactory.setPublisherConfirms(true);
        return connectionFactory;
    }

    @Bean(name = "amqpAdmin")
    public AmqpAdmin amqpAdmin(@Qualifier("rabbitConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }

    @Bean(name = "messageListenerContainer")
    @ConditionalOnBean(ChannelAwareMessageListener.class)
    public SimpleMessageListenerContainer messageContainer(@Qualifier("connectionFactory") ConnectionFactory connectionFactory,
               @Qualifier("messageListenerDispatcher") ChannelAwareMessageListener channelAwareMessageListener) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(20);
        container.setConcurrentConsumers(1);
        //设置确认模式
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        container.setMessageListener(channelAwareMessageListener);
        return container;
    }
}

3.抽象项目中需要使用到的几种队列 ，并分别用子类实现

public abstract class AbstractActivityQueue
{
    public abstract String name();

    public abstract String routeKey();

    public abstract ActivityType activityType();

    //可以加上配置的是否使用
}

//实现
public class EmailQueue extends AbstractActivityQueue
{
    @Override public String name()
    {
        return "Email";
    }

    @Override public String routeKey()
    {
        return "smarthmo.email";
    }

    @Override public ActivityType activityType()
    {
        return ActivityType.Email;
    }
}

public class TimerQueue extends AbstractActivityQueue
{
    @Override public String name()
    {
        return "Timer";
    }

    @Override public String routeKey()
    {
        return "smarthmo.Timer";
    }

    @Override public ActivityType activityType()
    {
        return ActivityType.Timer;
    }
}

//队列的集合
@Component
public class Queues
{

    private final Map<ActivityType, AbstractActivityQueue> queueMap = new HashMap<>();

    public Queues()
    {
        queueMap.put(ActivityType.Email, new EmailQueue());
        queueMap.put(ActivityType.Timer, new TimerQueue());
    }

    public AbstractActivityQueue getQueue(ActivityType activityType)
    {
        return queueMap.get(activityType);
    }

    public Collection<AbstractActivityQueue> getQueues()
    {
        return queueMap.values();
    }
}

4.创建与其中对应的exchange，queue，binding

/**
 * 创建exchange,queue,bind
 */
@Component
public class RabbitMQRunner
{
    @Autowired AmqpAdmin amqpAdmin;

    @Autowired Queues queues;
    
    //init方法中不能带有参数
    @PostConstruct
    public void init()
    {
        System.out.println("----begin----");
        Exchange exchange = ExchangeBuilder.directExchange("exchange").build();
        amqpAdmin.declareExchange(exchange);

        for (AbstractActivityQueue queue : queues.getQueues())
        {
            Queue queue1 = QueueBuilder.durable(queue.name()).build();
            amqpAdmin.declareQueue(queue1);
            Binding binding = BindingBuilder.bind(queue1).to(exchange).with(queue.routeKey()).noargs();
            amqpAdmin.declareBinding(binding);
        }
        System.out.println("----end----");

    }

}

5.创建不同队列对应的rabbitTmplate

@Component
public class RabbitTemplateFactory
{
    private Map<ActivityType, RabbitTemplate> templateMap = new HashMap<>();

    @Autowired ConnectionFactory connectionFactory;

    @Autowired Queues queues;

    public RabbitTemplate newTemplate(AbstractActivityQueue queue)
    {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        rabbitTemplate.setExchange("exchange");
        rabbitTemplate.setRoutingKey(queue.routeKey());
        return rabbitTemplate;
    }

    @PostConstruct
    public void init()
    {
        for (AbstractActivityQueue queue : queues.getQueues())
        {
            templateMap.put(queue.activityType(), newTemplate(queue));
        }

    }

    public RabbitTemplate getRabbitTemplate(ActivityType activityType)
    {
        return templateMap.get(activityType);
    }
}

6.在service中实现消息的监听消费

@RabbitListener(queues = "Email")
public void receiveEmail(Message message)
{
    System.out.println("execute receiveEmail..");
    System.out.println(new String(message.getBody()));
    System.out.println(message.getMessageProperties());
    
}

7.Test测试消息的发送

@SpringBootTest
@RunWith(SpringRunner.class)
public class DemoAmqpApplicationTest
{

    @Autowired RabbitTemplateFactory rabbitTemplateFactory;

    @Autowired AmqpAdmin amqpAdmin;

    @Test
    public void sendTest1()
    {
        //message 需要自己构建消息模型 定义消息体内容和消息头
        //rabbitTemplate.send(exchange,routeKey,message);

        //下面方法可以自己将对象转化为消息体 -使用的是默认的消息头，如果不需要定义头部就可以直接使用该方法
        // 被默认序列化以后发送出去
        //rabbitTemplate.convertAndSend(exchange,routeKey,object);
        RabbitTemplate rabbitEmail = rabbitTemplateFactory.getRabbitTemplate(ActivityType.Email);
        rabbitEmail.convertAndSend("xzw test rabbit mq");
    }

    @Test
    public void exchang1()
    {
        //通过amqp管理器创建交换器
        amqpAdmin.declareExchange(new DirectExchange("xx"));

        //创建消息队列
        amqpAdmin.declareQueue(new Queue("xxx", true));

        //创建绑定关系
        amqpAdmin.declareBinding(new Binding("xxx", Binding.DestinationType.QUEUE,"xx","cc",null));
    }

}