SpringCloud

最新推荐文章于 2023-11-16 16:25:42 发布
最新推荐文章于 2023-11-16 16:25:42 发布
阅读量131 收藏
点赞数
文章标签： java maven spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51072735/article/details/120538318
版权

文章目录

微服务

什么是微服务？

什么是微服务？

微服务(Microservice Architecture) 是近几年流行的一种架构思想，关于它的概念很难一言以蔽之。

究竟什么是微服务呢？我们在此引用ThoughtWorks 公司的首席科学家 Martin Fowler 于2014年提出的一段话：

原文：https://martinfowler.com/articles/microservices.html

汉化：https://www.cnblogs.com/liuning8023/p/4493156.html

就目前而言，对于微服务，业界并没有一个统一的，标准的定义。
但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它体长将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HTTP)互相沟通，每个服务都围绕着具体的业务进行构建，并且能狗被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应该根据业务上下文，选择合适的语言，工具(Maven)对其进行构建，可以有一个非常轻量级的集中式管理来协调这些服务，可以使用不同的语言来编写服务，也可以使用不同的数据存储。
再来从技术维度角度理解下：

微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。

微服务与微服务架构

微服务

强调的是服务的大小，它关注的是某一个点，是具体解决某一个问题/提供落地对应服务的一个服务应用，狭义的看，可以看作是IDEA中的一个个微服务工程，或者Moudel。IDEA 工具里面使用Maven开发的一个个独立的小Moudel，它具体是使用SpringBoot开发的一个小模块，专业的事情交给专业的模块来做，一个模块就做着一件事情。强调的是一个个的个体，每个个体完成一个具体的任务或者功能。

微服务架构

一种新的架构形式，Martin Fowler 于2014年提出。

微服务架构是一种架构模式，它体长将单一应用程序划分成一组小的服务，服务之间相互协调，互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务之间采用轻量级的通信机制**(如HTTP)互相协作，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具(如Maven)**对其进行构建。

微服务优缺点

优点

单一职责原则；
每个服务足够内聚，足够小，代码容易理解，这样能聚焦一个指定的业务功能或业务需求；
开发简单，开发效率高，一个服务可能就是专一的只干一件事；
微服务能够被小团队单独开发，这个团队只需2-5个开发人员组成；
微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的；
微服务能使用不同的语言开发；
易于和第三方集成，微服务允许容易且灵活的方式集成自动部署，通过持续集成工具，如jenkins，Hudson，bamboo；
微服务易于被一个开发人员理解，修改和维护，这样小团队能够更关注自己的工作成果，无需通过合作才能体现价值；
微服务允许利用和融合最新技术；
微服务只是业务逻辑的代码，不会和HTML，CSS，或其他的界面混合;
每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一的数据库；

缺点

开发人员要处理分布式系统的复杂性；
多服务运维难度，随着服务的增加，运维的压力也在增大；
系统部署依赖问题；
服务间通信成本问题；
数据一致性问题；
系统集成测试问题；
性能和监控问题；
2.4 微服务技术栈有那些？

微服务技术条目落地技术
服务开发SpringBoot、Spring、SpringMVC等
服务配置与管理Netfix公司的Archaius、阿里的Diamond等
服务注册与发现Eureka、Consul、Zookeeper等
服务调用Rest、PRC、gRPC
服务熔断器Hystrix、Envoy等
负载均衡Ribbon、Nginx等
服务接口调用(客户端调用服务的简化工具)Fegin等
消息队列Kafka、RabbitMQ、ActiveMQ等
服务配置中心管理SpringCloudConfig、Chef等
服务路由(API网关)Zuul等
服务监控Zabbix、Nagios、Metrics、Specatator等
全链路追踪Zipkin、Brave、Dapper等
数据流操作开发包SpringCloud Stream(封装与Redis，Rabbit，Kafka等发送接收消息)
时间消息总栈SpringCloud Bus
服务部署Docker、OpenStack、Kubernetes等

为什么选择SpringCloud作为微服务架构

选型依据

整体解决方案和框架成熟度
社区热度
可维护性
学习曲线

当前各大IT公司用的微服务架构有那些？
阿里：dubbo+HFS
京东：JFS
新浪：Motan
当当网：DubboX

…

各微服务框架对比

功能点/服务框架Netflix/SpringCloudMotangRPCThri tDubbo/DubboX
功能定位完整的微服务框架RPC框架，但整合了ZK或Consul，实现集群环境的基本服务注册发现RPC框架RPC框架服务框架
支持Rest是，Ribbon支持多种可拔插的序列号选择否否否否
支持RPC否是(Hession2)是是是
支持多语言是(Rest形式)否是是否
负载均衡是(服务端zuul+客户端Ribbon)，zuul-服务，动态路由，云端负载均衡Eureka（针对中间层服务器）是(客户端)否否是(客户端)
配置服务Netfix Archaius，Spring Cloud Config Server 集中配置是(Zookeeper提供)否否否
服务调用链监控是(zuul)，zuul提供边缘服务，API网关否否否否
高可用/容错是(服务端Hystrix+客户端Ribbon)是(客户端)否否是(客户端)
典型应用案例NetflixSinaGoogleFacebook
社区活跃程度高一般高一般2017年后重新开始维护，之前中断了5年
学习难度中等低高高低
文档丰富程度高一般一般一般高
其他Spring Cloud Bus为我们的应用程序带来了更多管理端点支持降级Netflix内部在开发集成gRPCIDL定义实践的公司比较多

SpringCloud

Spring Cloud 五大组件

  • 服务注册与发现——Netflix Eureka

  • 负载均衡：

    • 客户端负载均衡——Netflix Ribbon
    • 服务端负载均衡：——Feign(其也是依赖于Ribbon，只是将调用方式RestTemplete 更改成Service 接口)

  • 断路器——Netflix Hystrix

  • 服务网关——Netflix Zuul

  • 分布式配置——Spring Cloud Config

SpringCloud和SpringBoot的关系

SpringBoot专注于开苏方便的开发单个个体微服务；
SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务，整合并管理起来，为各个微服务之间提供：配置管理、服务发现、断路器、路由、为代理、事件总栈、全局锁、决策竞选、分布式会话等等集成服务；
SpringBoot可以离开SpringCloud独立使用，开发项目，但SpringCloud离不开SpringBoot，属于依赖关系；
SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架；

Dubbo 和 SpringCloud技术选型

  1. 分布式+服务治理Dubbo
    目前成熟的互联网架构，应用服务化拆分 + 消息中间件

  2. Dubbo 和 SpringCloud对比
    可以看一下社区活跃度：

    https://github.com/dubbo

    https://github.com/spring-cloud

