尚硅谷 SpringCloud 第二季学习笔记【已完结】

最新推荐文章于 2023-06-17 11:01:00 发布
最新推荐文章于 2023-06-17 11:01:00 发布
阅读量1.8k 收藏 19
点赞数
分类专栏： 面试 学习路线 阿里巴巴 文章标签： 计算机视觉 database android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54850467/article/details/125402133
版权
这是一篇关于SpringCloud微服务架构的详细学习笔记，涵盖了从基础介绍、微服务编码构建、服务注册与发现（Eureka、Zookeeper、Consul）、负载均衡（Ribbon）、服务接口调用（OpenFeign）、断路器（Hystrix）、消息驱动（Stream）、链路跟踪（Sleuth）、配置中心（Nacos）等多个方面。文章深入浅出地介绍了每个组件的用途、配置和实践操作，适合想要全面学习SpringCloud的开发者参考。
摘要由CSDN通过智能技术生成

SpringCloud

一、介绍

（一）cloud和boot之间的依赖关系

https://spring.io/projects/spring-cloud#overview

  • Finchley 是基于 Spring Boot 2.0.x 构建的不再 Boot 1.5.x
  • Dalston 和 Edgware 是基于 Spring Boot 1.5.x 构建的，不支持 Spring Boot 2.0.x
  • Camden 构建于 Spring Boot 1.4.x，但依然能支持 Spring Boot 1.5.x

image-20220123024227971

更详细的版本对应查看方法：https://start.spring.io/actuator/info

image-20220123024323186

（二）课程所用软件版本

  1. cloud：Hoxton.SR1
  2. boot：2.2.2.RELEASE
  3. cloud alibaba：2.1.0.RELEASE
  4. Java：Java8
  5. Maven：3.5及以上
  6. Mysql：5.7及以上

题外话：boot版已经到2.2.4为最新，为什么选2.2.2？

  1. 如果项目中只用到 boot，直接用最新
  2. 同时用boot和cloud，需要照顾cloud，由cloud决定boot版本

image-20220123024608286 image-20220123024911535

SpringCloud和SpringBoot版本对应关系

image-20220123024939313

（三）Cloud各种组件的停更/升级/替换

以前：

image-20220123025134516

现在（2020年）：

1641811794746

二、微服务架构编码构建

约定 > 配置 > 编码

（一）IDEA新建project工作空间

1、微服务cloud整体聚合父工程Project

（1）New Project

image-20220118235307862 image-20220119000150639 image-20220118235822453

（2）字符编码

image-20220119000408237

（3）注解生效激活

1641812377112

（4）java编译版本选8

1641809624397

（5）File Type过滤

image-20220119000546392

2、父工程POM

<?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>com.atguigu.springcloud</groupId>
    <artifactId>mscloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>cloud-provider-payment8001</module>
    </modules>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
    <dependencyManagement>
        <dependencies>
            <!--spring boot 2.2.2-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud Hoxton.SR1-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud alibaba 2.1.0.RELEASE-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.1.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring.boot.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <optional>true</optional>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <finalName>mscloud</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.5.RELEASE</version>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

如果有依赖下载不下来就先把 pom 文件中的<dependencyManagement> 注释掉，等下载完成后在取消注释即可

3、Maven工程落地细节复习

Maven中的DependencyManagement和Dependencies

dependencyManagement：

Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。

使用pom.xml 中的dependencyManagement 元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。

Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement 元素的项目，然后它就会使用这个
dependencyManagement 元素中指定的版本号。

1641813022727

这样做的好处就是：如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号，这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目的修改；另外如果某个子项目需要另外的一个版本，只需要声明version就可。

  •   dependencyManagement 里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖

  •   如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom

  •   如果子项目中指定了版本号，那么会使用子项目中指定的jar版本

maven中跳过单元测试

image-20220119001152702

父工程创建完成执行mvn:install将父工程发布到仓库方便子工程继承

（二）Rest微服务工程构建

1、支付模块8001

cloud-provider-payment8001 微服务提供者支付Module模块

建 cloud-provider-payment8001

image-20220119221007002

创建完成后请回到父工程查看pom文件变化

image-20220119221119247

（1）改POM
<?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">
    <parent>
        <artifactId>mscloud</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-payment8001</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
