mq安装教程

bubbleJessica

已于 2024-05-19 14:32:46 修改

阅读量524

点赞数 20

分类专栏：中间件文章标签： java 开发语言

于 2024-05-09 01:10:08 首次发布

本文链接：https://blog.csdn.net/bubbleJessica/article/details/138588899

版权

中间件专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一：从本地加载

docker load -i mq.tar

二：安装MQ

执行下面的命令来运行MQ容器：

docker run \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123321 \
--name mq \
--hostname mq1 \
-p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq:3.8-management

三：查看mq状态

docker ps

四：之前启动过想重新运行（二换成四）

docker start mq

通过自己虚拟机ip+端口号即可访问RabbitMQ官网

详细操作

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.101.130");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}

建立连接执行完之后，mq界面就显示如下：

创建通道后如图

创建队列和发送消息后界面如图

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.101.130");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

建立连接执行完之后，mq界面就显示如下：

创建通道后如图

创建队列和接收消息后界面如图

Spring AMQP应用间消息通信协议

官方地址

入门案例

步骤一：引入依赖

<!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

步骤二：在发布者中配置mq地址信息

spring:
  rabbitmq:
    host: 192.168.101.130 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendMessage2SimpleQueue(){
        String queueName="simple.queue";
        String message="hello.spring amqp!";
        rabbitTemplate.convertAndSend(queueName,message);
    }
}

步骤三：在消费者中配置mq地址信息

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
    }
}

消息消费掉确实没了

WorkQueue

生产者

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendMessage2WorkQueue() throws InterruptedException {
        String queueName = "simple.queue";
        String message = "hello.message__";
        for (int i = 1; i <= 50; i++) {
            rabbitTemplate.convertAndSend(queueName, message + i);
            Thread.sleep(20);
        }

    }
}

消费者

@Component
public class SpringRabbitListener {

    /*
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
    }
    */

    @RabbitListener(queues = "simple.queue")
    public void listenWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
        Thread.sleep(20);
    }

    @RabbitListener(queues = "simple.queue")
    public void listenWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2接收到消息：【" + msg + "】" + LocalTime.now());
        Thread.sleep(200);
    }
}

为了保证能者多劳，需要再配置文件设置prefetch参数

spring:
  rabbitmq:
    host: 192.168.101.130 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /
    listener:
      simple:
        prefetch: 1

上面两种队列SimpleQueue和WorkQueue都是每条消息只被一个消费者接收

三种交换机

FanoutExchange

消费者配置

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:48
 * @description
 */
@Configuration
public class FanoutConfig {
    // itcast.fanout
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("itcast.fanout");
    }

    // fanout.queue1
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("fanout.queue1");
    }

    // 绑定队列1到交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    // fanout.queue2
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("fanout.queue2");
    }

    // 绑定队列2到交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

监听器

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String msg) {
        System.out.println("消费者接收到fanout.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String msg) {
        System.out.println("消费者接收到fanout.queue2的消息：【" + msg + "】");
    }
}

启动完看到mq界面有itcast.fanout

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendFanoutExchange() {
        // 交换机名称
        String exchangeName = "itcast.fanout";
        // 消息
        String message = "hello,every one!";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "", message);
    }
}

DirectExchange

消费者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    public void listenDirectQueue1(String msg){
        System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
    }
}

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    
    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "itcast.direct";
        // 消息
        String message = "hello,red!";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "red", message);
    }
}

TopicExchange

通配符#代表0~多个，*代表一个

消费者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
            key = "china.#"
    ))
    public void listenTopicQueue1(String msg) {
        System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
            key = "#.news"
    ))
    public void listenTopicQueue2(String msg) {
        System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
    }
}

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "itcast.topic";
        // 消息
        String message = "今天天气不错，我的心情好极了！";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "china.weather", message);
    }
}

消息转换器

消费者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:48
 * @description
 */
@Configuration
public class FanoutConfig {
    
    @Bean
    public Queue objectQueue() {
        return new Queue("object.queue");
    }
}

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> msg){
        System.out.println("消费者接收到object.queue的消息：【" + msg + "】");
    }

}

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendObjectQueue() {
        Map<String, Object> msg = new HashMap<String, Object>();
        msg.put("name", "杨紫");
        msg.put("age", 21);
        rabbitTemplate.convertAndSend("object.queue", msg);
    }
}

java序列化意味着把对象给序列化，性能差安全低，数据长度太长，传输速度太慢，占用额外内存

引入依赖

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
</dependency>

生产者消费者主程序配置转换器

@Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

bubbleJessica

关注

20
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
mq安装教程

java序列化意味着把对象给序列化，性能差安全低，数据长度太长，传输速度太慢，占用额外内存。为了保证能者多劳，需要再配置文件设置prefetch参数。通过自己虚拟机ip+端口号即可访问RabbitMQ官网。启动完看到mq界面有itcast.fanout。
复制链接

扫一扫