转载于:https://blog.51cto.com/arlies/1659427

一、交换机的行为

交换机的行为无非分为接收数据、发送数据；任何流量在一个交换机内部转发时必须携带标签；PC接收到的流量必须为正常流量，不识别携带标签的流量。

接收数据
流量进入一个接口时，先看该流量是否携带标签。
发送数据
流量从一个接口出时，查询该接口的vlan允许列表，关注是否标记。

Huawei交换机存在三种工作模式

• Access，接入模式

• Trunk，中继模式

• Hybrid，混杂模式

接入模式
使用场景：常用于连接PC、终端设备、路由器等不能识别VLAN标记的流量的

中继模式
使用场景：常用于两台交换机之间相连的链路，用于承载所有的VLAN流量的

混杂模式
使用场景：任意场景，但Hybrid的灵活性很高不易于配置

Access端口只属于1个VLAN，所以它的缺省VLAN就是它所在的VLAN，不用设置；
Hybrid端口和Trunk端口属于多个VLAN，所以需要设置缺省VLAN ID。缺省情况下，Hybrid端口和Trunk端口的缺省VLAN为VLAN 1

Tag和Untag，tag是指vlan的标签，即vlan的id，用于指名数据包属于那个vlan，untag指数据包不属于任何vlan，没有vlan标记pvid，即端口vlan id号。

access
接收：如果是无标记帧，则会打上接口的缺省vlan，接收
          如果是标记帧，对比缺省vlanid，相同接收，不相同丢弃

发送：对比接口vlanid，如果不相同不能从该接口发送

trunk
接收：如果是无标记帧，则会打上接口的缺省vlanid，接收
          如果是标记帧，检查允许列表，允许则接收，不允许就丢弃

发送：如果标记帧的vlanid与接口pvid相同，并且在允许列表中，则标记帧的tag被删除发送
          如果标记帧的vlanid与接口pvid不同，并且在允许列表中，则标记帧带原tag发送

hybrid
接收：如果是无标记帧，接收并打上接口的缺省vlanid，接收
          如果是标记帧，检查允许列表（允许列表是tag和untag），允许则接收，不允许就丢弃

发送：如果以太帧在untagged或tagged列表，则表示可以从此端口通过，
对于untagged列表中的以太帧，在发送的时候去掉vlan标签后再从端口发送出去；
对于tagged列表中的以太帧，在发送的时候带着vlan标签从端口发送出去。
如果以太帧不在untagged或tagged列表，表示不从此端口通过。

hybrid接口
华为默认接口，翻译过来就是混杂接口，因为它结合了access和trunk的功能

主要配置

int e0/0/1  //进接口

port link hybrid  //配置接口模式为hybrid（华为交换机默认为hybrid）

port hybrid pvid vlan 2 //配置接口pvid （vlan1为接口默认加入的，可以不用配置）

Port hybrid untagged vlan 1 2 //配置脱标签的vlan号

port hybrid tagged vlan 1 2 //配置携带标签的vlan号

实验

下面进行配置（因为是同网段，所以用不到路由器）：

ping一下可以发现满足要求

stp生成树协议STP（spanning tree protocol）

为了提高网络可好性，交换网络中通常会使用冗余链路，然而，冗余链路会交给交换网络带来环路风险，并导致广播风暴以及MAC地址表不稳定等问题，进而会影响到用户的通信质量。生成树协议STP（spanning tree protocol）可以在提高可靠性的同时用能避免环路带来的各种问题。

环路会引起的问题
（1）环路会引起广播风暴，网络中的主机会收到重复数据帧。
（2）环路会引起MAC地址表震荡。

STP的作用
STP通过阻塞端口来消除环路，并能够实现链路备份的目的。（防止环路）
运行该协议的交换机可以自动找出导致环路的链路，并将其临时阻塞，再链路发生故障的时候，再自动恢复阻塞链路，保障网络既有冗余有无环运行。

BPDU报文
STP需要网络设备相互交换消息来检测桥接环路，该消息称为网桥协议数据单元BPDU。STP之所以能够良好的工作并构建一个无环的网络，是依赖于BPDU报文的泛洪，并根据报文中相关字段计算的结果