（2）写YML

application.yml

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud2021?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包
（3）主启动
package com.atguigu.springcloud;

@SpringBootApplication
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class,args);
    }
}
（4）建表

image-20220119222549864

CREATE TABLE `payment` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `serial` varchar(200) DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
（5）entities

主实体 Payment

package com.atguigu.springcloud.entities;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
    private Long id;
    private String serial;
}

Json封装体CommonResult

这个类是传递给前端的，前端不管什么 payment，它只要响应状态码、message…

package com.atguigu.springcloud.entities;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
    private Integer code;
    private String message;
    private T data;

    public CommonResult(Integer code, String message) {
        this(code, message, null);
    }
}
（6）controller
package com.atguigu.springcloud.controller;

@RestController
@Slf4j
@RequestMapping("/payment")
public class PaymentController {

    @Resource
    private PaymentService paymentService;

    @PostMapping("/create")
    public CommonResult create(Payment payment) {
        return paymentService.create(payment);
    }

    @GetMapping("/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id){
        return paymentService.getPaymentById(id);
    }
}

public CommonResult create(Payment payment)这里加@RequestBody测试的时候会报405

（7）service

PaymentService

package com.atguigu.springcloud.service;

public interface PaymentService {

    /**
     * 创建一个 payment
     * @param payment
     * @return
     */
    CommonResult create(Payment payment);

    /**
     * 根据 id 查询 payment
     * @param id
     * @return
     */
    CommonResult getPaymentById(Long id);
}

PaymentServiceImpl

@Service
@Slf4j
public class PaymentServiceImpl implements PaymentService {

    @Resource
    private PaymentDao paymentDao;

    @Override
    public CommonResult create(Payment payment) {
        int result = paymentDao.create(payment);
        log.info("*****插入操作返回结果:{}",result);
        if (result > 0) {
            return new CommonResult(200, "插入数据库成功", result);
        } else {
            return new CommonResult(444, "插入数据库失败", null);
        }
    }

    @Override
    public CommonResult getPaymentById(Long id) {
        Payment payment = paymentDao.getPaymentById(id);
        log.info("*****查询结果:{}", payment);
        if (payment != null) {
            return new CommonResult(200, "查询成功", payment);
        } else {
            return new CommonResult(444, "没有对应记录,查询ID: " + id, null);
        }
    }
}
（8）dao

PaymentDao

package com.atguigu.springcloud.dao;

@Mapper
public interface PaymentDao {

    /**
     * 创建一个 payment
     *
     * @param payment
     * @return
     */
    int create(Payment payment);

    /**
     * 根据 id 查询 payment
     *
     * @param id
     * @return
     */
    Payment getPaymentById(@Param("id") Long id);
}

PaymentMapper.xml

srcmain esourcesmapperPaymentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

<mapper namespace="com.atguigu.springcloud.dao.PaymentDao">
    <resultMap id="BaseResultMap" type="com.atguigu.springcloud.entities.Payment">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="serial" property="serial" jdbcType="VARCHAR"/>
    </resultMap>

    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyColumn="id">
        insert into payment(serial)
        values (#{serial})
    </insert>

    <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
        select id, serial
        from payment
        where id = #{id}
    </select>
</mapper>
（9）测试

postman模拟post

http://localhost:8001/payment/createserial=‘111’

image-20220120001120241

http://localhost:8001/payment/get/1

image-20220120001038440

（10）一些设置

image-20220120233020908

2、热部署Devtools

（1）8001的pom

之前已经添加了

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>
（2）父工程的pom

之前已经添加了

<build>
    <finalName>mscloud</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.5.RELEASE</version>
            <configuration>
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
    </plugins>
</build>
（3）自动编译

image-20220121000836843

（4）Update the value of

快捷键：ctrl+shift+alt+/

image-20220121001028891 image-20220121001151946

然后重启 IDEA

注意：开发阶段开启热部署，生产阶段必须关闭

3、订单模块80

cloud-consumer-order80 微服务消费者订单Module模块

image-20220121002413787

（1）改POM
<?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">
    <parent>
        <artifactId>mscloud</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-order80</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
（2）写YML

application.yml

server:
  port: 80
（3）主启动
package com.atguigu.springcloud;

@SpringBootApplication
public class MainApp80 {
    public static void main(String[] args) {
        SpringApplication.run(MainApp80.class, args);
    }
}
（4）entities

主实体 Payment

package com.atguigu.springcloud.entities;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
    private Long id;
    private String serial;
}