对比结果：

DubboSpringCloud
服务注册中心ZookeeperSpring Cloud Netfilx Eureka
服务调用方式RPCREST API
服务监控Dubbo-monitorSpring Boot Admin
断路器不完善Spring Cloud Netfilx Hystrix
服务网关无Spring Cloud Netfilx Zuul
分布式配置无Spring Cloud Config
服务跟踪无Spring Cloud Sleuth
消息总栈无Spring Cloud Bus
数据流无Spring Cloud Stream
批量任务无Spring Cloud Task

最大区别：Spring Cloud 抛弃了Dubbo的RPC通信，采用的是基于HTTP的REST方式

严格来说，这两种方式各有优劣。虽然从一定程度上来说，后者牺牲了服务调用的性能，但也避免了上面提到的原生RPC带来的问题。而且REST相比RPC更为灵活，服务提供方和调用方的依赖只依靠一纸契约，不存在代码级别的强依赖，这个优点在当下强调快速演化的微服务环境下，显得更加合适。

品牌机和组装机的区别
社区支持与更新力度的区别

总结：二者解决的问题域不一样：Dubbo的定位是一款RPC框架，而SpringCloud的目标是微服务架构下的一站式解决方案。

SpringCloud能干嘛？

Distributed/versioned configuration 分布式/版本控制配置
Service registration and discovery 服务注册与发现
Routing 路由
Service-to-service calls 服务到服务的调用
Load balancing 负载均衡配置
Circuit Breakers 断路器
Distributed messaging 分布式消息管理
…

SpringCloud下载

官网：http://projects.spring.io/spring-cloud/
SpringCloud没有采用数字编号的方式命名版本号，而是采用了伦敦地铁站的名称，同时根据字母表的顺序来对应版本时间顺序，比如最早的Realse版本：Angel，第二个Realse版本：Brixton，然后是Camden、Dalston、Edgware，目前最新的是Hoxton SR4 CURRENT GA通用稳定版。
自学参考书：
SpringCloud Netflix 中文文档：https://springcloud.cc/spring-cloud-netflix.html
SpringCloud 中文API文档(官方文档翻译版)：https://springcloud.cc/spring-cloud-dalston.html
SpringCloud中国社区：http://springcloud.cn/
SpringCloud中文网：https://springcloud.cc

Rest环境搭建

  1. 首先创建一个空的maven项目作为副项目，配置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.wcy</groupId>
    <artifactId>SpringCloud</artifactId>
    <version>1.0-SNAPSHOT</version>

    <modules>
        <module>SpringCloud-API</module>
        <module>SpringCloud-Provider-Dept-8001</module>
        <module>SpringCloud-Consumer-Dept-80</module>
        <module>SpringBoot-Eureka-7001</module>
        <module>SpringBoot-Eureka-7002</module>
        <module>SpringBoot-Eureka-7003</module>
        <module>SpringCloud-Provider-Dept-8002</module>
        <module>SpringCloud-Provider-Dept-8003</module>
    </modules>

    <!--打包方式pom-->
    <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>

        <!--版本管理-->
        <junit.version>4.13</junit.version>
        <lombok.version>1.18.20</lombok.version>
        <log4j.version>1.2.17</log4j.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--SpringCloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR12</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--springboot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.12.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.25</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.6</version>
            </dependency>
            <!--spring starter-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.2.0</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!--日志相关-->
            <!--junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <!--log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.5</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

</project>

API

  1. 在项目中创建一个名为SpringCloud-API的项目，配置pom文件
<!--当前module中的依赖如果父依赖中已经指定版本，这里就无需指定-->
<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>
  1. 创建数据库db-01，并创建一张表dept
create table dept
(
    no        bigint auto_increment
        primary key,
    name      char(20) null,
    db_source char(20) null
);

insert into dept (name, db_source) values ('开发部', DATABASE());
insert into dept (name, db_source) values ('运维部', DATABASE());
insert into dept (name, db_source) values ('财务部', DATABASE());
insert into dept (name, db_source) values ('市场部', DATABASE());
insert into dept (name, db_source) values ('人事部', DATABASE());
  1. 创建实体类
package com.wcy.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

/**
 * 务必实现 Serializable 接口
 */
@Data
@NoArgsConstructor
@Accessors(chain = true)   // 这个注解可以实现链式编程
public class Dept implements Serializable {
    private long no;            // 编号
    private String name;        // 名称
    private String db_source;   // 所在的数据库名称

    public Dept(String name) {
        this.name = name;
    }
}

创建完成

服务提供者

  1. 继续创建一个新的空module:SpringCloud-Provider-Dept-8001，导入依赖
<dependencies>
        <!--拿到我们自己写的API项目中的实体类-->
        <dependency>
            <groupId>com.wcy</groupId>
            <artifactId>SpringCloud-API</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        
        <!--数据库相关-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--jetty 和tomcat的作用相同-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
  1. 编写项目配置文件application.xml
# 服务端口
server:
  port: 8001

# mybatis 配置
mybatis:
  type-aliases-package: com.wcy.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

# spring配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/db-01?useUnicode=true&chracterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
  1. 编写mybatis的配置文件mybatis-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>
  1. 编写Mapper层
@Repository
@Mapper
public interface DeptMapper {

    boolean addDept(Dept dept);

    Dept getDeptByNo(@Param("no") Long no);

    boolean updateDept(Dept dept);

    boolean delDeptByNo(@Param("no") Long no);

    List<Dept> getAllDept();
}
  1. 编写Mapper配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wcy.springcloud.mapper.DeptMapper">
    <insert id="addDept" parameterType="Dept">
        insert into dept (`name`, `db_source`)
        values (#{name}, DATABASE());
    </insert>
    <select id="getDeptByNo" resultType="Dept" parameterType="Long">
        select *
        from dept
        where `no`=#{no};
    </select>
    <update id="updateDept" parameterType="Dept">
        update dept
        set `name` = #{name}
        where `no`=#{no};
    </update>
    <delete id="delDeptByNo" parameterType="Long">
        delete
        from dept
        where `no`=#{no};
    </delete>
    <select id="getAllDept" resultType="Dept">
        select *
        from dept;
    </select>
</mapper>
  1. 编写service层
public interface DeptService {

    boolean addDept(Dept dept);

    Dept getDeptByNo(@Param("no") Long no);

    boolean updateDept(Dept dept);

    boolean delDeptByNo(@Param("no") Long no);

    List<Dept> getAllDept();

}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    DeptMapper deptMapper;

    @Override
    public boolean addDept(Dept dept) {
        return deptMapper.addDept(dept);
    }

    @Override
    public Dept getDeptByNo(Long no) {
        return deptMapper.getDeptByNo(no);
    }

    @Override
    public boolean updateDept(Dept dept) {
        return deptMapper.updateDept(dept);
    }

    @Override
    public boolean delDeptByNo(Long no) {
        return deptMapper.delDeptByNo(no);
    }

    @Override
    public List<Dept> getAllDept() {
        return deptMapper.getAllDept();
    }
}
  1. 编写controller