生成树算法的步骤
1、选择根网桥 
2、每个非根网桥上选择根端口（RP）
3、在每条链路上都要选择一个指定端口（DP）
4、阻塞既不是根端口又不是指定端口的端口（AP）

一、如何选择根网桥
依据：网桥ID（BID）
网桥ID=网桥优先级+网桥的MAC地址
网桥优先级的取值范围：0-65535
默认值：32768   

优先比较优先级，选最小
当优先级相等的情况下，选MAC地址小的

二、何选择根端口？
1、到根桥最低的根路径成本
某个网桥到达根网桥的中间所有线路的路径成本之和
用来代表一条线路带宽的大小
2、直连的网桥ID最小的
3、对端端口ID（PID）最小的
端口ID=端口优先级+端口编号
端口优先级：0-255  默认值：128

三、如何选择指定端口？
根网桥上的每个端口都是指定端口，都不会被阻塞
1、比较到达根桥的RPC（Root Path Cost），越小越优。
2、比较BPDU包发送者的BID，越小越优。
3、比较BPDU包发送者的PID，越小越优。
4、比较BPDU包接收者的PID，越小越优。

题目

首先网桥优先级都一样，MAC地址最小的是sw1,所以sw1为根网桥，它的两个端口为指定端口，然后根据路径开销最小最优先可以确定sw2和sw3的根端口分别为上面的端口和下面的端口，最后可以判断出指定端口sw2下面那个端口及阻塞端口sw3上面那个端口。

一、RabbitMQ的简单介绍

RabbitMQ作为一个消息队列，它负责提供一个通用的消息发送和接收平台,并且保证消息在传输过程中的安全可靠。
消息(Message)由Client(客户端)发送，RabbitMQ接收到消息之后通过交换机转发到对应的队列上面。Worker会从队列中获取未被读取的数据处理。

二、RabbitMQ的四种交换机

• 直连交换机：Direct exchange
• 扇形交换机：Fanout exchange
• 主体交换机：Topic exchange
• 首部交换机：Headers exchange

1、直连交换机

直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个binding_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。同样的一个binding_key也是支持应用到多个队列中的。
这样当一个交换机绑定多个队列时，就会被送到对应的队列去处理。

如图所示：当指定routing_key为key1时，消息队列1和2都会收到消息，下面用伪代码演示一下（只做演示，相关依赖省略）：

MQ配置类

@Configuration
public class MQConfig {
	//创建三个队列1,2,3
	//Queue的第一个参数为队列名称，第二个参数为是否持久存在
	 @Bean
    public Queue directQueue1() {
        return new Queue("queue1", true);
    }

    @Bean
    public Queue directQueue2() {
        return new Queue("queue2", true);
    }

    @Bean
    public Queue directQueue3() {
        return new Queue("queue3", true);
    }
	//创建直连交换机，参数为交换机的名称
	@Bean
    public DirectExchange directExchange() {
        return new DirectExchange("DIRECT_EXCHANGE");
    }
	//将三个队列都与该直连交换机绑定起来，并赋予上面说的binding_key(也可以说是routing_key)
	@Bean
    public Binding bindingDirectExchange1() {
        return BindingBuilder.bind(directQueue1()).to(directExchange()).with("key.1");
    }

    @Bean
    public Binding bindingDirectExchange2() {
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with("key.1");
    }

    @Bean
    public Binding bindingDirectExchange3() {
        return BindingBuilder.bind(directQueue3()).to(directExchange()).with("key.2");
    }
}

MQSnder发送者类

@Service
public class MQSender {
	//注入AmqpTemplate接口，该接口定义了发送和接收消息的基本操作
	@Autowired
    AmqpTemplate amqpTemplate;
    
    public void send(String message) {
    	//第一个参数指将消息发送到该名称的交换机，第二个参数为对应的routing_key,第三个参数为发送的具体消息   
    	amqpTemplate.convertAndSend("DIRECT_EXCHANGE", "key.1", message);   				 
    }
}

MQReceive消费者类