Json封装体CommonResult

这个类是传递给前端的，前端不管什么 payment，它只要响应状态码、message…

package com.atguigu.springcloud.entities;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
    private Integer code;
    private String message;
    private T data;

    public CommonResult(Integer code, String message) {
        this(code, message, null);
    }
}
（5）首说RestTemplate

是什么：

RestTemplate提供了多种便捷访问远程Http服务的方法， 是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集

官网地址：

https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

使用：

使用restTemplate访问restful接口非常的简单粗暴无脑

  • url：REST请求地址
  • requestMap：请求参数
  • ResponseBean.class：HTTP响应转换被转换成的对象类型
（6）config配置类

ApplicationContextConfig

package com.atguigu.springcloud.config;

@Configuration
public class ApplicationContextConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
（7）controller
@RestController
@Slf4j
@RequestMapping("/consumer")
public class OrderController {

    public static final String PaymentSrv_URL = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    /**
     * 客户端用浏览器是get请求，但是底层实质发送post调用服务端8001
     *
     * @param payment
     * @return
     */
    @GetMapping("/payment/create")
    public CommonResult<Payment> create(Payment payment) {
        return restTemplate.postForObject(PaymentSrv_URL + "/payment/create", payment, CommonResult.class);
    }

    @GetMapping("/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PaymentSrv_URL + "/payment/get/" + id,CommonResult.class,id);
    }
}

注意：/payment/get/路径中 get 后面的 / 不要忘了加，否则会一直报错

image-20220121005326776

image-20220121005418027

（8）测试

http://localhost/consumer/payment/get/1

http://localhost/consumer/payment/createserial=aaaaa1

image-20220122235915781

但是数据库中只有主键并没有数据

image-20220123000016123

8001中的 create 不要忘记@RequestBody注解

@PostMapping("/create")
public CommonResult create(@RequestBody Payment payment) {
    return paymentService.create(payment);
}

插入成功

image-20220123000203509

4、工程重构

（1）观察问题

image-20220123020257709

系统中有重复部分，重构

（2）cloud-api-commons

image-20220123021053758

pom.xml

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.1.0</version>
    </dependency>
</dependencies>

把 8001 和 80 的 entities 移到 commons 中

image-20220123021533643

maven命令clean install

image-20220123022241845

订单80和支付8001分别改造

  • 删除各自的原先有过的entities文件夹

  • 各自粘贴POM内容

    •   <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
      <groupId>com.atguigu.springcloud</groupId>
      <artifactId>cloud-api-commons</artifactId>
      <version>${project.version}</version>
  </dependency>

三、SpringCloud Eureka 服务注册与发现

（一）Eureka基础知识

1、什么是服务治理

Spring Cloud 封装了 Netflix 公司开发的 Eureka 模块来实现服务治理

在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

2、什么是服务注册

Eureka采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，它是服务注册中心。而系统中的其他微服务，使用 Eureka的客户端连接到 Eureka Server并维持心跳连接。这样系统的维护人员就可以通过 Eureka Server 来监控系统中各个微服务是否正常运行。

在服务注册与发现中，有一个注册中心。当服务器启动的时候，会把当前自己服务器的信息 比如 服务地址通讯地址等以别名方式注册到注册中心上。另一方（消费者|服务提供者），以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用RPC远程调用框架核心设计思想：在于注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址))

下左图是Eureka系统架构，右图是Dubbo的架构，请对比：

image-20220123025941829

3、Eureka两组件

Eureka包含两个组件：Eureka Server和Eureka Client

  • Eureka Server 提供服务注册服务

各个微服务节点通过配置启动后，会在EurekaServer中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到

  • EurekaClient 通过注册中心进行访问

是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒）

（二）单机Eureka构建步骤

1、eurekaServer端服务注册中心

IDEA生成eurekaServer端服务注册中心类似物业公司

（1）建Module

cloud-eureka-server7001

image-20220123030402591

（2）改POM
<?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">
    <parent>
        <artifactId>mscloud</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-eureka-server7001</artifactId>

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

    <dependencies>
        <!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--boot web actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--图形监控，以后的swagger和Hystrix要用的-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--一般通用配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>