@RestController
@RequestMapping("/dept")
public class DeptController {

    @Autowired
    DeptService deptService;

    @PostMapping("/add")
    public boolean add(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("/all")
    public List<Dept> getAll(){
        return deptService.getAllDept();
    }

    @GetMapping("/get/{no}")
    public Dept get(@PathVariable("no") long no){
        return deptService.getDeptByNo(no);
    }
}
  1. 编写springboot的主启动类，注意要和三层所在的包同级
@SpringBootApplication
public class DeptProvider8001 {

    public static void main(String[] args) {
        SpringApplication.run(DeptProvider8001.class, args);
    }
}

在这里插入图片描述
9. 启动测试
访问 localhost:8001/dept/get/1 localhost:8001/dept/all
能获取到对应的部门信息就配置成功了

服务消费者

  1. 创建项目SpringCloud-Consumer-Dept-80
<dependencies>

        <dependency>
            <groupId>com.wcy</groupId>
            <artifactId>SpringCloud-API</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
  1. 项目配置
    80端口是http的默认端口
server:
  port: 80

3.创建config包，配置bean
需要使用RestTemplate来实现远程请求

package com.wcy.springcloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}
  1. 创建controller
package com.wcy.springcloud.controller;

import com.wcy.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("/consumer/dept")
public class DeptController {

    // 使用RestTemplate访问远程http服务
    @Autowired
    RestTemplate restTemplate;

    // 服务提供者的url前缀
    static final String PROVIDER_REST_URL_PREFIX = "http://localhost:8001/dept";

    @RequestMapping("/add")
    public Boolean add(Dept dept){
        // 发送post请求
        // 服务端地址 需要发送的数据 返回的类型
        System.out.println(dept);
        return restTemplate.postForObject(
                PROVIDER_REST_URL_PREFIX + "/add",
                dept,
                Boolean.class
        );
    }

    @RequestMapping("/get/{no}")
    public Dept get(@PathVariable("no") Long no){
        // get请求
        return restTemplate.getForObject(
                PROVIDER_REST_URL_PREFIX + "/get/" + no,
                Dept.class
        );
    }

    @RequestMapping("/all")
    public List<Dept> getAll(){
        return restTemplate.getForObject(
                PROVIDER_REST_URL_PREFIX + "/all",
                List.class
        );
    }

}
  1. 主启动类
@SpringBootApplication
public class DeptConsumer80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80.class, args);
    }
}
  1. 测试
    http://localhost/consumer/dept/add?name=游戏部
    http://localhost/consumer/dept/get/1
    http://localhost/consumer/dept/all
    能够返回对应的数据即成功

Eureka

Eureka服务器

  1. 创建SpringBoot-Eureka-7001项目
<dependencies>
        <!--eureka-->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
  1. 配置文件
server:
  port: 7001

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
        defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  1. 主启动类
    主启动类一定要记得@EnableEurekaServer开启服务
package com.wcy.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class Eureka7001 {

    public static void main(String[] args) {
        SpringApplication.run(Eureka7001.class, args);
    }
}
  1. 测试http://localhost:7001/
    在这里插入图片描述

Eureka客户端

将我们8001端口上的服务注册到Eureka服务器中

  1. 在项目SpringCloud-Provider-Dept-8001添加依赖
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-client -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
  1. 配置
# spring配置
spring:
  application:
    name: SpringCloud-Provider-Dept-8001 # 该服务的名称

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/  # 注册的地址
  1. 开启Eureka客户端 @EnableEurekaClient
@SpringBootApplication
@EnableEurekaClient
public class DeptProvider8001 {

    public static void main(String[] args) {
        SpringApplication.run(DeptProvider8001.class, args);
    }
}
  1. 启动Eureka服务器，在启动8001上的服务
    访问http://localhost:7001/
    在这里插入图片描述
    可以发现服务已经注册成功
    1处是我们配置的服务名称
    2处是默认的描述
    可以通过配置文件来更改2处的描述
# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: SpringCloud-Provider-Dept-8001 # 更改描述

在这里插入图片描述
点击链接会出现404页面，是因为还没有配置actuator
配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

在配置文件中配置

# info配置 自定义键值对
info:
  app.name: DeptProvider8001
  app.function: provide dept service for comsumer
  company.name: com.wcy
# 开启端点 不开启的话还是404
management:
  endpoints:
    web:
      exposure:
        include: "*"  # 开启所有

端点的配置

选择若干个要开启的端点
management.endpoints.web.exposure.include=["auditevents","health","info"]

开启全部端点
management.endpoints.web.exposure.include=*

在yaml中,需要加上""：
management.endpoints.web.exposure.include="*"

如果想要enable /shutdown端点：
management.endpoint.shutdown.enabled=true

如果想要暴露所有enable的web端点除了env
management.endpoints.web.exposure.include=*
management.endpoints.web.exposure.exclude=env

配置完成重启
点击详情链接，会出现我们配置的信息

在这里插入图片描述

获取微服务信息

在实际的开发中，需要获取微服务的信息，可以使用DiscoverClient来获取
在8001服务的控制器中添加一个方法

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

@Autowired
DiscoveryClient discoveryClient;

// 获取注册进来的微服务信息
@GetMapping("/discovery")
public Object discovery() {
    // 获取所有的微服务列表
    List<String> services = discoveryClient.getServices();
    System.out.println("discoveryServices====>" + services);
    // 通过微服务名称application.name 获取指定的微服务信息
    List<ServiceInstance> instances = discoveryClient.getInstances("SpringCloud-Provider-Dept-8001");
    for (ServiceInstance instance : instances) {
        System.out.println("----------------------------------------");
        System.out.println("ServiceId:" + instance.getServiceId());
        System.out.println("Host:" + instance.getHost());
        System.out.println("Uri:" + instance.getUri());
        System.out.println("----------------------------------------");
    }
    return discoveryClient;
}

重启后访问http://localhost:8001/dept/discovery
获取到了所有的微服务信息，目前只有这一个
在这里插入图片描述
后台打印也获取到了我们制定的微服务信息
在这里插入图片描述

Eureka集群配置

