12-微服务与分布式_Spring Cloud（上）

最新推荐文章于 2024-05-12 07:22:56 发布
最新推荐文章于 2024-05-12 07:22:56 发布
阅读量444 收藏
点赞数 2
分类专栏： JavaEE开发工程师学习之路 文章标签： spring cloud 微服务 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41528502/article/details/122933566
版权

目录

一，介绍

1，架构演变

1.1 集中式架构

1.2 垂直拆分

1.3 分布式服务

1.4 服务治理SOA

 1.5 微服务

2，服务调用方式说明

2.1 RPC

2.2 HTTP

2.3 如何选择

3，简介

3.1 什么是spring cloud

3.2 版本

二，微服务场景模拟

1，创建父工程

2，服务提供者

3，服务调用者

4，思考

三，Eureka

1，简介

2，原理图

3，入门案例

3.1 编写EurekaServer

3.2 服务注册

3.3 服务发现

4，高可用EurekaServer

4.1 服务同步

4.2 动手搭建高可用的EurekaServer

5，Eureka客户端服务端配置

5.1 服务注册

5.2 服务续约

5.3 获取服务列表

5.4 失效剔除和自我保护

6，小结

四，负载均衡Ribbon

1，简单示例

1.1 开启两个服务实例

1.2 开启负载均衡

2，源码跟踪

3，负载均衡策略

3.1 轮询

3.2 随机 

五，hystrix

1，简介

1.1 雪崩问题

2，服务降级

2.1 简介

2.2 简单案例

3，熔断原理

4，熔断器案例

在项目开发中随着业务越来越多，导致功能之间耦合性高、开发效率低、系统运行缓慢难以维护、不稳定。微服务架构可以解决这些问题，而Spring Cloud是微服务架构最流行的实现。

一，介绍

1，架构演变

1.1 集中式架构

当网站流量很小时，只需要一个应用，将所有的功能都部署在一起，以减少部署节点和成本。

优点：

  • 系统开发速度快
  • 维护成本低
  • 适用于并发要求较低的系统

缺点：

  • 代码耦合度高，后期维护困难
  • 无法针对不同模块进行优化
  • 无法水平扩展
  • 单点容错率低，并发能力差

1.2 垂直拆分

当访问量逐渐增大，单一应用无法满足需求，此时为了应对更高的并发和业务需求，我们根据业务功能对系统进行 拆分：

优点：

  • 系统拆分实现了流量分担，解决了并发问题
  • 可以针对不同模块进行优化
  • 方便水平扩展，负载均衡，容错率提高

缺点：

  • 系统间相互独立，会有很多重复开发工作，影响开发效率

1.3 分布式服务

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式调用是关键。

优点：

  • 将基础服务进行了抽取，系统间相互调用，提高了代码复用和开发效率

缺点：

  • 系统间耦合度变高，调用关系错综复杂，难以维护

1.4 服务治理SOA

SOA（Service Oriented Architecture）面向服务的架构：它是一种设计方法，其中包含多个服务， 服务之间通过 相互依赖最终提供一系列的功能。一个服务通常以独立的形式存在于操作系统进程中。各个服务之间通过网络调用。

SOA缺点：

  • 每个供应商提供的ESB产品有偏差，自身实现较为复杂；
  • 应用服务粒度较大，ESB集成整合所有服务和 协议、数据转换使得运维、测试部署困难。
  • 所有服务都通过一个通路通信，直接降低了通信速度。

 1.5 微服务

微服务架构是使用一套小服务来开发单个应用的方式或途径，每个服务基于单一业务能力构建，运行在自己的进程中，并使用轻量级机制通信，通常是HTTP API，并能够通过自动化部署机制来独立部署。这些服务可以使用不同的 编程语言实现，以及不同数据存储技术，并保持最低限度的集中式管理。 微服务结构图 ：

1，特点

单一职责：

  • 微服务中每一个服务都对应唯一的业务能力，做到单一职责

面向服务：

  • 面向服务是说每个服务都要对外暴露服务接口API。并不关心服务的技术实现，做到与平台和语言无关，也不限定用什么技术实现，只要提供REST的接口即可。

自治：自治是说服务间互相独立，互不干扰

  • 团队独立：每个服务都是一个独立的开发团队。
  • 技术独立：因为是面向服务，提供REST接口，使用什么技术没有别人干涉
  • 前后端分离：采用前后端分离开发，提供统一REST接口，后端不用再为PC、移动段开发不同接口
  • 数据库分离：每个服务都使用自己的数据源

2， 微服务和SOA比较：

2，服务调用方式说明

无论是微服务还是SOA，都面临着服务间的远程调用。常见的远程调用方式有以下几种：

  • RPC：Remote Procedure Call远程过程调用，类似的还有RMI。自定义数据格式，基于原生TCP通信，速度快，效率高。早期的Web Service，现在热门的Dubbo，都是RPC的典型。
  • HTTP：HTTP其实是一种网络传输协议，基于TCP，规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用HTTP协议。也可以用来进行远程服务调用。缺点是消息封装臃肿。现在热门的REST风格，就可以通过HTTP协议来实现。

2.1 RPC

RPC，即 Remote Procedure Call（远程过程调用），是一个计算机通信协议。 该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。说得通俗一点就是：A计算机提供一个 服务，B计算机可以像调用本地服务那样调用A计算机的服务。

2.2 HTTP

HTTP其实是一种网络传输协议，基于TCP，工作在应用层，规定了数据传输的格式。现在客户端浏览器与服务端通 信基本都是采用HTTP协议，也可以用来进行远程服务调用。