</project>

1.X和2.X的对比说明：

以前的老版本（当前使用2018）
<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>


现在新版本（当前使用2020.2）
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
（3）写YML
server:
  port: 7001

eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    #false表示不向注册中心注册自己。
    register-with-eureka: false
    #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
    #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址。
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
（4）主启动
package com.atguigu.springcloud;

@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7001.class, args);
    }
}
（5）测试

http://localhost:7001/

image-20220123031503669

No application available 没有服务被发现，因为没有注册服务进来当然不可能有服务被发现

2、8001注册进Eureka成为提供者

EurekaClient 端 cloud-provider-payment8001 将注册进 EurekaServer 成为服务提供者 provider，类似尚硅谷学校对外提供授课服务

（1）改POM
<!--eureka-client-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
（2）写YML

application.yml

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      defaultZone: http://localhost:7001/eureka
（3）主启动
@EnableEurekaClient


package com.atguigu.springcloud;

@SpringBootApplication
@EnableEurekaClient
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class,args);
    }
}
（4）测试

先要启动EurekaServer，http://localhost:7001/

image-20220123120903795

微服务注册名配置说明

image-20220123121142942

（5）自我保护机制

image-20220123121247649

3、80注册进Eureka成为消费者

EurekaClient 端 cloud-consumer-order80 将注册进 EurekaServer 成为服务消费者 consumer，类似来尚硅谷上课消费的各位同学

（1）改POM
<!--eureka-client-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
（2）写YML

application.yml

server:
  port: 80

spring:
  application:
    name: cloud-order-service

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      defaultZone: http://localhost:7001/eureka
（3）主启动
@EnableEurekaClient


package com.atguigu.springcloud;

@SpringBootApplication
@EnableEurekaClient
public class MainApp80 {
    public static void main(String[] args) {
        SpringApplication.run(MainApp80.class, args);
    }
}
（4）测试

先要启动EurekaServer——7001服务，再要启动服务提供者provider——8001服务

image-20220123122247426

http://localhost/consumer/payment/get/31

image-20220123122320920

4、bug

Failed to bind properties under ‘eureka.client.service-url’ to java.util.Map<java.lang.String, java.lang.String>

image-20220123122714466

（二）集群Eureka构建步骤

1、Eureka集群原理说明

image-20220123123020106

问题：微服务RPC远程服务调用最核心的是什么？

高可用，试想你的注册中心只有一个only one， 它出故障了那就呵呵(￣▽￣)"了，会导致整个为服务环境不可用，所以解决办法：搭建Eureka注册中心集群 ，实现负载均衡+故障容错

2、EurekaServer集群环境构建步骤

（1）新建cloud-eureka-server7002

参考cloud-eureka-server7001，新建cloud-eureka-server7002

（2）改POM
<artifactId>cloud-eureka-server7002</artifactId>

父工程 mscloud 的 POM

<module>cloud-eureka-server7002</module>
（3）修改映射配置

找到C:WindowsSystem32driversetc路径下的hosts文件，修改映射配置添加进hosts文件

  • 127.0.0.1 eureka7001.com
  • 127.0.0.1 eureka7002.com

image-20220123125019978

（4）写YML

以前单机版：

image-20220123125614973

7001：

server:
  port: 7001

eureka:
  instance:
    hostname: eureka7001.com  #eureka服务端的实例名称
  client:
    register-with-eureka: false #false表示不向注册中心注册自己。
    fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7002.com:7002/eureka/

7002：

server:
  port: 7002

eureka:
  instance:
    hostname: eureka7002.com  #eureka服务端的实例名称
  client:
    register-with-eureka: false #false表示不向注册中心注册自己。
    fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/
（5）主启动
package com.atguigu.springcloud;

@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7002 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7002.class, args);
    }
}
（6）测试

image-20220123175252624

image-20220123130850066

3、8001发布到2台Eureka集群

application.yml

# 集群版
defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  


server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud2021?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

4、80发布到2台Eureka集群

application.yml

defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版


server:
  port: 80

spring:
  application:
    name: cloud-order-service

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版

5、测试01

先要启动EurekaServer，7001/7002服务，再要启动服务提供者provide——8001，最后再启动消费者——80

