【黑马SpringCloud微服务开发与实战】（七）MQ入门

原创 已于 2025-07-27 16:18:48 修改 · 330 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring cloud #微服务 #spring

于 2025-07-24 17:53:29 首次发布

1. MQ课程介绍

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2. 初识MQ —— 同步调用优缺点

在这里插入图片描述

在这里插入图片描述

3. 初识MQ —— 异步调用优缺点

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

4. 初识MQ —— 技术选型

在这里插入图片描述

docker run \
 -e RABBITMQ_DEFAULT_USER=itheima \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 --network hm-net\
 -d \
 rabbitmq:3.8-management

在这里插入图片描述

docker run \
 -e RABBITMQ_DEFAULT_USER=itheima \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 --network hm-net\
 -d \
 rabbitmq:3.8-management

在这里插入图片描述
http://192.168.10.100:15672/

在这里插入图片描述
如果你的无响应，可以试试添加端口

# CentOS 示例
sudo firewall-cmd --add-port=5672/tcp --permanent
sudo firewall-cmd --permanent --add-port=15672/tcp
sudo firewall-cmd --reload
# 确认端口已添加
sudo firewall-cmd --list-ports
# 重启容器
docker restart mq

如果重启容器失败，就重启docker在重启容器。

在这里插入图片描述

在这里插入图片描述

5. 快速入门

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

6. 数据隔离

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

退出mq，用hmall账号登录，然后设置：

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

在这里插入图片描述
选择你想看的
在这里插入图片描述

7. Java客户端——快速入门

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

在这里插入图片描述

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.demo</groupId>
    <artifactId>mq-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>publisher</module>
        <module>consumer</module>
    </modules>
    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--AMQP依赖，包含RabbitMQ-->
        <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>
</project>

spring:
  rabbitmq:
    host: 192.168.10.100 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: /hmall # 虚拟主机
    username: hmall # 用户名
    password: 123 # 密码

记得消费者和发送者都要配

ctrl + shift + t 创建测试类

在这里插入图片描述

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, spring amqp!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }

队列接受到消息

在这里插入图片描述

在这里插入图片描述

@Component
public class SpringRabbitListener {

    // 利用RabbitListener来声明要监听的队列信息
    // 将来一旦监听的队列中有了消息，就会推送给当前服务，调用当前方法，处理消息。
    // 可以看到方法体中接收的就是消息体的内容
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

在这里插入图片描述

在这里插入图片描述

8. Java客户端——WorkQueue

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

在这里插入图片描述

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

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

/**
     * workQueue
     * 向队列中不停发送消息，模拟消息堆积。
     */
@Test
public void testWorkQueue() throws InterruptedException {
    // 队列名称
    String queueName = "work.queue";
    // 消息
    String message = "hello, message_";
    for (int i = 0; i < 50; i++) {
        // 发送消息，每20毫秒发送一次，相当于每秒发送50条消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

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

注意到这两消费者，都设置了Thead.sleep，模拟任务耗时：

  • 消费者1 sleep了20毫秒，相当于每秒钟处理50个消息
  • 消费者2 sleep了200毫秒，相当于每秒处理5个消息

在这里插入图片描述

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

可以发现，由于消费者1处理速度较快，所以处理了更多的消息；消费者2处理速度较慢，只处理了6条消息。而最终总的执行耗时也在1秒左右，大大提升。
正所谓能者多劳，这样充分利用了每一个消费者的处理能力，可以有效避免消息积压问题。

在这里插入图片描述

9. Java客户端——Fanout交换机

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

@Test
public void testFanoutExchange() {
    // 交换机名称
    String exchangeName = "hmall.fanout";
    // 消息
    String message = "hello, everyone!";
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}

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

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

在这里插入图片描述

在这里插入图片描述

10. Java客户端——Direct交换机

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

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

red发送

    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "hmall.direct";
        // 消息
        String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "red", message);
    }

在这里插入图片描述
blue 发送：

    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "hmall.direct";
        // 消息
        String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "blue", message);
    }

在这里插入图片描述