在实际中，我们不可能将所有服务注册到一个服务器上，而是同时注册到多个服务器上，这样当其中一个服务崩了之后还有其他的可以使用
模拟集群配置

  1. 再创建两个和SpringBoot-Eureka-7001一样的项目，SpringBoot-Eureka-7002，SpringBoot-Eureka-7003，导入同样的包
    在这里插入图片描述

  2. 修改一下hosts文件，模拟三个服务
    在这里插入图片描述

  3. eureka配置文件

每一个服务都和另外的两个关联

7001

server:
  port: 7001

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
        # 单个配置 http://${eureka.instance.hostname}:${server.port}/eureka/
        # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
        # 集群配置
        defaultZone: http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/

7002

server:
  port: 7002

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
        # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
        defaultZone: http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/

7003

server:
  port: 7003

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      defaultZone: http://eureka7002:7002/eureka/,http://eureka7001:7001/eureka/
  1. 8001服务提供者配置
# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: SpringCloud-Provider-Dept-8001 # 更改描述

注册到三个服务端

  1. 启动7001， 7002， 7003， 8001测试
    可以看到每个服务端都和另外两个关联
    在这里插入图片描述
    一个简单的eureka集群就搭建好了

Ribbon负载均衡(基于客户端)

现在我们的服务被注册到了三个服务端上，用户访问时，会向其中的服务端请求，如果请求多了，并且如果一直都是向其中一个服务器请求，那么服务器的负载就会过重，我们需要将请求平均的分配到所有服务器上。

客户请求

  1. 在80项目请求中添加eureka依赖，这个依赖包含了ribbon
<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
  1. 配置
server:
  port: 80

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
    register-with-eureka: false # 不向eureka注册自己
  1. 在RestTemplate 添加@LoadBalanced 注解
@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced  // ribbon
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}
  1. 开启服务
@SpringBootApplication
@EnableEurekaClient
public class DeptConsumer80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80.class, args);
    }
}

使用Ribbon来实现负载均衡

  1. 首先在添加两个服务提供者8002, 8003
    在这里插入图片描述
  2. 添加两个数据库db-02 , db-03, 内容和db-01一样
  3. 将配置文件中的端口，和服务描述修改一下即可
# 服务端口
server:
  port: 8002

# mybatis 配置
mybatis:
  type-aliases-package: com.wcy.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

# spring配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/db-02?useUnicode=true&chracterEncoding=UTF-8&useSSL=true
    driver-class-name: com.mysql.cj.jdbc.Driver
  application:
    name: SpringCloud-Provider-Dept-8001

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: SpringCloud-Provider-Dept-8002 # 更改描述

# info配置 自定义键值对
info:
  app.name: DeptProvider8001
  app.function: provide dept service for comsumer
  company.name: com.wcy
# 开启端口
management:
  endpoints:
    web:
      exposure:
        include: "*"
  1. 在80客户消费者中指定负载均衡的规则
    有如下这么多种
    在这里插入图片描述
@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced  // ribbon
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

	/**
     * IRule:
     * RoundRobinRule 轮询策略
     * RandomRule 随机策略
     * AvailabilityFilteringRule ： 会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
     * RetryRule ： 会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试
     */
    @Bean
    public IRule iRule(){
//        return new RoundRobinRule();
        return new RandomRule();
    }
}

这里使用随机分配，每次访问都会随机分配服务器

自定义负载均衡规则

使用ribbon自定义负载均衡的规则
首先创建一个配置类，注意该配置类不能和主启动类同级，也就是说不能扫描到该配置类，需要我们手动配置
在这里插入图片描述

@Configuration
public class MyRule {

    @Bean
    public IRule ribbonRule(){
        return new MyRandomRule();
    }

}

自定义的负载均衡

public class MyRandomRule extends AbstractLoadBalancerRule {

    /**
     * 每个服务访问5次则换下一个服务(总共3个服务)
     * <p>
     * total=0,默认=0,如果=5,指向下一个服务节点
     * index=0,默认=0,如果total=5,index+1
     */

    private int total = 0;          //被调用的次数
    private int currentIndex = 0;   //当前是谁在提供服务

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers(); // 获取活着的服务
            List<Server> allList = lb.getAllServers();      // 获取所有的服务

            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.
                 */
                return null;
            }

            // int index = chooseRandomInt(serverCount);
            // server = upList.get(index);

            //=============自定义负载规则===================
            if (total < 5){
                server = upList.get(currentIndex);
                total += 1;
            }else {
                total = 0;
                currentIndex += 1;
                if (currentIndex > upList.size() - 1){
                    currentIndex = 0;
                }
                server = upList.get(currentIndex);
            }
            //============================================

            if (server == null) {
                /*
                 * The only time this should happen is if the server list were
                 * somehow trimmed. This is a transient condition. Retry after
                 * yielding.
                 */
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }

        return server;

    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub

    }
}

配置主启动类

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT-8001", configuration = MyRule.class)
public class DeptConsumer80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80.class, args);
    }
}

这里的name名称需要和eureka中的注册的名称一样
在这里插入图片描述

Feign负载均衡(基于服务端)

Feign是声明式Web Service客户端，它让微服务之间的调用变得更简单，类似controller调用service。SpringCloud集成了Ribbon和Eureka，可以使用Feigin提供负载均衡的http客户端

只需要创建一个接口，然后添加注解即可

Feign主要是社区版，大家都习惯面向接口编程。这个是很多开发人员的规范。
调用微服务访问两种方法

  1. 微服务名字 【ribbon】
  2. 接口和注解 【feign】

Feign能干什么

Feign旨在使编写Java Http客户端变得更容易
前面在使用Ribbon + RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一个客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步的封装，由他来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它 (类似以前Dao接口上标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解)，即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon 时，自动封装服务调用客户端的开发量。

Feign默认集成了Ribbon
利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而简单的实现了服务调用

使用Feign

  1. 首先创建一个新的模块SpringCloud-Consumer-Feign，可以复制SpringCloud-Consumer-Dept-80模块，并再导入Feign的依赖
<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
  1. 在SpringCloud-API模块中做一些更改，添加一个Service接口
    注意：FeignClient中的服务名字，就是在eureka中注册的名字，路径要和服务提供者中的路径一样
@Component
@FeignClient(name = "SPRINGCLOUD-PROVIDER-DEPT-8001")
public interface DeptClientService {

    @PostMapping("/dept/add")
    boolean addDept(Dept dept);

    @GetMapping("/dept/get/{no}")
    Dept getDeptByNo(@PathVariable("no") Long no);

    @GetMapping("/dept/all")
    List<Dept> getAllDept();

}
  1. 将SpringCloud-Consumer-Feign中controller改为接口风格
@RestController
@RequestMapping("/consumer/dept")
public class DeptController {