http://localhost/consumer/payment/get/1

image-20220123134613385

6、支付服务提供者8001集群环境构建

（1）新建cloud-provider-payment8002

参考cloud-provider-payment8001

pom.xml

<artifactId>cloud-provider-payment8002</artifactId>

application.yml

server:
  port: 8002

主启动

package com.atguigu.springcloud;

@SpringBootApplication
@EnableEurekaClient
public class PaymentMain8002 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8002.class,args);
    }
}
（2）修改8001/8002的PaymentServiceImpl

8001：

@Value("${server.port}")
private String serverPort;


package com.atguigu.springcloud.service.impl;

@Service
@Slf4j
public class PaymentServiceImpl implements PaymentService {
    
    @Resource
    private PaymentDao paymentDao;

    @Value("${server.port}")
    private String serverPort;

    @Override
    public CommonResult create(Payment payment) {
        int result = paymentDao.create(payment);
        log.info("*****插入操作返回结果:{}", result);
        if (result > 0) {
            return new CommonResult(200, "插入数据库成功，serverPort：" + serverPort, result);
        } else {
            return new CommonResult(444, "插入数据库失败", null);
        }
    }

    @Override
    public CommonResult getPaymentById(Long id) {
        Payment payment = paymentDao.getPaymentById(id);
        log.info("*****查询结果:{}", payment);
        if (payment != null) {
            return new CommonResult(200, "查询成功，serverPort：" + serverPort, payment);
        } else {
            return new CommonResult(444, "没有对应记录,查询ID: " + id, null);
        }
    }
}

8002：

同理

@Value("${server.port}")
private String serverPort;
（3）测试

http://eureka7001.com:7001/

image-20220123175603467

http://eureka7002.com:7002/

image-20220123175621348

http://localhost:8001/payment/get/1

image-20220123181118488

http://localhost:8002/payment/get/1

image-20220123181145608

http://localhost/consumer/payment/get/1

image-20220123181246895

（4）bug

我们发现不管怎么刷新请求，请求的端口号一直是8001，原因是我们在80的controller中写死了

image-20220123182702982

OrderController：

///不要把地址写死
//public static final String PaymentSrv_URL = "http://localhost:8001";
// 通过在eureka上注册过的微服务名称调用
public static final String PAYMENT_SRV = "http://CLOUD-PAYMENT-SERVICE";

此时再测试

image-20220123201948548

这又是什么情况？

现在注册中心不再是暴露出具体的端口号，而是微服务名称 CLOUD-PAYMENT-SERVICE，但是这个微服务名称代表的集群中有很多个，比如8001、8002…用哪个，它并不知道

image-20220123202535357

我们需要再配置一下负载均衡

7、负载均衡

（1）@LoadBalanced

使用 @LoadBalanced 注解赋予 RestTemplate 负载均衡的能力

cloud-consumer-order80

ApplicationContextConfig

@LoadBalanced //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力


package com.atguigu.springcloud.config;

@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
（2）测试

第一次

image-20220123203629529

第二次

image-20220123203723079

负载均衡效果达到，8001/8002端口交替出现

提前剧透：Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号，且该服务还有负载功能了。O(∩_∩)O

（三）actuator微服务信息完善

1、主机名称:服务名称修改

（1）当前问题

含有主机名称

image-20220123204237614

（2）修改8001和8002

8001：

application.yml

instance:
  instance-id: payment8001


server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud2021?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
  instance:
    instance-id: payment8001

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

同理，8002：

instance:
  instance-id: payment8002

再测试

image-20220123211341196

image-20220123211536534

2、访问信息有IP信息提示

（1）当前问题

没有IP提示

image-20220123204651752

（2）修改8001和8002

application.yml

prefer-ip-address: true     #访问路径可以显示IP地址


eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
  instance:
    instance-id: payment8001
    prefer-ip-address: true     #访问路径可以显示IP地址

image-20220123211851786

image-20220123211909332

（四）服务发现Discovery

对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息

1、修改8001和8002的Controller

加上

@Resource
private DiscoveryClient discoveryClient;