11. Java客户端——Topic交换机

在这里插入图片描述

在这里插入图片描述
创建队列和交换机比较简单，这里就不一一阐述和前面类似，这里贴一个绑定的图：

在这里插入图片描述

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

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

    /**
     * topicExchange
     */
    @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "hmall.topic";
        // 消息
        String message = "喜报！孙悟空大战哥斯拉，胜!";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
    }

在这里插入图片描述
这里符合两个队列的匹配规则。

12. Java客户端——基于Bean声明队列交换机

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.itheima.consumer.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {

    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("hmall.fanout");
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

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

    /**
     * 第2个队列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

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


package com.itheima.consumer.config;

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

@Configuration
public class DirectConfig {

    /**
     * 声明交换机
     * @return Direct类型交换机
     */
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange("hmall.direct").build();
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue directQueue1(){
        return new Queue("direct.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
    }
    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue directQueue2(){
        return new Queue("direct.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("red");
    }
    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");
    }
}

13. Java客户端——基于注解声明队列交换机

在这里插入图片描述

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

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

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

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

14. Java客户端——消息转换器

在这里插入图片描述

package com.itheima.consumer.config;

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

@Configuration
public class MessageConfig {

    @Bean
    public Queue objectQueue() {
        return new Queue("object.queue");
    }
}


@Test
public void testSendMap() throws InterruptedException {
    // 准备消息
    Map<String,Object> msg = new HashMap<>();
    msg.put("name", "柳岩");
    msg.put("age", 21);
    // 发送消息
    rabbitTemplate.convertAndSend("object.queue", msg);
}

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

配置消息转换器，在publisher和consumer两个服务的启动类中添加一个Bean即可：

在这里插入图片描述

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

在这里插入图片描述

15. Java客户端——业务改造

在这里插入图片描述

package com.hmall.common.config;

import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass(Jackson2JsonMessageConverter.class)
public class MqConfig {

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

}

自动装配、把spring.factorys写
记的加这个 @ConditionalOnClass(Jackson2JsonMessageConverter.class) 不然自动装配会报错

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.hmall.common.config.MyBatisConfig,\
  com.hmall.common.config.MvcConfig,\
  com.hmall.common.config.MqConfig,\
  com.hmall.common.config.JsonConfig


        <!--消息发送-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

spring:
  rabbitmq:
    host: 192.168.10.100 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: /hmall # 虚拟主机
    username: hmall # 用户名
    password: 123 # 密码

创建listen包 tarde服务里面作为消费者监听

@Component
@RequiredArgsConstructor
public class PayStatusListener {

    private final IOrderService orderService;


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "trade.pay.success.queue", durable = "true"),
            exchange = @Exchange(name = "pay.topic"),
            key = "pay.success"
    ))
    public void listenPaySuccess(Long orderId){
        orderService.markOrderPaySuccess(orderId);
    }
}

pay的生产者代码修改

private final RabbitTemplate rabbitTemplate;

try {
    rabbitTemplate.convertAndSend("pay.topic", "pay.success", po.getBizOrderNo());
} catch (Exception e) {
    log.error("支付成功的消息发送失败，支付单id：{}， 交易单id：{}", po.getId(), po.getBizOrderNo(), e);
}

在这里插入图片描述