@Service
public class MQReceiver {
	private static final Logger logger = LoggerFactory.getLogger(MQReceiver.class);
	//此注解表示监听某个队列，参数为队列名
    @RabbitListener(queues = "queue1")
    public void receive1(String message) {
        logger.info("receive : dir1 message {}", message);
    }

    @RabbitListener(queues = "queue2")
    public void receive2(String message) {
        logger.info("receive : dir2 message {}", message);
    }

    @RabbitListener(queues = "queue3")
    public void receive3(String message) {
        logger.info("receive : dir3 message {}", message);
    }
}

调用发送者的send方法后，发现结果是队列1和2收到了消息，符合预期
适用场景：有优先级的任务，根据任务的优先级把消息发送到对应的队列，这样可以派更多的资源去处理高优先级的队列。

2、扇形交换机

扇形交换机是最基本的交换机类型，它能做的事非常简单——广播消息，扇形交换机会把能接收到的消息全部发送给绑定在自己身上的队列。因为广播不需要"思考"，所以扇形交换机处理消息的速度也是所有的交换机类型里面最快的。

下面用伪代码演示一下。
MQ配置类

@Configuration
public class MQConfig {
	//创建三个队列1,2,3
	//Queue的第一个参数为队列名称，第二个参数为是否持久存在
	 @Bean
    public Queue fanoutQueue1() {
        return new Queue("queue1", true);
    }

    @Bean
    public Queue fanoutQueue2() {
        return new Queue("queue2", true);
    }

    @Bean
    public Queue fanoutQueue3() {
        return new Queue("queue3", true);
    }
	//创建扇形交换机，参数为交换机的名称
	@Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange ("FANOUT_EXCHANGE");
    }
	//将三个队列都与该交换机绑定起来，无需binding_key
	@Bean
    public Binding bindingFanoutExchange1() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    @Bean
    public Binding bindingFanoutExchange2() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }

    @Bean
    public Binding bindingFanoutExchange3() {
        return BindingBuilder.bind(fanoutQueue3()).to(fanoutExchange());
    }
}

MQSnder发送者类

@Service
public class MQSender {
	//注入AmqpTemplate接口，该接口定义了发送和接收消息的基本操作
	@Autowired
    AmqpTemplate amqpTemplate;
    
    public void send(String message) {
    	//第一个参数指将消息发送到该名称的交换机，第二个参数为对应的routing_key(此时设置为空字符串即可),第三个参数为发送的具体消息   
    	amqpTemplate.convertAndSend("FANOUT_EXCHANGE", "", message);   				 
    }
}

MQReceive消费者类

@Service
public class MQReceiver {
	private static final Logger logger = LoggerFactory.getLogger(MQReceiver.class);
	//此注解表示监听某个队列，参数为队列名
    @RabbitListener(queues = "queue1")
    public void receive1(String message) {
        logger.info("receive : fanout message {}", message);
    }

    @RabbitListener(queues = "queue2")
    public void receive2(String message) {
        logger.info("receive : fanout message {}", message);
    }

    @RabbitListener(queues = "queue3")
    public void receive3(String message) {
        logger.info("receive : fanout message {}", message);
    }
}

调用MQSend的send()方法，三个队列都能接收到消息。
适用场景：需要给所有绑定该交换机的队列直接发送消息时使用。

3、主题交换机

直连交换机的routing_key方法非常简单，如果希望将一条消息发送给多个队列，那么这个交换机需要绑定非常多的routing_key，这样的话消息的管理就会非常的困难。
所以RabbitMQ提供了一种主题交换机，发送到主题交换机上的消息需要携带制定规则的routing_key，主题交换机会根据这个规则将数据发送到对应的队列上。
主题交换机的routing_key需要有一定的规则，交换机和队列绑定时候设置的binding_key需要采用*.#.*…的格式，每个部分用.分开，其中：

• *表示一个单词
• #表示任意数量(零个或多个)单词。
  假设有一条消息的routing_key为com.lrving.www，那么带有这样binding_key的几个队列都有收到消息:

1. com…
2. …www
3. com.#
4. …

下面是网上的一张图，清楚描述了主题交换机的消息发送规则

当一个队列的绑定键为#的时候，这个队列将会无视消息的路由键，接收所有的消息。下面用伪代码演示一下
MQ配置类