@GetMapping(value = "/discovery")
public Object discovery() {
    List<String> services = discoveryClient.getServices();
    for (String service : services) {
        log.info("service:{}", service);
    }
    List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
    for (ServiceInstance instance : instances) {
        log.info(instance.getServiceId() + "	" + instance.getHost() + "	" + instance.getPort() + "	"
                 + instance.getUri());
    }
    return this.discoveryClient;
}


package com.atguigu.springcloud.controller;

import org.springframework.cloud.client.discovery.DiscoveryClient;

@RestController
@Slf4j
@RequestMapping("/payment")
public class PaymentController {

    @Resource
    private PaymentService paymentService;

    @Resource
    private DiscoveryClient discoveryClient;

    @PostMapping("/create")
    public CommonResult create(@RequestBody Payment payment) {
        return paymentService.create(payment);
    }

    @GetMapping("/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id) {
        return paymentService.getPaymentById(id);
    }

    @GetMapping(value = "/discovery")
    public Object discovery() {
        List<String> services = discoveryClient.getServices();
        for (String service : services) {
            log.info("service:{}", service);
        }
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance instance : instances) {
            log.info(instance.getServiceId() + "	" + instance.getHost() + "	" + instance.getPort() + "	"
                    + instance.getUri());
        }
        return this.discoveryClient;
    }
}

2、主启动类

@EnableDiscoveryClient //服务发现

8001：

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient //服务发现
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class,args);
    }
}

8002同理

3、测试

image-20220123214547168

image-20220123214535831

（五）Eureka自我保护

1、故障现象

概述：保护模式主要用于一组客户端和Eureka Server之间存在网络分区场景下的保护。一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据，也就是不会注销任何微服务。

如果在Eureka Server的首页看到以下这段提示，则说明Eureka进入了保护模式

image-20220123215516917

2、导致原因

为什么会产生Eureka自我保护机制？

为了防止EurekaClient可以正常运行，但是 与 EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除

什么是自我保护模式？

默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。

在自我保护模式中，Eureka Server会保护服务注册表中的信息，不再注销任何服务实例。

它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话讲解：好死不如赖活着

综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留）也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮、稳定。

一句话：某时刻某一个微服务不可用了，Eureka不会立刻清理，依旧会对该微服务的信息进行保存

属于CAP里面的AP分支

3、怎么禁止自我保护

现在可以不用集群版了，只用开一个，在 application.yml 中把集群配置改为单机版

（1）注册中心eureakeServer端7001

出厂默认，自我保护机制是开启的 eureka.server.enable-self-preservation=true，使用eureka.server.enable-self-preservation = false 可以禁用自我保护模式

application.yml：

server:
  #关闭自我保护机制，保证不可用服务被及时踢除
  enable-self-preservation: false
  eviction-interval-timer-in-ms: 2000


server:
  port: 7001

eureka:
  instance:
    hostname: eureka7001.com  #eureka服务端的实例名称
  client:
    register-with-eureka: false #false表示不向注册中心注册自己。
    fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7002.com:7002/eureka/
  server:
    #关闭自我保护机制，保证不可用服务被及时踢除
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 2000

关闭效果：

image-20220123221232971

（2）生产者客户端eureakeClient端8001

默认配置：

eureka.instance.lease-renewal-interval-in-seconds=30 #单位为秒(默认是30秒)
eureka.instance.lease-expiration-duration-in-seconds=90 #单位为秒(默认是90秒)

配置：

#Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
lease-renewal-interval-in-seconds: 1
#Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
lease-expiration-duration-in-seconds: 2


server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud2021?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      defaultZone: http://localhost:7001/eureka
      #defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
  instance:
    instance-id: payment8001
    #访问路径可以显示IP地址
    prefer-ip-address: true
    #Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
    lease-renewal-interval-in-seconds: 1
    #Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
    lease-expiration-duration-in-seconds: 2

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

测试：

7001和8001都配置完成，先启动7001再启动8001

http://eureka7001.com:7001/

image-20220123222603823

模拟8001出现了故障关闭了，以前7001还会保留，但是现在：

image-20220123222749492

四、Zookeeper服务注册与发现

（一）Eureka停止更新了你怎么办

https://github.com/Netflix/eureka/wiki

image-20220123223011220

（二）SpringCloud整合Zookeeper代替Eureka

1、注册中心Zookeeper

zookeeper 暂时跳过，虚拟机没有装 zookeeper

五、SpringCloud Consul 服务注册与发现

