RabbitMQ（6）工作模式：WorkQueue、Pub/Sub

最新推荐文章于 2024-10-09 08:17:44 发布
最新推荐文章于 2024-10-09 08:17:44 发布
阅读量230 收藏
点赞数 1
分类专栏： # RabbitMQ 文章标签： rabbitmq 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyuggjggg/article/details/122027148
版权

WorkQueue工作队列模式

模式说明

*加粗样式
Work Queues:与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

应用场景:对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

代码

生产者（Producer_WorkQueues）

package com.yy.producer;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class Producer_WorkQueues {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.153.129");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/yy");//虚拟机 默认值/
        factory.setUsername("yy");//用户名 默认 guest
        factory.setPassword("yy");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
        //5. 创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：
            1. queue：队列名称
            2. durable:是否持久化，当mq重启之后，还在
            3. exclusive：
                * 是否独占。只能有一个消费者监听这队列
                * 当Connection关闭时，是否删除队列
                *
            4. autoDelete:是否自动删除。当没有Consumer时，自动删除掉
            5. arguments：参数。

         */
        //如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("work_queues",true,false,false,null);
        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        参数：
            1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
            2. routingKey：路由名称
            3. props：配置信息
            4. body：发送消息数据

         */
        for (int i = 1; i <= 10; i++) {
            String body = i+"hello rabbitmq~~~";

            //6. 发送消息
            channel.basicPublish("","work_queues",null,body.getBytes());
        }

        //7.释放资源
      channel.close();
      connection.close();

    }
}

消费者（Consumer_WorkQueues1）

package com.yy.consumer;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_WorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.153.129");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/yy");//虚拟机 默认值/
        factory.setUsername("yy");//用户名 默认 guest
        factory.setPassword("yy");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
        //5. 创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：
            1. queue：队列名称
            2. durable:是否持久化，当mq重启之后，还在
            3. exclusive：
                * 是否独占。只能有一个消费者监听这队列
                * 当Connection关闭时，是否删除队列
                *
            4. autoDelete:是否自动删除。当没有Consumer时，自动删除掉
            5. arguments：参数。

         */
        //如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("work_queues",true,false,false,null);

        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象

         */
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){
            /*
                回调方法，当收到消息后，会自动执行该方法

                1. consumerTag：标识
                2. envelope：获取一些信息，交换机，路由key...
                3. properties:配置信息
                4. body：数据

             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body："+new String(body));
            }
        };
        channel.basicConsume("work_queues",true,consumer);

        //关闭资源？不要

    }
}

消费者（Consumer_WorkQueues2）

package com.yy.consumer;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_WorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.153.129");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/yy");//虚拟机 默认值/
        factory.setUsername("yy");//用户名 默认 guest
        factory.setPassword("yy");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
        //5. 创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：
            1. queue：队列名称
            2. durable:是否持久化，当mq重启之后，还在
            3. exclusive：
                * 是否独占。只能有一个消费者监听这队列
                * 当Connection关闭时，是否删除队列
                *
            4. autoDelete:是否自动删除。当没有Consumer时，自动删除掉
            5. arguments：参数。

         */
        //如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("work_queues",true,false,false,null);

        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象

         */
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){
            /*
                回调方法，当收到消息后，会自动执行该方法

                1. consumerTag：标识
                2. envelope：获取一些信息，交换机，路由key...
                3. properties:配置信息
                4. body：数据

             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body："+new String(body));
            }
        };
        channel.basicConsume("work_queues",true,consumer);


        //关闭资源？不要

    }
}

运行

首先，执行两个消费者，最后再去执行生产者
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

总结

1.在一个队列中如果有多个消费者,那么消费者之间对于同一个消息的关系是竞争的关系。

也就是说，一个消息只能被一个消费者获取

2.Work Queues对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

例如:短信服务部署多个,只需要有一个节点成功发送即可。

Pub/Sub订阅模式

模式说明

在这里插入图片描述
在订阅模型中，多了一个Exchange色，而且过程略有变化:

  1. P:生产者,也就是要发送消息的程序,但是不再发送到队列中，而是发给X (交换机)
  2. C:消费者,消息的接收者，会一直等待消息到来
  3. Queue: 消息队列，接收消息、缓存消息
  4. Exchange: 交换机(X)。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有 常见以下3种类型:
    1. Fanout: 广播，将消息交给所有绑定到交换机的队列
    2. Direct: 定向，把消息交给符合指定routing key的队列
    3. Topic: 通配符，把消息交给符合routing pattern (路由模式) 的队列

Exchange (交换机)只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失!

代码

需求：通过生产者生产一条消息，两个消费者同时接收，这是一条日志的消息，C1把日志打印到控制台上，C2将日志存储在数据库中

生产者（Producer_PubSub）

package com.yy.producer;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class Producer_PubSub {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("172.16.98.133");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
       /*

       exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
       参数：
        1. exchange:交换机名称
        2. type:交换机类型，通过打点去调用就可以了
            DIRECT("direct"),：定向
            FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
            TOPIC("topic"),通配符的方式
            HEADERS("headers");参数匹配，这个用的比较少

        3. durable:是否持久化
        4. autoDelete:自动删除
        5. internal：内部使用。 一般false
        6. arguments：参数
        */

       String exchangeName = "test_fanout";
        //5. 创建交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        //6. 创建队列
        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);

        //7. 绑定队列和交换机
        /*
        queueBind(String queue, String exchange, String routingKey)
        参数：
            1. queue：队列名称
            2. exchange：交换机名称
            3. routingKey：路由键，绑定规则
                如果交换机的类型为fanout ，routingKey设置为""（这个路由交换机将来会把消息分发给每一个与之绑定的queue（队列））
         */
        channel.queueBind(queue1Name,exchangeName,"");
        channel.queueBind(queue2Name,exchangeName,"");

        String body = "日志信息：张三调用了findAll方法...日志级别：info...";
        //8. 发送消息
        channel.basicPublish(exchangeName,"",null,body.getBytes());

        //9. 释放资源
        channel.close();
        connection.close();

    }
}