SpringCloud笔记(黑马)
安赫' 的博客
09-07 5486
单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝微服务：一种良好的分布式架构方案​ ①优点：拆分粒度更小、服务更独立、耦合度更低​ ②缺点：架构非常复杂，运维、监控、部署难度提高SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组件SpringCloudRibbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。
2024最新SpringCloud微服务开发与实战 视频教程 下载
06-22 1187
│ Elasticsearch01-14.JavaRestClient-文档的CRUD.mp4。│ Elasticsearch01-13.JavaRestClient-新增文档.mp4。│ MybatisPlus-10.核心功能-IService的Lambda方法.mp4。│ MybatisPlus-11.核心功能-IService的批量新增.mp4。│ Elasticsearch01-07.索引库操作-索引库的CRUD.mp4。
SpringCloud微服务技术栈.黑马跟学(三)
心向阳光的天域的博客
03-19 1267
Docker快速入门，常用指令，搭建Docker镜像仓库
微服务概述1
m0_62520968的博客
09-29 572
为应对系统出现异常的问题，引入分布式日志服务，可以统一对整个集群中的每个服务的运行日志进行存储、统计、分析，出现问题可以准确定位。还有系统监控链路追踪组件，实时监控整个集群中每个服务节点的运行状态、cpu负载、内存占用等，一旦出现问题，可以直接定位。一个业务由多个服务完成，当业务越多，服务之间的调用关系就越复杂，这样需要一个组件“注册中心”，负责记录每一个服务的功能、IP、端口等配置信息。现在就是可访问状态，用户通过身份验证，提交请求，由服务网关路由到相应服务。对系统进行自动化部署。来自黑马程序员ppt。
SpringCloud微服务 黑马教程 自我总结笔记
制定持续可量化的目标，不断坚持。
03-13 1993
BeanEureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS云域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。同时，它也是Spring Cloud Netflix微服务套件中的一部分，可以与Spring Boot构建的微服务很容易地整合起来。Eureka包含两个组件：Eureka Server和Eureka Client。
【黑马程序员】SpringCloud——微服务
weixin_54533016的博客
11-07 1291
跟着B站的黑马程序员学习 SpringCloud，语言为java，目前是第一个学习内容SpringCloud——微服务以上就是本章要讲的内容，本文仅仅简单复述了老师讲课的文本内容，内容有误麻烦联系。
黑马商城项目—最新SpringCloud开发实战—功能实现详细学习笔记（微服务篇）
最新发布
m0_74822999的博客
02-08 2225
服务拆分后会遇到2个问题：1，服务地址有很多且将来可能发生变化，前端无法确定请求的服务地址端口2，每个服务都需要登录的用户信息，如果每个服务都去登录不仅复杂而且可能泄露密钥以上问题可以用网关解决前端只需要去请求网关，然后就可以访问到对应的微服务，包括3个功能，网关还有一些优点：网关可以避免微服务地址暴露给前端，也是一种对微服务的保护，对于前端来说，网关的作用将后端的微服务架构变成了单体架构（前端将整个后端视为黑盒首先微服务启动后在注册中心进行注册，然后网关会去拉取服务列表，
SpringCloud
qq_39581763的博客
02-13 353
SpringCloud 分布式系统，每个系统分布在各自的机器上，下单买东西，订单系统，库存系统，仓储系统，积分系统 日活10万单块系统不合适 当一个用户下订单，调用订单系统，订单系统调用库存系统，仓储系统，积分系统，等等，电商系统，拆分为了多个子系统，一个请求需要多个子系统写作完成，每个子系统完成各自的功能， 最终这个请求处理完毕。 springCloud的核心组件 Eureka :服务注册中心，...
黑马学SpringCloud-Nacos（二）
dengfengling999的博客
10-22 618
随着微服务越来越多，我们在生产环境中可能会达到数十上百甚至上千台这种服务器的情况，我们的配置文件需要做一些修改，这个配置文件可能跟数十个微服务都由关系，这时候我们得逐个微服务去调整这个配置，很麻烦，调完之后这些微服务都需要重启，一个服务重启带来的影响还是挺大的，我们希望这些配置文件做到统一的管理，比如说我们现在有数十个配置需要修改，我们只在一个地方完成改动，并且我们希望这个服务不需要重启，这些配置就能立马生效，这就是配置的热更新，这就用到配置管理服务。多环境共享的是没有带环境的。
黑马十次方项目day07-01之SpringCloud的介绍
Java持续实践
02-16 1179
文章目录1. 1什么是SpringCloud1.2 SpringCloud与SpringBoot的关系1.3SpringCloud主要框架1.4 Spring Cloud和Dubbo对比1.5 SpringCloud的版本 1. 1什么是SpringCloud Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简 化了分布式系统基础设施的开发，如服务发现...
黑马程序员-SpringCloud-学习笔记01-认识微服务
06-18
黑马程序员-SpringCloud-学习笔记01-认识微服务
SpringCloud微服务技术栈.黑马跟学(四)
心向阳光的天域的博客
03-20 668
Rabbit MQ的安装，部署，以及常见的消息队列模型，消息转换器
SpringCloud微服务技术栈.黑马跟学(六)
心向阳光的天域的博客
03-23 672
DSL语法学习、DSL语法在RestClient的实现、以旅游为例实战小项目快速入门RestClient
黑马程序员 spring cloud 学习笔记
qq_40813329的博客
02-16 2210
资源 视频，讲义，资源 https://pan.baidu.com/s/169SFtYEvel44hRJhmFTRTQ 提取码：1234 视频地址 https://www.bilibili.com/video/BV1LQ4y127n4?from=search&seid=13710719474285356603&spm_id_from=333.337.0.0 笔记 https://www.xn2001.com/archives/663.html ...
SpringCloud学习笔记(黑马)(五)——gateway网关组件
zhw00508zz的博客
12-10 817
gateway网关网关介绍为什么需要网关网关技术实现搭建网关环境路由断言工厂路由过滤器（Gateway Filter）默认过滤器全局过滤器案例 拦截并判断用户的身份定义过滤器的执行顺序方法一 注解方法二 实现接口 网关介绍 为什么需要网关 网关技术实现 搭建网关环境 1.新建一个项目 2.引入依赖 <dependencies> <!-- 网关组件--> <dependency> <groupId&g
SpringCloud学习笔记(黑马)(二)——ribbon组件
zhw00508zz的博客
12-06 405
ribbon负载均衡原理负载均衡流程三级目录 负载均衡原理 负载均衡流程 三级目录
黑马4天从浅入深精通SpringCloud 微服务架构（完整资料）
weixin_46240907的博客
04-30 1806
目录：/001 黑马4天从浅入深精通SpringCloud 微服务架构（完整资料） ┣━━day1 ┃ ┣━━01-课程介绍.mp4 ┃ ┣━━02-系统架构演变-上.avi ┃ ┣━━03-系统架构演变-中.avi ┃ ┣━━04-系统架构演变-下.avi ┃ ┣━━05-基础知识：rpc...
黑马商城 Spring Cloud 微服务课程笔记 - 雪崩问题之原因分析（SpringCloud 微服务保护和分布式事务 - 01）
m0_57836225的博客
11-23 656
在黑马商城的 Spring Cloud 微服务架构中，本部分主要聚焦于微服务保护中的雪崩问题原因分析。当一个微服务出现故障时，可能会导致与其相关的其他微服务也相继出现故障，进而像雪崩一样影响整个微服务系统的正常运行，严重影响系统的可用性和稳定性。通过对雪崩问题原因的分析，我们能够更清楚地认识到在黑马商城的 Spring Cloud 微服务架构中可能存在的风险，为后续学习雪崩问题的解决方案（如使用 Sentinel 进行限流、熔断等）奠定基础，从而更好地保障微服务系统的稳定性和可靠性。
SpringCloud保姆级教程（黑马程序员）建议收藏！！！（可作对比，课程小细节）
2301_80182418的博客
11-10 1970
微服务架构，是服务化思想指导下的一套最佳实践架构方案。服务化，就是把单体架构中的功能模块拆分为多个独立项目。拆分成独立项目，不是一个小项目一个controller，而是一个小项目单独负责一个功能，例如增删改查，登录注册。各个微服务再各自打包成jar包在tomcat服务器上运行，各自搭配一个mysql数据库。spring的springboot框架优势：自动装配和依赖管理spring cloud是封装了各个组件。
SpringCloud微服务实战：从单体到分布式架构演变
本文围绕“黑马商城”这一企业级项目的架构演进过程，系统性地展示了从传统单体架构向微服务架构迁移的完整路径，深入剖析了微服务拆分的设计原则、实施策略以及SpringCloud生态组件在实际开发中的集成与应用。...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值