    @Autowired
    DeptClientService deptClientService;

    @PostMapping("add")
    public boolean add(Dept dept){
        return deptClientService.addDept(dept);
    }

    @GetMapping("/all")
    public List<Dept> getAll(){
        return deptClientService.getAllDept();
    }

    @GetMapping("/get/{no}")
    public Dept get(@PathVariable("no") Long no){
        return deptClientService.getDeptByNo(no);
    }

}
  1. 主启动类中的配置
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = "com.wcy.springcloud")
public class DeptConsumerFeign {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumerFeign.class, args);
    }
}

4.测试，开启我们的Feign消费者，同样可以访问到信息

Feign和Ribbon如何选择

根据个人习惯而定，如果喜欢REST风格使用Ribbon；如果喜欢社区版的面向接口风格使用Feign.

Feign 本质上也是实现了 Ribbon，只不过后者是在调用方式上，为了满足一些开发者习惯的接口调用习惯

Hystrix：服务熔断

分布式系统面临的问题

复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免失败！

服务雪崩

多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其他的微服务，这就是所谓的“扇出”，如果扇出的链路上某个微服务的调用响应时间过长，或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的“雪崩效应”。

对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几十秒内饱和。比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障，这些都表示需要对故障和延迟进行隔离和管理，以达到单个依赖关系的失败而不影响整个应用程序或系统运行。

什么是Hystrix

Hystrix是一个应用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时，异常等，Hystrix 能够保证在一个依赖出问题的情况下，不会导致整个体系服务失败，避免级联故障，以提高分布式系统的弹性。

“断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控 (类似熔断保险丝) ，向调用方返回一个服务预期的，可处理的备选响应 (FallBack) ，而不是长时间的等待或者抛出调用方法无法处理的异常，这样就可以保证了服务调用方的线程不会被长时间，不必要的占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

Hystrix能干嘛

服务降级
服务熔断
服务限流
接近实时的监控
…

服务熔断

什么是服务熔断?
熔断机制是赌赢雪崩效应的一种微服务链路保护机制。

当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况，当失败的调用到一定阀值缺省是5秒内20次调用失败，就会启动熔断机制。熔断机制的注解是：@HystrixCommand。

服务熔断解决如下问题：

当所依赖的对象不稳定时，能够起到快速失败的目的；
快速失败后，能够根据一定的算法动态试探所依赖对象是否恢复。

使用Hystrix

  1. 复制一份SpringCloud-Provider-Dept-8001项目名为SpringCloud-Provider-Dept-Hystrix-8001，添加hystrix依赖
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>
  1. 配置文件
# 服务端口
server:
  port: 8001

# mybatis 配置
mybatis:
  type-aliases-package: com.wcy.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

# spring配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/db-01?useUnicode=true&chracterEncoding=UTF-8&useSSL=true
    driver-class-name: com.mysql.cj.jdbc.Driver
  application:
    name: SpringCloud-Provider-Dept-8001

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: SpringCloud-Provider-Dept-Hystrix-8001 # 更改描述
    prefer-ip-address: true  # 显示ip地址

# info配置 自定义键值对
info:
  app.name: DeptProvider8001
  app.function: provide dept service for comsumer
  company.name: com.wcy
# 开启端口
management:
  endpoints:
    web:
      exposure:
        include: "*"

prefer-ip-address: true
可以显示ip地址
在这里插入图片描述

  1. 控制器
@RestController
@RequestMapping("/dept")
public class DeptController {

    @Autowired
    DeptService deptService;

    /*
    如果出错就走备用方案hystrixGet
     */
    @HystrixCommand(fallbackMethod = "hystrixGet")
    @GetMapping("/get/{no}")
    public Dept get(@PathVariable("no") Long no) {
        Dept dept = deptService.getDeptByNo(no);
        if (dept == null) {
            throw new RuntimeException("no为" + no + "的用户不存在！");
        }
        return dept;
    }

    /**
     * 备用方案
     */
    public Dept hystrixGet(@PathVariable("no") Long no) {
        return new Dept().setNo(no)
                .setName("这个no=>" + no + ",没有对应的信息,null---@Hystrix~")
                .setDb_source("在MySQL中没有这个数据库");
    }

}
  1. 主启动类开启熔断支持
@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
@EnableCircuitBreaker  // 熔断的支持注解
public class DeptProviderHystrix8001 {

    public static void main(String[] args) {
        SpringApplication.run(DeptProviderHystrix8001.class, args);
    }

}
  1. 测试，打开Hystrix的服务提供者
    当访问不存在的信息时，依然会返回我们备用的值
    在这里插入图片描述
    而如果是没有使用Hystrix的提供者，那么就会出现服务器的500错误

服务降级

什么是服务降级

服务降级是指 当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理，或换种简单的方式处理，从而释放服务器资源以保证核心业务正常运作或高效运作。说白了，就是尽可能的把系统资源让给优先级高的服务。

资源有限，而请求是无限的。如果在并发高峰期，不做服务降级处理，一方面肯定会影响整体服务的性能，严重的话可能会导致宕机某些重要的服务不可用。所以，一般在高峰期，为了保证核心功能服务的可用性，都要对某些服务降级处理。比如当双11活动时，把交易无关的服务统统降级，如查看蚂蚁深林，查看历史订单等等。

服务降级主要用于什么场景呢？当整个微服务架构整体的负载超出了预设的上限阈值或即将到来的流量预计将会超过预设的阈值时，为了保证重要或基本的服务能正常运行，可以将一些 不重要 或 不紧急 的服务或任务进行服务的 延迟使用 或 暂停使用。

降级的方式可以根据业务来，可以延迟服务，比如延迟给用户增加积分，只是放到一个缓存中，等服务平稳之后再执行 ；或者在粒度范围内关闭服务，比如关闭相关文章的推荐。

服务降级需要考虑的问题

1）那些服务是核心服务，哪些服务是非核心服务
2）那些服务可以支持降级，那些服务不能支持降级，降级策略是什么
3）除服务降级之外是否存在更复杂的业务放通场景，策略是什么？

自动降级分类

1）超时降级：主要配置好超时时间和超时重试次数和机制，并使用异步机制探测回复情况

2）失败次数降级：主要是一些不稳定的api，当失败调用次数达到一定阀值自动降级，同样要使用异步机制探测回复情况

3）故障降级：比如要调用的远程服务挂掉了（网络故障、DNS故障、http服务返回错误的状态码、rpc服务抛出异常），则可以直接降级。降级后的处理方案有：默认值（比如库存服务挂了，返回默认现货）、兜底数据（比如广告挂了，返回提前准备好的一些静态页面）、缓存（之前暂存的一些缓存数据）