消费者（Consumer_PubSub1）

package com.yy.consumer;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_PubSub1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.153.129");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/yy");//虚拟机 默认值/
        factory.setUsername("yy");//用户名 默认 guest
        factory.setPassword("yy");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";


        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象

         */
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){
            /*
                回调方法，当收到消息后，会自动执行该方法

                1. consumerTag：标识
                2. envelope：获取一些信息，交换机，路由key...
                3. properties:配置信息
                4. body：数据

             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body："+new String(body));
                System.out.println("将日志信息打印到控制台.....");
            }
        };
        channel.basicConsume(queue1Name,true,consumer);


        //关闭资源？不要

    }
}

消费者（Consumer_PubSub2）

package com.yy.consumer;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_PubSub2 {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.153.129");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/yy");//虚拟机 默认值/
        factory.setUsername("yy");//用户名 默认 guest
        factory.setPassword("yy");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";


        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象

         */
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){
            /*
                回调方法，当收到消息后，会自动执行该方法

                1. consumerTag：标识
                2. envelope：获取一些信息，交换机，路由key...
                3. properties:配置信息
                4. body：数据

             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body："+new String(body));
                System.out.println("将日志信息保存数据库.....");
            }
        };
        channel.basicConsume(queue2Name,true,consumer);


        //关闭资源？不要

    }
}

运行

首先运行生产者，然后运行两个消费者，最终结果如下

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

总结

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。

发布订阅模式与工作队列模式的区别

1、工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。

2、发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)。

3、发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑 定到默认的交换机 。

?abc!
关注
专栏目录
JAVA 反射总结
oHeHeHou的专栏
01-20 768
反射提供了程序分析类的能力，利用JAVA的反射机制可以方便完成很多工作，常用到的4个类： java.lang.reflect.Field java.lang.reflect.Method java.lang.Class java.lang.reflect.Modifier  一.java.lang.Class： 在运行的JAVA程序中维护所有对象的信息的一个类.Cl
JS前端动态添加表格--包括合并指定单元格
baijianjun123456的博客
03-08 6737
var newRow = "";//全局变量 var pubSum=1;//计数添加记录次数 var panelTitle=$("#title").val(); var currExtBJ=""; var existMatterPrice=$("#matter_price").val(); var isDisplay=$("#isDisplay").val(); var existMa
RabbitMQ工作模式
后端
07-06 1111
对应 fanout（广播） 类型的 Exchange，会把所有发送到该 Exchange 的消息路由到所有与它绑定的 Queue 中，不需要做任何判断操作，所以 fanout 类型是所有的交换机类型里面速度最快的。”分隔开的每一段独立的字符串称为一个单词），如 “com.rabbitmq.client”、“java.util.concurrent”、“com.hidden.client”包含一个生产者、一个队列和多个消费者，多个消费者绑定到同一个队列上，且一条消息只能被一个消费者消费。
消息队列5：rabbitmq的WorkQueue模式
火焰
04-18 314
环境： win10 rabbitmq-3.8.8 .net core 3.1 RabbitMQ.Client 6.2.1 说明： 这一部分的代码与上一篇：《消息队列3：rabbitmq入门实例》基本上没有出入。 这一片注重rabbitmq的模式和参数的说明。 一、rabbitmq模式概念 rabbitmq有5中模式，分别是： 工作者模式； 发布/订阅模式； 路由模式； 主题模式； rpc模式； 其他地方也有说是6种模式的，所谓的6种模式是将工作者模式拆分成两个模式： 简单模式： 一个生产者对应一个
消息队列6：rabbitmq的发布订阅模式
火焰
04-19 385
环境： win10 rabbitmq 3.8.8 .net core 3.1 vs2019 RabbitMQ.Client 6.2.1 本文参照：https://www.rabbitmq.com/tutorials/tutorial-three-dotnet.html 一、关于完整的消息模型 在上一篇《消息队列5：rabbitmq的工作者模式》中，我们为了测试消息的发送和接收，进行了如下动作： 生产者： 创建连接； 在连接上创建信道； 在信道上声明队列； 将消息发送到队列上； 消费者：
SpringBoot整合RabbitMQ：5种模式实战
沮丧的南瓜
07-31 3368
一、环境准备 1、pom依赖 <!-- 父工程依赖 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.6.RELEASE</version> </pa
04. RabbitMQ的几种工作模式
程序员阿红的博客
03-20 1810
04. RabbitMQ的几种工作模式 🍎姓名:程序员阿红🍎 🍊喜欢:Java编程🍊 🍉重要的事情说三遍!!!🍉 🍓欢迎大家关注哦,互相学习🍓 🍋欢迎大家访问哦,互相学习🍋 🍑欢迎大家收藏哦,互相学习🍑 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🍟🍟🍟RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此我们只学习前5种 🍗🍗🍗在线手册：https://www.rabbitmq.com/getstarted.htm 5种消息模型，大体分为两类： 1和2属于点对点 3、4
【RabbitMQ】RabbbitMQ的六种工作模式以及代码实现
qq_61903414的博客
04-14 1125
RabbitMQ的简单模式是一对一即，一个生产者生产消息后不经交换机直接给指定的队列供消费者消费工作队列模式相比简单模式，他的处理任务速度在一定情况下会更快，因为他相比简单模式单一消费者而言它增加了消费者个数他相比之前两种模式引入了交换机，当MQ服务器收到消息后，交换机会把收到的消息分发给每一个绑定了该交换机的队列给不同的消费者进行消费，之前的文章里我们是通过控制台进行队列与交换机的绑定，这里我们会使用Java代码来进行绑定。
MQ——RabbitMQ工作模式实战
庄小焱
09-23 354
摘要 主要是讲解Rabbit的实战代码和分析。主要的代码在：https://github.com/2462612540/Senior-Architect/tree/a_1.0/RabbitMQ 简答模式下项目结构 简单模式下生产者代码 package com.xjl.mq.producer; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client
RabbitMQ 消息队列
bier_zm的博客
11-08 4323
什么是 RabbitMQ MQ（Message Queue）消息队列 消息队列中间件，是分布式系统中的重要组件； 主要解决异步处理、应用解耦、流量削峰等问题，从而实现高性能，高可用，可伸缩和最终一致性的架构。 使用较多的消息队列产品：RabbitMQ，RocketMQ，ActiveMQ，ZeroMQ，Kafka 等。 异步处理 用户注册后，需要发送验证邮箱和手机验证码。 将注册信息写入数据库，发送验证邮件，发送手机，三个步骤全部完成后，返回给客户端。 传统： 客户端 <-> 注
rabbitmq在exchange下的两种使用模式
热门推荐
congge
09-10 2万+
上一篇，我们介绍了rabbimtmq的简单工作队列的使用方式，即生产者和消费者之间直接通过绑定相同的workqueue进行消息的发送和接收，如果业务逻辑比较简单，这样的方式也是可以用的，但在实际工作中，实际的业务场景远远比这个复杂，而且需要更加细粒度的对消息进行进行分发和接收，这就需要用到rabbitmq的另外一个组件exchange; 顾名思义，exchange在rabbitmq中翻译为交换机...
RabbitMQ五种消息类型
weixin_35787722的博客
05-08 5047
大体分为两类：1和2属于点对点；3、4、5属于发布订阅模式（一对多） 点对点模式：P2P（point to point）模式包含三个角色： 消息队列（queue），发送者（sender），接收者（receiver） 每个消息发送到一个特定的队列中，接收者从中获得消息 队列中保留这些消息，直到他们被消费或超时 特点： 1. 每个消息只有一个消费者，一旦消费，消息就不在队列中了 2. 发送者和接收者之间没有依赖性，发送者发送完成，不管接收者是否运行，都不会影响 消息发送到队列中（我给你发微信，不
# rabbitMQ学习（一）入门使用
lzr_ps的博客
05-13 173
rabbitMQ学习（一） 前言 为什么要学习rabbitMQ？ 别问，必学。 MQ是什么，有什么优势？ “消息队列”是在消息的传输过程中保存消息的容器。 --百度百科 简单来说，消息队列即在两个系统中用于消息传递的一个中间件，一般有三个角色 消息中间件 发送方（生产者） 接收方（消费者） 相比于让两个系统之间进行互相调用，使用MQ有如下优势： 解耦 两个系统不会直接依赖，而是与消息中间件进行通信 提速 发送方只需要将消息放入队列中即可返回，不用等待接收方的处理 消峰 让接收方不会被动承担
集成与优化：Java线程池与消息队列性能提升的7个技巧
!...# 1. Java线程池与消息队列基础 在Java的并发编程中，线程池与消息队列是两个核心的组件，它们分别承担着不同的任务与职责，共同协作实现高效、稳定的应用程序架构。本章节将对这两者的概念进行基础介绍，并阐述...
《RabbitMQ篇》消费者轮询消费消息
m0_56199449的博客
10-08 208
验证RabbitMQ中消费者轮询消费消息
【黑马点评】 使用RabbitMQ实现消息队列——2.使用RabbitMQ监听秒杀下单
m0_52031708的博客
10-06 1107
黑马点评之使用RabbitMQ实现消息队列
仿RabbitMQ实现消息队列服务端（二）
weixin_74461263的博客
10-04 1082
在RabbitMQ中,虚拟主机是可以随意创建/删除的，但是咱们此处为了实现简单,并没有实现虚拟主机的管理，因此我们默认就只有⼀个虚拟主机的存在，但是在数据结构的设计上我们预留了对于多虚拟主机的管理，从⽽保证不同虚拟主机中的Exchange、Queue、Binding、Message等资源都是相互隔离的。具体通信的过程我们使⽤Muduo库来实现，使⽤TCP作为通信的底层协议，同时在这个基础上⾃定义应⽤层协议，完成客⼾端对服务器功能的远端调⽤。使⽤⼆进制的⽅式设计应⽤层协议。
尚硅谷rabbitmq 2024 集群ui 第49节 答疑二
最新发布
2401_86733530的博客
10-09 1028
在HAProxy的配置中，`frontend`和`backend`是两个不同的概念，分别用于处理客户端请求和后端服务器的定义。虽然你在`frontend`部分定义了`default_backend rabbitmq_ui_backend`，但你仍然需要在`backend`部分具体定义这个后端服务器组，以便HAProxy知道如何与这些后端服务器进行通信。`upstream`和`backend`都用于定义后端服务器组，而`server`和`frontend`都用于定义如何处理客户端请求。你的担忧是很合理的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

?abc!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值