@Configuration
public class MQConfig {
	@Bean
    public Queue topicQueue1() {
        return new Queue("TOPIC_QUEUE1", true);
    }
    @Bean
    public Queue topicQueue2() {
        return new Queue("TOPIC_QUEUE2", true);
    }
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("TOPIC_EXCHANGE");
    }
  	//将topicQueue1与topicExchange交换机绑定
    @Bean
    public Binding bindQueue1() {
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("topic.key1");
    }
    //将topicQueue2与topicExchange交换机绑定
    @Bean
    public Binding bindQueue2() {
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("topic.#");
    }
}

MQSnder发送者类

@Service
public class MQSender {
	//注入AmqpTemplate接口，该接口定义了发送和接收消息的基本操作
	@Autowired
    AmqpTemplate amqpTemplate;
   public void sendTopic(String message) {
        amqpTemplate.convertAndSend("TOPIC_EXCHANGE", "topic.key1", message);
        amqpTemplate.convertAndSend("TOPIC_EXCHANGE", "topic.key2", message);
    }
}

MQReceive消费者类

@Service
public class MQReceiver {
	private static final Logger logger = LoggerFactory.getLogger(MQReceiver.class);
	@RabbitListener(queues = "TOPIC_QUEUE1")
    public void receiveQueue1(String message) {
        logger.info("receive : queue1 {}", message);
    }

    @RabbitListener(queues ="TOPIC_QUEUE2")
    public void receiveQueue2(String message) {
        logger.info("receive : queue2 {}", message);
    }
}

调用MQSender的send()方法，发现队列1收到了一条消息，而队列2收到了两条消息,符合参数#的描述。

4、首部交换机

首部交换机是忽略routing_key的一种路由方式。路由器和交换机路由的规则是通过Headers信息来交换的，这个有点像HTTP请求中的请求头。将一个交换机声明成首部交换机，绑定一个队列的时候，定义一个Hash的数据结构，消息发送的时候，会携带一组hash数据结构的信息，当Hash内容匹配上的时候，消息就会被写入队列。
绑定交换机和队列的时候，Hash结构中要求携带一个键"x-match"，这个键的Value可以是any或者all，这代表消息携带的Hash是需要全部匹配(all)，还是仅仅匹配一个键(any)就可以了。相比较直连交换机，首部交换机的优势是匹配的规则不被限定为字符串(string)。
下面用伪代码演示一下：
MQ配置类

@Configuration
public class MQConfig {
	 @Bean
    public Queue headersQueue() {
        return new Queue("HEADERS_QUEUE");
    }
    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange("HEADERS_EXCHANGE");
    }
    //将headersQueue与HeadersExchange交换机绑定
    @Bean
    public Binding bingHeadersQueue() {
    	//map为绑定的规则
        Map<String, Object> map = new HashMap<>();
        map.put("headers1", "value1");
        map.put("headers2", "value2");
        //whereAll表示需要满足所有条件
        return BindingBuilder.bind(headersQueue()).to(headersExchange()).whereAll(map).match();
    }
}

MQSnder发送者类

@Service
public class MQSender {
	//注入AmqpTemplate接口，该接口定义了发送和接收消息的基本操作
	@Autowired
    AmqpTemplate amqpTemplate;
   public void sendHeaders(String message) {
   		//配置消息规则
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("headers1", "value1");
        messageProperties.setHeader("headers2", "value2");
        //要发送的消息，第一个参数为具体的消息字节数组，第二个参数为消息规则
        Message msg = new Message(result.getBytes(), messageProperties);
        amqpTemplate.convertAndSend("HEADERS_EXCHANGE", "", msg);
    }
}

MQReceive消费者类

@Service
public class MQReceiver {
	private static final Logger logger = LoggerFactory.getLogger(MQReceiver.class);
   @RabbitListener(queues = "HEADERS_QUEUE")
    public void receiveHeadersQueue(byte[] message) {
        logger.info("receive : HeadersQueue {}", new String(message));
    }
}

调用MQSender的send()方法，发现队列收到了消息，符合预期。

参考资料

参考资料