（一）Consul简介

1、是什么

https://www.consul.io/intro/index.html

image-20220123230251771

Consul 是一套开源的分布式服务发现和配置管理系统，由 HashiCorp 公司用 Go 语言开发

提供了微服务系统中的服务治理、配置中心、控制总线等功能。这些功能中的每一个都可以根据需要单独使用，也可以一起使用以构建全方位的服务网格，总之Consul提供了一种完整的服务网格解决方案

它具有很多优点。包括： 基于 raft 协议，比较简洁； 支持健康检查, 同时支持 HTTP 和 DNS 协议 支持跨数据中心的 WAN 集群 提供图形界面 跨平台，支持 Linux、Mac、Windows

2、能干嘛

Spring Cloud Consul 具有如下特性：

image-20220123230402725

  • 服务发现：提供HTTP和DNS两种发现方式
  • 健康监测：支持多种方式，HTTP、TCP、Docker、Shell脚本定制化监控
  • KV存储：Key、Value的存储方式
  • 多数据中心：Consul支持多数据中心
  • 可视化Web界面

3、去哪下

https://www.consul.io/downloads.html

4、怎么玩

https://www.springcloud.cc/spring-cloud-consul.html

（二）安装并运行Consul

1、官网安装说明

https://learn.hashicorp.com/consul/getting-started/instal