缺点是消息封装臃肿，优势是对服务的提供和调用方 没有任何技术限定，自由灵活，更符合微服务理念。现在热门的REST风格，就可以通过HTTP协议来实现。

2.3 如何选择

RPC的机制是根据语言的API（language API）来定义的，而不是根据基于网络的应用来定义的。如果公司全部采用Java技术栈，那么使用Dubbo作为微服务架构是一个不错的选择。

相反，如果公司的技术栈多样化，而且你更青睐Spring家族，那么Spring Cloud搭建微服务是不二之选。会选择 Spring Cloud套件，因此会使用HTTP方式来实现服务间调用。

3，简介

3.1 什么是spring cloud

Spring Cloud是Spring旗下的项目之一，官网地址：Redirecting…

Spring最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中。

Spring Cloud也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括：

Netflflix

  • Eureka：注册中心
  • Zuul：服务网关（不再维护，可以使用gateway代替）
  • Ribbon：负载均衡
  • Feign：服务调用
  • Hystrix：熔断器

3.2 版本

Spring Cloud的版本命名比较特殊，因为它不是一个组件，而是许多组件的集合，它的命名是以A到Z为首字母的一 些单词组成(其实是伦敦地铁站的名字)：

Spring Clound 和Spring Boot版本对应关系(不能使用过高或过低版本！！！)

 这里采用Greenwich版本

二，微服务场景模拟

1，创建父工程

微服务中需要同时创建多个项目，为了方便演示，先创建一个父工程，后续的工程都以这个工程为父，使用 Maven的聚合和继承。统一管理子工程的版本和配置。

新建一个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.xxy</groupId>
    <artifactId>springcloud-parent</artifactId>
    <!--注意聚合父工程-->
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

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

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
        <mapper.starter.version>2.1.5</mapper.starter.version>
        <mysql.version>8.0.23</mysql.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- springCloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 通用Mapper启动器 -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
            <!-- mysql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2，服务提供者

1，选中父工程创建Module ——user-service

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>springcloud-parent</artifactId>
        <groupId>com.xxy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-service</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 通用Mapper启动器 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

3，创建启动器（记得添加mapperscan注解，来自tkmybatis）和配置文件

如果resources目录显示为普通目录，可以在 resources 上右键 Make Directory as Resources Root；

如果yml文件上没有出现绿叶，可以先刷新下maven中的配置，仍然不行可以参考下面的解决办法：

4，编写yml文件

server:
  port: 9091
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud
    username: root
    password: root

mybatis:
  type-aliases-package: com.xxy.user.pojo

5，创建数据库springcloud以及表tb_user

CREATE DATABASE /*!32312 IF NOT EXISTS*/`springcloud` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `springcloud`;

/*Table structure for table `tb_user` */

DROP TABLE IF EXISTS `tb_user`;

