<二>spring spring boot集成rabbitmq

Spring 集成rabbbitmq

1创建工程

2引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.boxuegu</groupId>
    <artifactId>springboot_rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_rabbitmq</name>
    <description>springboot_rabbitmq</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3编写代码

image.png
RabbitConfig.java

package com.boxuegu.config;

import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:rabbitmq.properties")
public class RabbitConfig {

    @Value("${rabbit.host}")
    private String host;
    @Value("${rabbit.port}")
    private int port;
    @Value("${rabbit.username}")
    private String username;
    @Value("${rabbit.password}")
    private String password;
    @Value("${rabbit.virtualHost}")
    private String virtualHost;

    /**
     * 创建连接工厂
     */
    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(this.host);
        connectionFactory.setPort(this.port);
        connectionFactory.setUsername(this.username);
        connectionFactory.setPassword(this.password);
        connectionFactory.setVirtualHost(this.virtualHost);
        return connectionFactory;
    }

    /**
     * RabbitAdmin 封装了对RabbitMQ的管理操作
     *
     * @param connectionFactory
     * @return
     */
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        // 声明交换机
        /**
           交换机名
           是否可以持久化
           无队列绑定的时候是否删除
        **/
        TopicExchange topicExchange = new TopicExchange("spring_topic_exchange", true, false);
        rabbitAdmin.declareExchange(topicExchange);
        // 声明队列
        Queue spring_error_queue = new Queue("spring_error_queue", true, false, false, null);
        Queue spring_log_queue = new Queue("spring_log_queue", true, false, false, null);
        rabbitAdmin.declareQueue(spring_error_queue);
        rabbitAdmin.declareQueue(spring_log_queue);
        // 绑定操作
        rabbitAdmin.declareBinding(BindingBuilder.bind(spring_error_queue).to(topicExchange).with("log.#.error"));
        rabbitAdmin.declareBinding(BindingBuilder.bind(spring_log_queue).to(topicExchange).with("log.*"));
        return rabbitAdmin;
    }

    /**
     * RabbitTemplate作用简化RabbitMQ发送与接收消息的步骤
     * @return
     */
    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(this.connectionFactory());
        return rabbitTemplate;
    }

}

SpringConfig.java

package com.boxuegu.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * 配置类 -- 用来替代xml配置文件的
 */
@Configuration
@ComponentScan(basePackages = {"com.boxuegu"})
public class SpringConfig {

}

Consumer_log.java

package com.boxuegu.test;

import com.boxuegu.config.RabbitConfig;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class Consumer_log {
    @Autowired
    RabbitConfig rabbitConfig;

    @Bean
    public SimpleMessageListenerContainer messageListenerContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(rabbitConfig.connectionFactory());
        //设置监听的队列
        container.setQueueNames("spring_error_queue", "spring_log_queue");
        container.setMessageListener(new ChannelAwareMessageListener() {
            public void onMessage(Message message, Channel channel) throws Exception {
                // 获得队列的名称
                String consumerQueue = message.getMessageProperties().getConsumerQueue();
                if (consumerQueue.contains("error")) {
                    System.err.println("error级别的日志:" + new String(message.getBody()));
                }
                if (consumerQueue.contains("log")) {
                    System.out.println("log级别的日志:" + new String(message.getBody()));
                }
            }
        });
        return container;
    }
}

Producer_test.java

package com.boxuegu.test;

import com.boxuegu.config.SpringConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(value = SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class Producer_test {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sendMessage() {
        /**
            交换机名
            路由名
            消息
        **/
        rabbitTemplate.convertAndSend("spring_topic_exchange", "log.error", "这是一个错误的信息.");
    }


    @Test
    public void receiveMessage() {
        // 监听队列
        Message message = rabbitTemplate.receive("spring_log_queue");
        // 获取消息
        System.out.println(new String(message.getBody()));
    }

    @Test
    public void test() {
        while (true) {

        }
    }

}

rabbitmq.properties

## 主机地址
rabbit.host=localhost
## 用户名
rabbit.username=guest
## 密码
rabbit.password=guest
## 端口号
rabbit.port=5672
## 虚拟主机
rabbit.virtualHost=/

碰到一下错误在setting中搜java compile
未覆盖org.springframework.amqp.core.MessageListener中的抽象方法onMessage(org.springframework.amqp.core.Message)
image.png
image.png

总结

image.png
image.png

Spring Boot集成rabbitmq

1引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.boxuegu</groupId>
    <artifactId>springboot_rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_rabbitmq</name>
    <description>springboot_rabbitmq</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件

application.properties

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

交换机 队列 绑定

RabbitConfig.java

package com.boxuegu.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    /**
     * 声明交换机
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("springboot_topic_exchange", true, false);
    }

    /**
     * 声明交换机
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("springboot_fanout_exchange", true, false);
    }

    /**
     * 声明队列
     */
    @Bean
    public Queue error_queue() {
        return new Queue("springboot_error_queue", true, false, false, null);
    }

    @Bean
    public Queue log_queue() {
        return new Queue("springboot_log_queue", true, false, false, null);
    }

    @Bean
    public Queue user_queue() {
        return new Queue("springboot_user_queue", true, false, false, null);
    }

    /**
     * 绑定
     */
    @Bean
    public Binding binding_error() {
        return BindingBuilder.bind(this.error_queue()).to(this.topicExchange()).with("log.#.error");
    }

    @Bean
    public Binding binding_log() {
        return BindingBuilder.bind(this.log_queue()).to(this.topicExchange()).with("log.*");
    }

    @Bean
    public Binding binding_user() {
        return BindingBuilder.bind(this.user_queue()).to(this.fanoutExchange());
    }

}

生产者

package com.boxuegu.test;

import com.boxuegu.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * 生产者
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class Producer {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sendMessage() {
        Map map = new HashMap();
        map.put("error", "这是一个错误的信息");
        rabbitTemplate.convertAndSend("springboot_topic_exchange", "log.error",
                map);
    }

    @Test
    public void sendMessageUser() {
        User user = new User();
        user.setUsername("zhangsan");
        user.setPassword("123456");
        rabbitTemplate.convertAndSend("springboot_fanout_exchange", "",
                user);
    }
}

消费者

package com.boxuegu.test;

import com.boxuegu.domain.User;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 消费者
 */
@Component
public class Consumer {


    @RabbitListener(queues = {"springboot_error_queue", "springboot_log_queue"})
    public void receive(Map map, Message message, Channel channel) {
        //队列的名称
        String consumerQueue = message.getMessageProperties().getConsumerQueue();

        if (consumerQueue.contains("error")) {
            System.err.println("错误日志:" + map);
        }

        if (consumerQueue.contains("log")) {
            System.out.println("日志:" + map);
        }
    }

    @RabbitListener(queues = {"springboot_user_queue"})
    public void receiveUser(User user, Message message, Channel channel) {
        System.out.println("消费者:" + user);
    }
}

User

package com.boxuegu.domain;

import java.io.Serializable;

public class User implements Serializable {

    private String username;

    private String password;

    public String getUsername() {


        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

评论

暂无评论