4）限流降级：秒杀或者抢购一些限购商品时，此时可能会因为访问量太大而导致系统崩溃，此时会使用限流来进行限制访问量，当达到限流阀值，后续请求会被降级；降级后的处理方案可以是：排队页面（将用户导流到排队页面等一会重试）、无货（直接告知用户没货了）、错误页（如活动太火爆了，稍后重试）

使用自动降级

  1. 在SpringCloud-API的service包中添加一个DeptClientServiceFallBackFactory
@Component
public class DeptClientServiceFallBackFactory implements FallbackFactory<Object> {
    @Override
    public Object create(Throwable throwable) {
        return new DeptClientService() {
            @Override
            public boolean addDept(Dept dept) {
                return false;
            }

            @Override
            public Dept getDeptByNo(Long no) {
                return new Dept()
                        .setNo(no)
                        .setName("id=>" + no + "没有对应的信息，客户端提供了降级的信息，这个服务现在已经被关闭")
                        .setDb_source("没有数据");
            }

            @Override
            public List<Dept> getAllDept() {
                return null;
            }
        };
    }
}
  1. 在DeptClientService中指定降级配置类DeptClientServiceFallBackFactory
//fallbackFactory指定降级配置类
@Component
@FeignClient(name = "SPRINGCLOUD-PROVIDER-DEPT-8001", fallbackFactory = DeptClientServiceFallBackFactory.class)
public interface DeptClientService {

    @PostMapping("/dept/add")
    boolean addDept(Dept dept);

    @GetMapping("/dept/get/{no}")
    Dept getDeptByNo(@PathVariable("no") Long no);

    @GetMapping("/dept/all")
    List<Dept> getAllDept();

}
  1. SpringCloud-Consumer-Feign中开启服务降级
# 开启服务降级
feign:
  hystrix:
    enabled: true

服务熔断和降级的区别

服务熔断—>服务端：某个服务超时或异常，引起熔断~，类似于保险丝(自我熔断)
服务降级—>客户端：从整体网站请求负载考虑，当某个服务熔断或者关闭之后，服务将不再被调用，此时在客户端，我们可以准备一个 FallBackFactory ，返回一个默认的值(缺省值)。会导致整体的服务下降，但是好歹能用，比直接挂掉强。

  • 触发原因不太一样，服务熔断一般是某个服务（下游服务）故障引起，而服务降级一般是从整体负荷考虑；管理目标的层次不太一样，熔断其实是一个框架级的处理，每个微服务都需要（无层级之分），而降级一般需要对业务有层级之分（比如降级一般是从最外围服务开始）
  • 实现方式不太一样，服务降级具有代码侵入性(由控制器完成/或自动降级)，熔断一般称为自我熔断。
    熔断，降级，限流：

限流：限制并发的请求访问量，超过阈值则拒绝；

降级：服务分优先级，牺牲非核心服务（不可用），保证核心服务稳定；从整体负荷考虑；

熔断：依赖的下游服务故障触发熔断，避免引发本系统崩溃；系统自动执行和恢复

Dashboard 流监控

  1. 新建SpringCloud-Consumer-Hystrix-HashBoard模块
<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.wcy</groupId>
            <artifactId>SpringCloud-API</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
  1. 配置文件
server:
  port: 9001


hystrix:
  dashboard:
    proxy-stream-allow-list: '*'
  1. 主启动类
@SpringBootApplication
@EnableHystrixDashboard  // 开启dashboard
public class HashBoard9001 {
    public static void main(String[] args) {
        SpringApplication.run(HashBoard9001.class, args);
    }
}
  1. 在SpringCloud-Provider-Dept-Hystrix-8001的主启动类中
@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
@EnableCircuitBreaker  // 熔断的支持注解
public class DeptProviderHystrix8001 {

    public static void main(String[] args) {
        SpringApplication.run(DeptProviderHystrix8001.class, args);
    }

    @Bean
    public ServletRegistrationBean<HystrixMetricsStreamServlet> registrationBean(){
        ServletRegistrationBean<HystrixMetricsStreamServlet> servletRegistrationBean = new ServletRegistrationBean<>(new HystrixMetricsStreamServlet());
        servletRegistrationBean.addUrlMappings("/actuator/hystrix.stream");
        return servletRegistrationBean;
    }

}

进入http://localhost:9001/hystrix

Zuul路由网关

什么是zuul

Zull包含了对请求的路由(用来跳转的)和过滤两个最主要功能：

其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础，而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。Zuul和Eureka进行整合，将Zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。

注意：Zuul 服务最终还是会注册进 Eureka

提供：代理 + 路由 + 过滤 三大功能

Zuul 能干嘛

  • 路由
  • 过滤

使用zuul

创建SpringBoot-Zuul-9527模块

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.wcy</groupId>
            <artifactId>SpringCloud-API</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-zuul -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>

    </dependencies>

配置文件

server:
  port: 9527
spring:
  application:
    name: springcloud-zuul #微服务名称

# eureka 注册中心配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance: #实例的id
    instance-id: zuul9527.com
    prefer-ip-address: true # 显示ip

info:
  app.name: com.wcy.springcloud # 项目名称
  company.name: com.wcy # 公司名称