CREATE TABLE `tb_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `name` varchar(50) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `sex` int(11) DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  `created` date DEFAULT NULL,
  `updated` date DEFAULT NULL,
  `note` varchar(2000) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

/*Data for the table `tb_user` */

insert  into `tb_user`(`id`,`user_name`,`password`,`name`,`age`,`sex`,`birthday`,`created`,`updated`,`note`) values 
(1,'zhangsan','1','张三a',18,1,'2019-02-27','2019-02-27','2019-02-27','在学习Java...'),
(2,'lisi','1','李四ab',18,1,'2019-02-27','2019-02-27','2019-02-27','在学习Java...'),
(3,'wangwu','1','王五abc',18,1,'2019-02-27','2019-02-27','2019-02-27','在学习Java...'),
(4,'fanbingbing','1','范冰冰aa',18,2,'2019-02-27','2019-02-27','2019-02-27','在学习Java...'),
(5,'guodegang','1','郭德纲bb',18,1,'2019-02-27','2019-02-27','2019-02-27','在学习Java...'),
(6,NULL,NULL,'周星驰cc',18,NULL,'2020-06-01','2020-06-01',NULL,NULL),
(7,'kaikeba',NULL,'开课吧',NULL,NULL,NULL,NULL,NULL,NULL);

5，编写实体类User

package com.xxy.user.pojo;

import lombok.Data;

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Data   // 加入该注解后就不需要编写getter和setter方法
@Table(name = "tb_user")
public class User{
    // id
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 用户名
    private String userName;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    // 备注
    private String note;
}

6，创建mapper接口UserMapper，使用内置的方法

package com.xxy.user.mapper;

import com.xxy.user.pojo.User;
import tk.mybatis.mapper.common.Mapper;

@Repository
public interface UserMapper extends Mapper<User> {
}

 7，创建UserService

package com.xxy.user.service;

import com.xxy.user.mapper.UserMapper;
import com.xxy.user.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id) {
        return userMapper.selectByPrimaryKey(id);
    }
}

8，创建UserController，提供rest风格的服务

package com.xxy.user.controler;

import com.xxy.user.pojo.User;
import com.xxy.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id) {
        return userService.queryById(id);
    }
}

3，服务调用者

1，选中父工程，创建新module——consumer-demo

<?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>springcloud-parent</artifactId>
        <groupId>com.xxy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>consumer-demo</artifactId>

    <!--调用服务，所以只需要引入web启动器即可-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

2，编写启动器和配置文件

package com.xxy.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

Spring提供了一个RestTemplate模板工具类，对基于HTTP的客户端进行了封装，并且实现了对象与json的序列化和反序列化，非常方便。RestTemplate并没有限定HTTP的客户端类型，而是进行了抽象，目前常用的3种都有支持：

  • HTTPClient
  • OkHTTP
  • JDK原生的URLConnection（默认的）

3，创建实体类

package com.xxy.consumer.pojo;

import lombok.Data;
import java.util.Date;

@Data   // 加入该注解后就不需要编写getter和setter方法
public class User{
    // id
    private Long id;

    // 用户名
    private String userName;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    // 备注
    private String note;
}

4，编写ConsumerController，调用User中的服务

package com.xxy.consumer.controller;

import com.xxy.consumer.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
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;

@RestController
@RequestMapping("consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id) {
        String url = "http://localhost:9091/user/".concat(id.toString());
        return restTemplate.getForObject(url, User.class);
    }

}

5，同时启动user和consumer

访问consumer端口（没有设置，默认为8080）

一个简单的远程服务调用案例就实现了.

4，思考

简单回顾一下，刚才我们写了什么：

  • user-service：对外提供了查询用户的接口
  • consumer-demo：通过RestTemplate访问 http://locahost:9091/user/{id} 接口，查询用户数据

存在什么问题？

  • 在consumer中，我们把url地址硬编码到了代码中，不方便后期维护
  • consumer需要记忆user-service的地址，如果出现变更，可能得不到通知，地址将失效
  • consumer不清楚user-service的状态，服务宕机也不知道
  • user-service只有1台服务，不具备高可用性
  • 即便user-service形成集群，consumer还需自己实现负载均衡

其实上面说的问题，概括一下就是分布式服务必然要面临的问题：

服务管理

  • 如何自动注册和发现
  • 如何实现状态监管
  • 如何实现动态路由

服务如何实现负载均衡

服务如何解决容灾问题

服务如何实现统一配置

以上的问题，我们都将在SpringCloud中得到答案。

三，Eureka

1，简介

问题分析：

在刚才的案例中，user-service对外提供服务，需要对外暴露自己的地址。而consumer（调用者）需要记录服务提供者的地址。将来地址出现变更，还需要及时更新。这在服务较少的时候并不觉得有什么，但是在现在日益复杂的互联网环境，一个项目肯定会拆分出十几，甚至数十个微服务。此时如果还人为管理地址，不仅开发困难，将来测试、发布上线都会非常麻烦，这与DevOps的思想是背道而驰的。

网约车：

这就好比是网约车出现以前，人们出门叫车只能叫出租车。一些私家车想做出租却没有资格，被称为黑车。而很多人想要约车，但是无奈出租车太少，不方便。私家车很多却不敢拦，而且满大街的车，谁知道哪个才是愿意载人的。

此时滴滴这样的网约车平台出现了，所有想载客的私家车全部到滴滴注册，记录你的车型（服务类型），身份信息（联系方式）。这样提供服务的私家车，在滴滴那里都能找到，一目了然。

此时要叫车的人，只需要打开APP，输入你的目的地，选择车型（服务类型），滴滴自动安排一个符合需求的车到你面前，为你服务，完美！

Eureka做什么？

Eureka就好比是滴滴，负责管理、记录服务提供者的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka会把符合你需求的服务告诉你。

同时，服务提供方与Eureka之间通过 “心跳” 机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。

这就实现了服务的自动注册、发现、状态监控。

2，原理图

Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址

提供者：启动后向Eureka注册自己信息（地址，提供什么服务。可能有多个节点提供同样的服务，这时就需要进行负载均衡）

消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新

心跳(续约)：提供者定期通过HTTP方式向Eureka刷新自己的状态

3，入门案例

3.1 编写EurekaServer

1，创建新的module——eureka-server

Eureka是服务注册中心，只做服务注册；自身并不提供服务也不消费服务。可以搭建Web工程使用Eureka，可以 使用Spring Boot方式搭建。

<?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>springcloud-parent</artifactId>
        <groupId>com.xxy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>eureka-server</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

</project>

2，创建启动器和配置文件

package com.xxy;

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

@EnableEurekaServer    // ！！！
@SpringBootApplication
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

server:
  port: 10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    service-url:
      # eureka 服务地址，如果是集群的话；需要指定其它集群eureka地址
      defaultZone: http://172.0.0.1:10086/eureka
    # 不注册自己
    register-with-eureka: false
    # 不拉取服务
    fetch-registry: false

3，启动

3.2 服务注册

在服务提供工程user-service上添加Eureka客户端依赖；自动将服务注册到EurekaServer服务地址列表。

1，添加依赖

        <!-- Eureka客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

2，在启动类上开启Eureka客户端功能

3，编写配置

注意：

  • 这里我们添加了spring.application.name属性来指定应用名称，将来会作为应用的id使用。
  • 不用指定register-with-eureka和fetch-registry，因为默认是true

4，同时开启EurekaServer和User-Service

3.3 服务发现

在服务消费工程consumer-demo上添加Eureka客户端依赖；可以使用工具类DiscoveryClient根据服务名称获取对 应的服务地址列表。

1，添加依赖

2，在启动类添加开启Eureka客户端发现的注解 

3， 修改配置

spring:
  application:
    name: consumer-demo
eureka:
  client:
    service-url:
      defaultZone: HTTP://127.0.0.1:10086/eureka

4，修改controller代码，用DiscoveryClient类的方法，根据服务名称，获取服务实例：

注意这里引入的DiscoveryClient是org.springframework.cloud.client.discovery.DiscoveryClient！！

package com.xxy.consumer.controller;

import com.xxy.consumer.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
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")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id) {
        String url = "http://localhost:9091/user/".concat(id.toString());

        List<ServiceInstance> serviceInstances = discoveryClient.getInstances("user-service");
        ServiceInstance serviceInstance = serviceInstances.get(0);//  只有一个服务
        url = "http://".concat(serviceInstance.getHost()).concat(":").concat(String.valueOf(serviceInstance.getPort())).concat("/user/").concat(String.valueOf(id));
        return restTemplate.getForObject(url, User.class);
    }
}

4，高可用EurekaServer

Eureka架构中的三个核心角色：

服务注册中心

  • Eureka的服务端应用，提供服务注册和发现功能，就是刚刚我们建立的eureka-server

服务提供者

  • 提供服务的应用，可以是Spring Boot应用，也可以是其它任意技术实现，只要对外提供的是REST风格服务即可。本例中就是我们实现的user-service

服务消费者

  • 消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。本例中就是我们实现的consumer-demo

Eureka Server即服务的注册中心，在刚才的案例中，我们只有一个EurekaServer，事实上EurekaServer也可以是 一个集群，形成高可用的Eureka中心 。

Eureka Server是一个web应用，可以启动多个实例（配置不同端口）保证Eureka Server的高可用

4.1 服务同步

多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。

而作为客户端，需要把信息注册到每个Eureka中

如果有三个Eureka，则每一个EurekaServer都需要注册到其它几个Eureka服务中。

例如：有三个分别为10086、10087、10088，则：

  • 10086要注册到10087和10088上
  • 10087要注册到10086和10088上
  • 10088要注册到10086和10087上

4.2 动手搭建高可用的EurekaServer

1，修改原来的EurekaServer配置

server: 
    # 如果jvm设置端口号，则使用设置的端口号，否则使用10086
    port: ${port:10086} 
spring: 
    application: 
    name: eureka-server 
eureka: 
    client: 
        #eureka的服务地址，如果是集群，需要指定其他集群eureka地址 
        service-url: 
            defaultZone: ${defaultZone:http://127.0.0.1:10086/eureka} 
        # 不注册自己 
        #register-with-eureka: false 
        # 不抓取服务 
        #fetch-registry: false

所谓的高可用注册中心，其实就是把EurekaServer自己也作为一个服务进行注册，这样多个EurekaServer之间就能互相发现对方，从而形成集群。因此我们做了以下修改：

  1. 删除了register-with-eureka=false和fetch-registry=false两个配置。因为默认值是true，这样就会吧自己注册到注册中心了。
  2. 把service-url的值改成了另外一台EurekaServer的地址，而不是自己

2，另外一台在启动的时候可以指定端口port和defaultZone配置：

修改原来的启动配置组件；在如下界面中的 VM options 中 设置

-DdefaultZone=http:127.0.0.1:10087/eureka

复制一份并修改；在如下界面中的 VM options 中 设置

-Dport=10087 - DdefaultZone=http:127.0.0.1:10086/eureka

3，启动测试；同时启动两台eureka server

4，客户端注册服务到集群 

因为EurekaServer不止一个，因此注册服务的时候，service-url参数需要变化

5，Eureka客户端服务端配置

Eureka客户端工程

  • user-service 服务提供：服务地址使用ip方式、续约
  • consumer-demo 服务消费：获取服务地址的频率

Eureka服务端工程 eureka-server

  • 失效剔除
  • 自我保护

5.1 服务注册

服务提供者在启动时，会检测配置属性中的： eureka.client.register-with-erueka=true 参数是否为true，事实上默认就是true。如果值确实为true，则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息。

EurekaServer会把这些信息保存到一个双层Map结构中 。

  • 第一层Map的Key就是服务id，一般是配置中的 spring.application.name 属性,user-service
  • 第二层Map的key是服务的实例id。一般host+ serviceId + port，例如： localhost:user-service:8081
  • 值则是服务的实例对象，也就是说一个服务，这样可以同时启动多个不同实例，形成集群。

默认注册时使用的是主机名或者localhost，如果想用ip进行注册，可以在 user-service 中添加配置如下：

eureka: 
    instance: 
        ip-address: 127.0.0.1 # ip地址 
        prefer-ip-address: true # 更倾向于使用ip，而不是host名

修改完后先后重启 user-service 和 consumer-demo ；在调用服务的时候就已经变成ip地址（改变了serverInstance的host）；需要注意的是：不是 在eureka中的控制台服务实例状态显示。

5.2 服务续约

在注册服务完成以后，服务提供者会维持一个心跳（定时向EurekaServer发起Rest请求），告诉 EurekaServer：“我还活着”。这个我们称为服务的续约（renew）；

有两个重要参数可以修改服务续约的行为；可以在 user-service 中添加如下配置项：

eureka: 
    instance: 
        lease-expiration-duration-in-seconds: 90 
        lease-renewal-interval-in-seconds: 30
  • lease-expiration-duration-in-seconds：服务失效时间，默认值90秒
  • lease-renewal-interval-in-seconds：服务续约(renew)的间隔，默认为30秒

也就是说，默认情况下每个30秒服务会向注册中心发送一次心跳，证明自己还活着。如果超过90秒没有发送心 跳，EurekaServer就会认为该服务宕机，会从服务列表中移除。

这两个值在生产环境不要修改，默认即可。

5.3 获取服务列表

当服务消费者启动时，会检测 eureka.client.fetch-registry=true 参数的值，如果为true，则会从Eureka Server服 务的列表拉取只读备份，然后缓存在本地。并且 每隔30秒 会重新拉取并更新数据。可以在 consumer-demo 项目 中通过下面的参数来修改：

eureka: 
    client: 
        registry-fetch-interval-seconds: 30

生产环境中，我们不需要修改这个值。 但是为了开发环境下，能够快速得到服务的最新状态，我们可以将其设置小一点。

5.4 失效剔除和自我保护

1，服务下线

当服务进行正常关闭操作时，它会触发一个服务下线的REST请求给Eureka Server，告诉服务注册中心：“我要下线 了”。服务中心接受到请求之后，将该服务置为下线状态

2，失效剔除

有时我们的服务可能由于内存溢出或网络故障等原因使得服务不能正常的工作，而服务注册中心并未收到“服务下 线”的请求。

相对于服务提供者的“服务续约”操作，服务注册中心在启动时会创建一个定时任务，默认每隔一段时间 （默认为60秒）将当前清单中超时（默认为90秒）没有续约的服务剔除，这个操作被称为失效剔除。

可以通过 eureka.server.eviction-interval-timer-in-ms 参数对其进行修改，单位是毫秒。

3，自我保护

我们关停一个服务，就会在Eureka面板看到一条警告：

这是触发了Eureka的自我保护机制。当一个服务未按时进行心跳续约时，Eureka会统计最近15分钟心跳失败的服 务实例的比例是否超过了85%，当EurekaServer节点在短时间内丢失过多客户端（可能发生了网络分区故障）。在 生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因 为服务可能没有宕机。Eureka就会把当前实例的注册信息保护起来，不予剔除。

生产环境下这很有效，保证了大多 数服务依然可用。 但是这给我们的开发带来了麻烦， 因此开发阶段我们都会关闭自我保护模式： 

eureka: 
    server: 
        enable-self-preservation: false # 关闭自我保护模式（缺省为打开） 
        eviction-interval-timer-in-ms: 1000 # 扫描失效服务的间隔时间（缺省为60*1000ms）

6，小结

user-service

eureka: 
    client: 
        service-url: 
            defaultZone: http://127.0.0.1:10086/eureka 
    instance: 
        # 更倾向使用ip地址，而不是host名 
        prefer-ip-address: true 
        # ip地址 
        ip-address: 127.0.0.1 
        # 续约间隔，默认30秒 
        lease-renewal-interval-in-seconds: 5 
        # 服务失效时间，默认90秒 
        lease-expiration-duration-in-seconds: 5

consumer-demo

eureka: 
    client: 
        service-url: 
            defaultZone: http://127.0.0.1:10086/eureka 
        # 获取服务地址列表间隔时间，默认30秒 
        registry-fetch-interval-seconds: 10

dureka-server

eureka: 
    server: 
        # 服务失效剔除时间间隔，默认60秒 
        eviction-interval-timer-in-ms: 60000 
        # 关闭自我保护模式（默认是打开的） 
        enable-self-preservation: false

四，负载均衡Ribbon

在刚才的案例中，我们启动了一个user-service，然后通过DiscoveryClient来获取服务实例信息，然后获取ip和端口来访问。

但是实际环境中，我们往往会开启很多个user-service的集群。此时我们获取的服务列表中就会有多个，到底该访问哪一个呢？

一般这种情况下我们就需要编写负载均衡算法，在多个实例列表中进行选择。

不过Eureka中已经帮我们集成了负载均衡组件：Ribbon，简单修改代码即可使用。

1，简单示例

1.1 开启两个服务实例

首先我们启动两个user-service实例，一个9091，一个9092。

在user-service中配置如下端口：

server: 
    port: ${port:9091}

启动配置中配置如下：

Eureka监控面板

1.2 开启负载均衡

因为Eureka中已经集成了Ribbon，所以我们无需引入新的依赖。直接修改代码：

在RestTemplate的配置方法上添加 @LoadBalanced 注解：

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

修改调用方式，不再手动获取ip和端口，而是直接通过服务名称调用：

@GetMapping("/{id}") 
public User queryById(@PathVariable("id") Long id) { 
    String url = "http://user-service/user/" + id; 
    return restTemplate.getForObject(url, User.class); 
}

访问页面，查看结果；并可以在9091和9092的控制台查看执行情况：

2，源码跟踪

为什么只输入了service名称就可以访问了呢？之前还要获取ip和端口。

显然是有组件根据service名称，获取到了服务实例的ip和端口。

因为 consumer-demo 使用的是RestTemplate， spring使用LoadBalancerInterceptor拦截器 ，这个类会在对RestTemplate的请求进行拦截，然后从Eureka根据服 务id获取服务列表，随后利用负载均衡算法得到真实的服务地址信息，替换服务id。

继续跟入execute方法：发现获取了9092端口的服务

 再跟一次

3，负载均衡策略

3.1 轮询

Ribbon默认的负载均衡策略是简单的轮询，我们可以测试一下： 编写测试类，在刚才的源码中我们看到拦截中是使用RibbonLoadBalanceClient来进行负载均衡的，其中有一个 choose方法，是这样介绍的 

现在这个就是负载均衡获取实例的方法。

我们对注入这个类的对象，然后对其测试：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = UserConsumerDemoApplication.class)
public class LoadBalanceTest {
    @Autowired
    RibbonLoadBalancerClient client;

    @Test
    public void test(){
        for (int i = 0; i < 100; i++) {
            ServiceInstance instance = this.client.choose("user-service");
            System.out.println(instance.getHost() + ":" + instance.getPort());
        }
    }
}

确实是轮询的方式 

 

3.2 随机 

SpringBoot也帮我们提供了修改负载均衡规则的配置入口：

user-service: 
    ribbon: 
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

格式是： {服务名称}.ribbon.NFLoadBalancerRuleClassName ，值就是IRule的实现类。

五，hystrix

1，简介

Hystix是Netflix开源的一个延迟和容错库，用于隔离访问远程服务，防止出现级联失败。主页：https://github.com/Netflix/Hystrix/

1.1 雪崩问题

微服务中，服务间调用关系错综复杂，一个请求，可能需要调用多个微服务接口才能实现，会形成非常复杂的调用 链路：

如图，一次业务请求，需要调用A、P、H、I四个服务，这四个服务又可能调用其它服务。 如果此时，某个服务出 现异常：

例如： 微服务I 发生异常，请求阻塞，用户请求就不会得到响应，则tomcat的这个线程不会释放，于是越来越多的 用户请求到来，越来越多的线程会阻塞： 

服务器支持的线程和并发数有限，请求一直阻塞，会导致服务器资源耗尽，从而导致所有其它服务都不可用，形成雪崩效应。

这就好比，一个汽车生产线，生产不同的汽车，需要使用不同的零件，如果某个零件因为种种原因无法使用，那么就会造成整台车无法装配，陷入等待零件的状态，直到零件到位，才能继续组装。 此时如果有很多个车型都需要这个零件，那么整个工厂都将陷入等待的状态，导致所有生产都陷入瘫痪。一个零件的波及范围不断扩大

Hystrix解决雪崩问题的手段，主要包括：

  • 线程隔离
  • 服务降级

2，服务降级

2.1 简介

解读：

  • Hystrix为每个依赖服务调用分配一个小的线程池，如果线程池已满调用将被立即拒绝，默认不采用排队，加速失败判定时间。
  • 用户的请求将不再直接访问服务，而是通过线程池中的空闲线程来访问服务，如果线程池已满，或者请求超时，则会进行降级处理，什么是服务降级？

服务降级：可以优先保证核心服务。

用户的请求故障时，不会被阻塞，更不会无休止的等待或者看到系统崩溃，至少可以看到一个执行结果（例如返回友好的提示信息） 。

服务降级虽然会导致请求失败，但是不会导致阻塞，而且最多会影响这个依赖服务对应的线程池中的资源，对其它服务没有响应。 触发Hystrix服务降级的情况：

  • 线程池已满
  • 请求超时

2.2 简单案例

服务降级：及时返回服务调用失败的结果，让线程不因为等待服务而阻塞

1，引入依赖

在 consumer-demo 消费端系统的pom.xml文件添加如下依赖：

<dependency> 
    <groupId>org.springframework.cloud</groupId> 
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId> 
</dependency>

2，开启熔断

在启动类 ConsumerApplication 上添加注解：@EnableCircuitBreaker

@SpringBootApplication 
@EnableDiscoveryClient 
@EnableCircuitBreaker 
public class ConsumerApplication { 
    // ... 
}

可以看到，我们类上的注解越来越多，在微服务中，经常会引入上面的三个注解，于是Spring就提供了一个组合注 解：@SpringCloudApplication

因此，我们可以使用这个组合注解来代替之前的3个注解 ：

@SpringCloudApplication 
public class ConsumerApplication { 
    // ... 
}

3，编写降级逻辑

当目标服务的调用出现故障，我们希望快速失败，给用户一个友好提示。因此需要提前编写好失败时的降级处理逻 辑，要使用HystrixCommand来完成。

@HystrixCommand(fallbackMethod = "queryByIdFallBack")：用来声明一个降级逻辑的方法

改造 consumer-demo\src\main\java\lxs\com\consumer\controller\ConsumerController.java 处理器 类，如下：

@RestController 
@RequestMapping("/consumer") 
@Slf4j 
public class ConsumerController { 

    @Autowired 
    private RestTemplate restTemplate; 

    @Autowired 
    private DiscoveryClient discoveryClient; 

    @GetMapping("{id}") 
    @HystrixCommand(fallbackMethod = "queryByIdFallback") 
    public String queryById(@PathVariable Long id) { 
        String url = "http://user-service/user/" + id; 
        return restTemplate.getForObject(url, String.class); 
    }

    public String queryByIdFallback(Long id) { 
        log.error("查询用户信息失败。id：{}", id); 
        return "对不起，网络太拥挤了！"; 
    } 

}

要注意；因为熔断的降级逻辑方法必须跟正常逻辑方法保证：相同的参数列表和返回值声明。

失败逻辑中返回User对象没有太大意义，一般会返回友好提示。所以把queryById的方法改造为返回String， 反正也是Json数据。这样失败逻辑中返回一个错误说明，会比较方便。

当 user-service 正常提供服务时，访问与以前一致。但是当将 user-service 停机时，会发现页面返回了降级处理 信息：

4，默认的fallback

刚才把fallback写在了某个业务方法上，如果这样的方法很多，那岂不是要写很多。所以可以把Fallback配置加在类上，实现默认fallback；

@DefaultProperties(defaultFallback = "defaultFallBack")：在类上指明统一的失败降级方法；该类中所有 方法返回类型要与处理失败的方法的返回类型一致。

再次改造 consumer- demo\src\main\java\com\lxs\consumer\controller\ConsumerController.java

@RestController
@RequestMapping("/consumer")
@Slf4j
@DefaultProperties(defaultFallback = "defaultFallback")
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @GetMapping("{id}")
    // 这里不需要指定具体的fallback方法，但是仍然需要有HystrixCommand注解！
    // @HystrixCommand(fallbackMethod = "queryByIdFallback") 
    @HystrixCommand
    public String queryById(@PathVariable Long id) {
        String url = "http://user-service/user/" + id;
        return restTemplate.getForObject(url, String.class);
    }

    public String queryByIdFallback(Long id) {
        log.error("查询用户信息失败。id：{}", id);
        return "对不起，网络太拥挤了！";
    }

    public String defaultFallback() {
        return "默认提示：对不起，网络太拥挤了！";
    }

}

5，超时设置

在之前的案例中，请求在超过1秒后都会返回错误信息，这是因为Hystrix的默认超时时长为1，我们可以通过配置 修改这个值；修改 consumer-demo\src\main\resources\application.yml 添加如下配置：

hystrix: 
    command: 
        default: 
            execution: 
                isolation: 
                    thread: 
                        timeoutInMilliseconds: 2000

这个配置会作用于全局所有方法。为了方便复制到yml配置文件中，可以复制

hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=2000

到yml文件中会自动格式化后再进行修改。

为了触发超时，可以在 user-service\src\main\java\com\lxs\user\service\UserService.java 的方法中休眠2秒；

    @RequestMapping("/{id}")
    public User queryById(@PathVariable("id") Long id) {
        try {
            Thread.sleep(2000);// 触发超时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userService.queryById(id);
    }

3，熔断原理

在服务熔断中，使用的熔断器，也叫断路器，其英文单词为：Circuit Breaker 熔断机制与家里使用的电路熔断原理类似；当如果电路发生短路的时候能立刻熔断电路，避免发生灾难。

在分布式系统中应用服务熔断后；服务调用方可以自己进行判断哪些服务反应慢或存在大量超时，可以针对这些服务进行主动熔断，防止整个系统被拖垮。

Hystrix的服务熔断机制，可以实现弹性容错；当服务请求情况好转之后，可以自动重连。通过断路的方式，将后续请求直接拒绝，一段时间（默认5秒）之后允许部分请求通过，如果调用成功则回到断路器关闭状态，否则继续打开，拒绝请求的服务。

Hystrix的熔断状态机模型：

状态机有3个状态：

Closed：关闭状态（断路器关闭），所有请求都正常访问。

Open：打开状态（断路器打开），所有请求都会被降级。Hystrix会对请求情况计数，当一定时间内失败请求百分比达到阈值，则触发熔断，断路器会完全打开。默认失败比例的阈值是50%，请求次数最少不低于20次。

Half Open：半开状态，不是永久的，断路器打开后会进入休眠时间（默认是5S）。随后断路器会自动进入半开状态。此时会释放部分请求通过，若这些请求都是健康的，则会关闭断路器，否则继续保持打开，再次进行休眠计时

4，熔断器案例

1，修改ConsumerController.java

为了能够精确控制请求的成功或失败，在 consumer-demo 的处理器业务方法中加入一段逻辑

    @GetMapping("{id}")
    @HystrixCommand
    public String queryById(@PathVariable Long id) {
        if (id == 1) {
            throw new RuntimeException("太忙了");
        }
        String url = "http://user-service/user/" + id;
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }

这样如果参数是id为1，一定失败，其它情况都成功。（不要忘了清空user-service中的休眠逻辑） 

2，快速发出访问id为1的请求（超过20次）

会触发熔断。断路器会打开，一切请求都会被降级处理。

此时你访问id为2的请求，会发现返回的也是失败，而且失败时间很短，只有20毫秒左右；因进入半开状态之后2是 可以的。

 3，默认的熔断触发要求较高，休眠时间窗较短，为了测试方便，我们可以通过配置修改熔断策略：（consumer-demo中的配置文件）

hystrix.command.default.circuitBreaker.requestVolumeThreshold=10 # 熔断触发最小请求次数，默认值是20
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds=10000 # 熔断后休眠时长，默认值5秒
hystrix.command.default.circuitBreaker.errorThresholdPercentage=50 # 触发熔断错误比例阈值，默认值50%
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=2000 # 服务降级超时时间

&再见萤火虫&
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机毕业设计-微服务项目之springcloud分布式电影
04-06
计算机毕业设计-微服务项目之springcloud分布式电影计算机毕业设计-微服务项目之springcloud分布式电影计算机毕业设计-微服务项目之springcloud分布式电影计算机毕业设计-微服务项目之springcloud分布式电影计算机...
基于SpringCloud实现的电影院购票系统设计-微服务-分布式
10-30
基于SpringCloud实现的电影院购票系统设计-微服务-分布式+适用于毕设，可用于毕设参考和练习，也可用于其它。 项目资源适用于大三、大四的同学，可用于毕设参考和练习，也可用于商用。 软件开发环境及开发工具： ...
@RequestParam和@PathVariable的区别
yzx的博客
09-14 412
@RequestParam和@PathVariable都是Spring注解，都用于Controller层接受前端数据，不同的是两者的接收方式和请求路径 1.接收方式 @RequestParam接收数据: //required表示接收的参数值是否必须，默认为true，即默认参数必须不为空，当传递过来的参数可能为空的时候可以设置required=false。此外还有一个参数defaultValue 表示如果此次参数未空则为其设置一个默认值。 @GetMapping(value = "/queById"
微服务和分布式和SpringCloud三者的关系
weixin_45956631的博客
07-11 821
微服务、分布式、springCloud
SpringCloud微服务-----分布式事务Seata
BUG专业户
08-26 1536
分布式事务Seata
一、【SpringCloud】微服务与分布式架构
wang_luwei的博客
03-21 6764
狂神-SpringCloud笔记目录 文章目录一、微服务与分布式架构1.1分布式架构1.2微服务架构1.3分布式架构的四个核心问题 与解决方案1.4 Spring Cloud 五大组件1.5面试常见问题 一、微服务与分布式架构 1.1分布式架构 将一个大的系统，划分为多个业务模块，业务模块分别部署在不同的机器上，各个业务模块之间通过接口进行数据交互。区别分布式的方式是根据不同机器不同业务。 上图中的ServiceA，B，C，D分别是业务组件，通过API Geteway进行业务访问。（分布式需要做好事
计算机毕业设计java毕设项目之springcloud商品服务系统-微服务-分布式
m0_37775035的博客
08-30 744
基于SpringCloud实现的商品服务系统-微服务-分布式》该项目含有源码、文档、PPT、配套开发软件、软件安装教程、项目发布教程等开发语言：Java框架：springcloudJDK版本：JDK1.8服务器：tomcat7数据库：mysql 5.7数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven3.3.9浏览器：谷歌浏览器。......
springcloud项目实战图书馆管理系统的设计与实现-微服务-分布式_微服务图书管理系统的架构设计
2401_84002294的博客
05-12 946
搞定算法，面试字节再不怕，有需要文章中分享的这些二叉树、链表、字符串、栈和队列等等各大面试高频知识点及解析最后再分享一份终极手撕架构的大礼包(学习笔记)：分布式+微服务+开源框架+性能优化本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取b5e56a57acb)收录**需要这份系统化的资料的朋友，可以点击这里获取。
简单介绍----微服务和Spring Cloud
weixin_73000974的博客
01-27 1526
SpringCloud是一个用于构建分布式系统和微服务架构的开发工具的集合。它基于Spring Framework，为开发人员提供了一套简化分布式系统开发的解决方案。SpringCloud提供了一系列的组件和库，用于实现分布式系统的常见模式和功能，包括服务注册与发现、负载均衡、断路器、配置管理、消息总线、分布式追踪、网关等等。它简化了在构建分布式系统时所需的开发工作，并提供了一致而可靠的开发模式。
SpringCloud-微服务项目架构
踏雨歌青春，诗酒趁年华
02-03 3860
本文是对微服务架构的详解。微服务架构是一种灵活而强大的设计模式，通过将系统拆分为独立的、自治的服务，使得应用更容易维护、扩展和升级。然而，采用微服务架构也需要在设计和管理上付出更多的努力，平衡其优势和挑战，以确保系统的稳定性和可维护性。
spring cloud--微服务
Ysuhang的博客
08-22 6193
微服务架构，简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。
springcloud项目实战高校招生信息管理系统-微服务-分布式_springcloud 学校项目实战
最新发布
2401_84002339的博客
05-12 789
终极手撕架构师的学习笔记：分布式+微服务+开源框架+性能优化本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取浏览器：谷歌浏览器2.2B/S模式B/S（浏览器/服务器）是一种比以前的架构更简单的架构。只需下载浏览器作为客户端，那么工作将实现“瘦身”效果，并且不需要考虑不断安装软件的问题。该系统具有较高的适用性，选用B/S结构，可以在绝大部分个人平台上使用该系统。
spring-cloud-demo备份20191024_springcloud_java_分布式_cloud_
10-01
【标题】"spring-cloud-demo备份20191024_springcloud_java_分布式_cloud_" 涵盖了Spring Cloud作为一个核心的分布式系统开发框架，它基于Spring Boot的微服务构建工具，使得开发者能够轻松地创建和配置服务发现、...
基于Vue+SpringCloud博客的设计与实现-微服务-分布式.zip
05-03
基于Vue+SpringCloud博客的设计与实现---微服务基础版本组件1.0版本 博客采用Vue+SpringCloud前后分离的方式。博客采用了高可用Eureka（可以替换成其他微服务组件）以及高可用Zuul，使用以Es搜索引擎作为Zpkin的存储...
2-分布式高级篇 _SpringCloud系统_spring_谷粒商城_分布式_分布式高级篇_
10-03
RabbitMQ柔性事务方案、SpringCloud-Gateway网关、Feign远程调用、Sleuth+Zipkin链路追踪系统、Spring Cache缓存、SpringSession跨子域Session同步方案、基于ElasticSearch7全文检索、异步编排与线程池、压力测试...
2022春招实习面经【美团、阿里、微软、字节、米哈游】
&再见萤火虫&的博客
04-12 4013
简单聊聊自己的春招实习经历和心得
07-项目训练_项目搭建与工具整理
&再见萤火虫&的博客
09-04 3166
一，项目搭建与工具整理 1，引入数据库相关工具包和工具类 package com.xxy.util; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource; import javax.xml.transform.Result; import java.io.IOException; import java.sql.Connection; import java.sql.Resu..
05-数据库_数据库高级_SQL进阶练习（部分习题）
&再见萤火虫&的博客
02-02 2287
三，表联结 1，where与join的用法 1.1 使用where进行表联结 如果数据存储在多个表中，怎样⽤单条SELECT语句检索出数据？ 答案是使⽤联结。简单地说，联结是⼀种机制，⽤来在⼀条SELECT语句中关联表，因此称之为联结。 使⽤特殊的语法，可以联结多个表返回⼀组输出，联结在运⾏时关联表中正确的⾏。 例如：我们需要查询出所有的商品及对应的供应商信息怎么办？ select vend_name,prod_name,prod_price from vendors,products
04-前端技术_CSS与CSS3美化页面
&再见萤火虫&的博客
11-03 2234
二，CSS与CSS3美化页面 1，CSS简介 1.1什么是CSS? CSS 指层叠样式表 (Cascading Style Sheets) 样式定义如何显示控制 HTML 元素,从⽽实现美化HTML⽹⻚。 样式通常存储在样式表中，⽬的也是为了解决内容与表现分离的问题 外部样式表(CSS⽂件)可以极⼤提⾼⼯作效率 多个样式定义可层叠为⼀，后者可以覆盖前者样式 1.2样式层叠次序 ⼀般⽽⾔，所有的样式会根据下⾯的规则层叠于⼀个新的虚拟样式表中，其中数字 4 拥有最⾼的优先权。 ...
SpringCloud Alibaba入门：微服务与分布式架构实践
本资源主要介绍SpringCloud Alibaba的相关知识点，旨在帮助读者深入理解微服务架构中的关键组件及其作用。以下是课程大纲概览： 1. 课程目标： - 掌握单体、分布式和集群的概念：单体应用是指所有代码和服务集中在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值