最低0.47元/天 解锁文章
m0_54850467
关注
专栏目录
尚硅谷2020最新SpringCloud思维导图【第二季】（非官方版本，个人学习笔记）
05-26
个人学习过程中，从视频中摘录的，自认为是目前网上最好、最全的版本了。 我的开发环境是在Mac上，所以有个别地方和周阳老师不一样，但是我都会在备注中同时注明了周阳老师Windows的原版话术。 除个别视频中没有展开的内容，其他内容只多不少，还原度高达99%。 周阳老师思路清晰，整体贯穿讲下来值得大家学习和参考。我是老程序员，所以是开1.5到2的倍速看下来的，但是为了整理笔记确实也耗费了不少时间和精力。 配套的源码：https://github.com/wenren0819/Spring-Cloud-2020 分享出来目的不是骗分儿，是希望能够帮助到大家，
尚硅谷周阳老师SpringCloud笔记
08-31
该资源为尚硅谷周阳老师SpringCloud的学习笔记，内容很详细
尚硅谷SpringCloud第二季笔记
01-22
介绍了SpringCloud组件的使用
尚硅谷周阳老师 SpringCloud第二季学习笔记
热门推荐
小鲁蛋的博客
07-31 1万+
前言首先感谢尚硅谷周阳老师的讲解，让我对springcloud有了很好的理解，周阳老师的讲课风格真的很喜欢，内容充实也很幽默，随口一说就是一个段子，我也算是周阳老师的忠实粉丝啦。
尚硅谷springcloud第二季笔记_外行人都能看懂的SpringCloud，错过了血亏！
weixin_39540744的博客
11-23 296
一、前言只有光头才能变强这篇主要来讲讲SpringCloud的一些基础的知识。(我就是现学现卖了，主要当做我学习SpringCloud的笔记吧！)当然了，我的水平是有限的，可能会有一些理解错的的概念/知识点，还请大家不吝在评论区指正啊~~项目结构图：如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高级交流：8546...
《springcloud&学习资料》--尚硅谷SpringCloud视频学习笔记.zip
最新发布
04-19
无论做毕业设计还是用于学习技能，或工作中当做参考资料，都能发挥重要作用 亲们下载我任何一个付费资源后，即可私信联系我免费下载其他相关资源哦~ 个人花大量时间整理出的实战资料，内容丰富，文档也很详细。无论...
尚硅谷SpringCloud第2季2020版.mmap
12-12
一篇很好的springCloud学习的思维导读，详细的介绍了，springCloud的搭建步骤以及各组件的说明讲解 涵盖 Eureka服务注册与发现 Zookeeper服务注册与发现 Consul服务注册与发现 Ribbon负载均衡服务调用 OpenFeign...
尚硅谷SpringCloud第2季2020.3.2.mmap
05-07
新出的springcloud第二版很符合我现阶段的学习需求。但美中不足的是，目前只有视频资料，并没有周阳老师上课的脑图，一点一点跟着老师构建项目，稍有吃力。将目前学习的笔记整理，供自己日后复习，供大家参考。若有...
尚硅谷springcloud笔记
09-03
尚硅谷2018springcloud第一季笔记，可以xmind直接查看
尚硅谷周阳SpringCloud第一季笔记（超详细非官方手工笔记）
02-21
尚硅谷发布的周阳老师讲授的SpringCloud，讲的非常好，深入简出了解SpringCloud第一季核心技术，这个是本人在学习时亲手整理的笔记，希望对大家有帮助。
尚硅谷springcloud第二季笔记_外行人都能看懂的 Spring Cloud，错过了血亏
weixin_39741101的博客
11-22 612
一、前言这篇主要来讲讲SpringCloud的一些基础的知识(我就是现学现卖了，主要当做我学习SpringCloud的笔记吧！)当然了，我的水平是有限的，可能会有一些理解错的的概念/知识点，还请大家不吝在评论区指正啊~~SpringCloud GitHub Demo(看完文章的同学可以自己练手玩玩)：https://github.com/ZhongFuCheng3y/msc-Demo项目结构图：二...
尚硅谷SpringCloud第2季--openFeign
紫蝶侠的博客
10-19 718
openFeign服务接口调用 openFeign主要用在客服端进行接口调用 openFeign集成了Ribbon openFeign初步使用 依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId>
尚硅谷阳哥SpringCloud第二季学习笔记（一）
景鹏虎晓的博客
02-01 6645
一、微服务架构概述 1.什么是微服务架构 微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务于服务之间采用轻量级的通信机制互相协作（通常是基于HTTP协议的RESTful API）。每个服务都围绕着具体业务进行构建，并且能够被独立的部署到生产环境、类生产环境等。另外，应当尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具对其进行构建。 2.SpringCloud
新手学SpringCloud
github_39019743的博客
12-05 291
SpringCloud 一、前言 这篇主要来讲讲SpringCloud的一些基础的知识。如果你能坚持看完，我相信你一定会对SpringCloud有了一个很深刻的认识！(我就是现学现卖了，主要当做我学习SpringCloud的笔记吧！)当然了，我的水平是有限的，可能会有一些理解错的的概念/知识点，还请大家不吝在评论区指正啊~~ 二、集群/分布式/微服务/SOA是什么？ 像我这种技术小白，看到这些词(...
尚硅谷阳哥SpringCloud第二季学习笔记（二）
景鹏虎晓的博客
03-03 2966
导航目录一、Ribbon负载均衡服务调用1.1 概述1.1.1 是什么1.1.2 能干吗1.2 Ribbon的简单架构1.3 RestTemplate的使用1.4 Ribbon核心组件IRule1.4.1 如何替换1.5 Ribbon负载均衡算法1.5.1 原理1.5.2 自己实现轮询策略算法二、OpenFeign服务接口调用2.1 概述2.1.1 是什么2.1.2 Feign能干什么2.2 OpenFeign使用步骤2.2.1 新建module-->cloud-consumer-feign-orde
尚硅谷Springcloud学习笔记
weixin_45429720的博客
03-18 645
springCloud 和 springCloud Alibaba 目前是最主流的微服务框架组合。 版本选择： 选用 springboot 和 springCloud 版本有约束，不按照它的约束会有冲突。 调配环境: 1、java版本 2、注解生效激活 3、编码 第一个微服务架构 建模块 module 改 pom 写yml 主启动 业务类 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http:
【后端开发】尚硅谷 SpringCloud 学习笔记
知不足而奋进，望远山而前行
06-17 3449
中文官网： https://www.spring.cloud.cc/spring-cloud-consul.html英文官网：https://www.consul.io需要下载一个安装包查看版本启动是一个命令行界面,需要输入启动默认我们使用eureka的新版本时,它默认集成了ribbon:这个starter中集成了reibbon了我们也可以手动引入ribbon未完待续...
尚硅谷springcloud第二季笔记网盘分享
12-16
尚硅谷springcloud第二季笔记是一份非常有价值的学习资料，对于学习和理解Spring Cloud框架的人来说非常重要。通过这份笔记，我们可以更全面地了解Spring Cloud框架的各个组件和模块，掌握其核心原理和使用方法。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值