# zuul 路由网关配置
zuul:
  # 路由相关配置
  # 原来访问路由 eg:http://localhost:9527/springcloud-provider-dept/dept/get/1
  # zuul路由配置后访问路由 eg:http://localhost:9527/haust/mydept/dept/get/1
  routes:
    mydept.serviceId: springcloud-provider-dept-8001 # eureka注册中心的服务提供方路由名称
    mydept.path: /mydept/** # 将eureka注册中心的服务提供方路由名称 改为自定义路由名称
  # 不能再使用这个路径访问了，*： 忽略,隐藏全部的服务名称~
  ignored-services: "*"
   # 设置公共的前缀
  prefix: /haust

主启动类

@SpringBootApplication
@EnableZuulProxy // 开启Zuul
public class Zuul9527 {
    public static void main(String[] args) {
        SpringApplication.run(Zuul9527.class,args);
    }
}

测试
访问：http://localhost:9527/haust/mydept/dept/get/2
如果没有配置zuul的网关配置

# zuul 路由网关配置
zuul:
  # 路由相关配置
  # 原来访问路由 eg:http://localhost:9527/springcloud-provider-dept/dept/get/1
  # zuul路由配置后访问路由 eg:http://localhost:9527/haust/mydept/dept/get/1
  routes:
    mydept.serviceId: springcloud-provider-dept-8001 # eureka注册中心的服务提供方路由名称
    mydept.path: /mydept/** # 将eureka注册中心的服务提供方路由名称 改为自定义路由名称
  # 不能再使用这个路径访问了，*： 忽略,隐藏全部的服务名称~
  ignored-services: "*"
   # 设置公共的前缀
  prefix: /haust

需要访问http://localhost:9527/springcloud-provider-dept/dept/get/1
配置过后http://localhost:9527/haust/mydept/dept/get/1

Spring Cloud Config 分布式配置

分布式系统面临的–配置文件问题

微服务意味着要将单体应用中的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务，由于每个服务都需要必要的配置信息才能运行，所以一套集中式的，动态的配置管理设施是必不可少的。spring cloud提供了configServer来解决这个问题，我们每一个微服务自己带着一个application.yml，那上百个的配置文件修改起来，令人头疼！

什么是SpringCloud config分布式配置中心？

在这里插入图片描述

spring cloud config 为微服务架构中的微服务提供集中化的外部支持，配置服务器为各个不同微服务应用的所有环节提供了一个中心化的外部配置。

spring cloud config 分为服务端和客户端两部分。

服务端也称为 分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密，解密信息等访问接口。

客户端则是通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息。配置服务器默认采用git来存储配置信息，这样就有助于对环境配置进行版本管理。并且可用通过git客户端工具来方便的管理和访问配置内容。

spring cloud config 分布式配置中心能干嘛？

集中式管理配置文件
不同环境，不同配置，动态化的配置更新，分环境部署，比如 /dev /test /prod /beta /release
运行期间动态调整配置，不再需要在每个服务部署的机器上编写配置文件，服务会向配置中心统一拉取配置自己的信息
当配置发生变动时，服务不需要重启，即可感知到配置的变化，并应用新的配置
将配置信息以REST接口的形式暴露

spring cloud config 分布式配置中心与GitHub整合

由于spring cloud config 默认使用git来存储配置文件 (也有其他方式，比如自持SVN 和本地文件)，但是最推荐的还是git ，而且使用的是 http / https 访问的形式。

config-server

  1. 新建SpringCloud-Config-Server-9528模块
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-config-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
    </dependencies>
  1. 配置
server:
  port: 9528

spring:
  application:
    name: SpringBoot-Config-9528
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/sepcai/springcloud-config.git
          # 通过 config-server可以连接到git，访问其中的资源以及配置
  1. 主启动类
@SpringBootApplication
@EnableConfigServer   //开启spring cloud config server服务
public class ConfigServer9528 {

    public static void main(String[] args) {
        SpringApplication.run(ConfigServer9528.class, args);
    }

}
  1. 将配置文件提交到git仓库中

application.yaml

spring:
  profiles:
    active: dev

---
spring:
  profiles: dev
  application:
    name: springcloud-dev

---
spring:
  profiles: test
  application:
    name: springcloud-test
  1. 测试
    访问http://localhost:9528/application-dev.yaml
    得到对应配置信息即可
    可以用如下的形式访问配置
/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

label代表所在的分支
例如：
http://localhost:9528/application/dev/master
http://localhost:9528/application-dev.yaml
http://localhost:9528/master/application-dev.yaml
都可以访问到

config-client

服务端已经配置好了，配置一个服务端去访问配置

  1. 新建SpringCloud-Config-Client-9529模块
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-config-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
  1. 配置文件
    aplication.yaml
# 用户级别的配置
spring:
  application:
    name: springcloud-config-client
server:
  port: 9529

bootstrap.yaml

# 系统级别的配置
spring:
  cloud:
    config:
      name: config-client # 需要从git上读取的资源名称，不要后缀
      profile: dev
      label: master
      uri: http://localhost:9528
  1. 将config-client.yaml提交到仓库
spring:
  profiles:
    active: dev
---
server:
  port:8201

# spring配置
spring:
  profiles: dev
  application:
    name: SpringCloud-Config

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
      
---
server:
  port:8202

# spring配置
spring:
  profiles: test
  application:
    name: SpringCloud-Config

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  1. 编写controller,获取配置信息
@RestController
public class ConfigClientController {
    @Value("${spring.application.name}")
    private String applicationName; //获取微服务名称
    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaServer; //获取Eureka服务
    @Value("${server.port}")
    private String port; //获取服务端的端口号

    @RequestMapping("/config")
    public String getConfig() {
        return "applicationName:" + applicationName + "\n" +
                "eurekaServer:" + eurekaServer + "\n" +
                "port:" + port;
    }
}
  1. 主启动类
@SpringBootApplication
public class ConfigClient9529 {

    public static void main(String[] args) {
        SpringApplication.run(ConfigClient9529.class, args);
    }
}
  1. 测试 http://localhost:9529/config
    有对应的信息就成功了

实际案例整合

Eureka配置

  1. 首先编写eureka的配置config-eureka.yaml提交到仓库
spring:
  profiles: 
    active: dev


---
server:
  port: 7001


spring:
  profiles: dev
  application:
    name: eureka-server-config

eureka:
  instance:
    hostname: eureka7001
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
        defaultZone: http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/


---

server:
  port: 7001


spring:
  profiles: test
  application:
    name: eureka-server-config

eureka:
  instance:
    hostname: eureka7001
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
        defaultZone: http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  1. 新建SpringCloud-Config-Eureka-7001
    <dependencies>
        <!--eureka-->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
    </dependencies>
  1. 配置文件
    bootstrap.yaml
spring:
  cloud:
    config:
      name: config-eureka # 仓库中的配置文件名称
      label: master  # 分支
      profile: dev  # 环境
      uri: http://localhost:9528

application.yaml

spring:
  application:
    name: eureka-config
  1. 主启动类
@SpringBootApplication
@EnableEurekaServer
public class EurekaConfig7001 {

    public static void main(String[] args) {
        SpringApplication.run(EurekaConfig7001.class, args);
    }
}
  1. 首先访问一下http://localhost:9528/config-eureka.yaml
    成功的话，访问localhost:7001
    如果出现eureka的界面即可

dept-provider配置

  1. 首先编写配置config-dpet.yaml提交到仓库
spring:
  profiles:
    active: dev

---
# 服务端口
server:
  port: 8001

# mybatis 配置
mybatis:
  type-aliases-package: com.wcy.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

# spring配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/db-01?useUnicode=true&chracterEncoding=UTF-8&useSSL=true
    driver-class-name: com.mysql.cj.jdbc.Driver
  application:
    name: SpringCloud-Provider-Dept-8001
  profiles: dev

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: SpringCloud-Provider-Dept-8001 # 更改描述

# info配置 自定义键值对
info:
  app.name: DeptProvider8001
  app.function: provide dept service for comsumer
  company.name: com.wcy
# 开启端口
management:
  endpoints:
    web:
      exposure:
        include: "*"

--- 

# 服务端口
server:
  port: 8001

# mybatis 配置
mybatis:
  type-aliases-package: com.wcy.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

# spring配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/db-02?useUnicode=true&chracterEncoding=UTF-8&useSSL=true
    driver-class-name: com.mysql.cj.jdbc.Driver
  application:
    name: SpringCloud-Provider-Dept-8001
  profiles: test

# eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: SpringCloud-Provider-Dept-8001 # 更改描述

# info配置 自定义键值对
info:
  app.name: DeptProvider8001
  app.function: provide dept service for comsumer
  company.name: com.wcy
# 开启端口
management:
  endpoints:
    web:
      exposure:
        include: "*"
  1. 新建模块SpringCloud-Config-Provider-Dept-8001，将SpringCloud-Provider-Dept-8001中的内容复制到新项目中
<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
  1. 配置文件
spring:
  application:
    name: spring-config-dept

spring:
  cloud:
    config:
      label: master
      uri: http://localhost:9528
      name: config-dept
      profile: dev
  1. 主启动类
@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
public class DeptConfigProvider8001 {

    public static void main(String[] args) {
        SpringApplication.run(DeptConfigProvider8001.class, args);
    }

}
  1. 依然先通过配置服务访问成功后再访问http://localhost:8001/dept/get/1
    有对应的信息即可
    现在的配置文件就和项目解耦合了，只需要在仓库中更改即可，不用更改项目

在这里插入图片描述

即将秃头的小老弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
微服务（一）微服务的介绍
m0_53312145的博客
05-27 426
父工程的搭建 父工程只需留下 pom.xml 文件 父工程的 pom.xml 文件 <?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.or
springcloud
最新发布
06-25
在 "springcloud" 这个主题中，我们主要讨论的是 Spring Cloud Alibaba，它是阿里巴巴提供的与 Spring Cloud 兼容的一系列微服务解决方案。Spring Cloud Alibaba 提供了包括服务发现（Nacos）、配置中心（Nacos）、...
微服务的常用组件
青云的博客
11-16 1308
SpringCloudConfig、Nacos、Apollo（阿波罗）配置中心。
SpringCloud学习笔记
qq_45541846的博客
05-23 675
springcloud学习笔记
狂神springcloud学习笔记加代码
03-24
狂神springcloud学习笔记加代码 笔记可以看：https://www.kuangstudy.com/bbs/1374942542566551554#header4 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr
GitHub轻松阅读微服务实战项目流程详解【第一天：数据库表设计及其环境搭建、项目运行】
Kevinnsm的博客
10-07 2192
One Day1.数据库表详解2.项目环境准备 github地址：https://github.com/Zealon159/light-reading-cloud 项目服务端主要使用SpringBoot+SpringCloud+SpringCloudAlibaba+ElasticSearch+Redis+RabbitMQ的技术栈。 1.数据库表详解 此项目包含了使用了两个数据库 （1）reading_cloud_account（与账户相关的数据库) 1. 用户表(user) #用户信息相关
SpringCloud视频教程全套百度网盘
03-01
第1章 SpringCloud简介 第2章 SpringCache缓存详细讲解及应用 第3章 Redis高级缓存讲解及应用 第4章 SpringSecurity安全详细讲解及应用 第5章 RabbitMQ高级消息的讲解及应用 第6章 ElasticSearch详细讲解及应用 第7...
SpringCloud中文文档
03-10
Spring Cloud中文文档 Spring Cloud 是一个用于快速构建分布式系统的工具集，提供了配置管理、服务发现、断路器、智能路由、微代理、控制总线等多种功能。这些功能可以帮助开发人员快速地支持实现分布式系统中的...
springcloud视频
01-20
《SpringCloud视频学习指南》 在当今的互联网行业中，微服务架构已经成为大型系统设计的主流趋势，而SpringCloud作为Java领域最热门的微服务框架，备受开发者青睐。本系列视频教程将带你深入理解SpringCloud的核心...
全新出品！Github总榜排行第七的SpringCloud生态全栈笔记我粉了
weixin_50205273的博客
08-26 128
虽然SpringCloudAlibaba增加了咱们的一些学习成本，但俗话说的好：活到老学到老！如果有小伙伴需要点这里——
JavaSE回顾总结（狂神说java）.xmind
05-11
javaSE回顾总结，学习笔记，查漏补缺。 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等.
狂神说java系列笔记（java基础+javaweb+ssm+微服务）.rar
01-08
狂神说JAVA整个系列的笔记，从JAVA SE到分布式微服务，JUC，JVM，docker，希望对大家有帮助(#^.^#)
【狂神说】Spring全面详细笔记.md
12-20
【狂神说】Spring全面详细笔记
Mall谷粒商城(基础篇的开发)
-
05-02 3046
项目简介 Mall商城项目致力于打造一个完整的大型分布式架构的电商平台，采用先阶段流行的前后端分离模式编写。 Mall商城是一套电商项目，包括前台的商城系统以及后台管理系统，基于SpringCloud、SpringCloud Alibaba、Mybatis-plus实现。 前台商城系统包括：用户登陆、注册、商品搜索、商品详情、购物车、订单、秒杀活动等模块。 后台管理系统包括：系统管理、商品系统、优惠营销、库存系统、订单系统、用户系统、内容管理等七大模块。 项目架构 接口文档 https://easydo
14.狂神说springcloud
归期无期的博客
10-14 539
此文章仅供自己查找复习使用，如有侵权，请联系作者删除
SpringCloud详细笔记（持续更新中）
AC_872767407的博客
11-21 910
SpringCloud 文章目录SpringCloudJava程序员周瑜尚硅谷：https://github.com/leelovejava/cloud2020父工程Project空间创建，父工程pom文件支付模块构建开启热部署Devtools：方便调试消费者订单模块工程重构5 Eureka服务注册与发现（已停更，但仍然使用较多）Eureka基础知识：APP23 actuator微服务信息完善Eureka自我保护理论知识禁止自我保护停更说明6 Zookeeper服务注册与发现（使用较少）7 Consul服务
微服务的几个重要组件
junaozun的博客
05-29 4528
一.跨语言、跨平台之间相互通信的数据交换格式 protobuf 二.通讯协议 gRPC 三.调度管理服务发现 consul 四.微服务框架 ...
spring cloud
09-13
Spring Cloud是一个用于构建分布式系统的开发工具集合。它提供了一些常用的组件和框架，包括服务注册和发现、负载均衡、断路器、分布式配置等等。在使用Spring Cloud时，有一些常见的错误和注意事项需要注意。 首先...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值