cloud-01-Eureka-Ribbon-hystrix

微服务 springcloud
Created At :
Count:5.4k Views 👀 :
  1. 1. 系统架构演变
  2. 2. 微服务架构说明
  3. 3. 服务调用方式说明
  4. 4. Spring RestTemplate示例工程导入
  5. 5. Spring Cloud概述
  6. 6. 创建微服务工程
    1. 创建微服务父工程nateshao-cloud-02-mybatis
  7. 7. 搭建配置user-service工程
  8. 8. 搭建配置consumer-demo工程
  9. 9. Eureka注册中心说明
  10. 10. 搭建eureka-server工程
  11. 11. 服务注册与发现
  12. 12. Eureka Server高可用配置
  13. 访问10086和10087端口
  14. 13. Eureka客户端与服务端配置
  15. 14. 负载均衡Ribbon简介
  16. 15. Ribbon负载均衡应用
  17. 16. 熔断器Hystrix简介
  18. 17. 线程隔离&服务降级
  19. 18. 服务熔断

cloud-01-Eureka-Ribbon-hystrix

1. 系统架构演变

1
2
3
4
5
graph LR;
1[集中式架构] --> 2[垂直拆分]
2 --> 3[分布式服务]
3 --> 4[SOA面向服务架构]
4 --> 5[微服务架构]

2. 微服务架构说明

分析：

SOA使用了ESB组件的面向服务架构：ESB自身实现复杂；应用服务粒度较大，所有服务之间的通信都经过ESB会降低通信速度；部署、测试ESB比较麻烦。

小结：

微服务架构：是一套使用小服务或者单一业务来开发单个应用的方式或途径。

微服务架构特点：

  • 单一职责
  • 服务粒度小
  • 面向服务（对外暴露REST api）
  • 服务之间相互独立

与使用ESB的SOA架构的区别：微服务架构没有使用ESB，有服务治理注册中心；业务粒度小。

3. 服务调用方式说明

分析：

  • RPC：基于socket，速度快，效率高；webservice、dubbo
  • HTTP：基于TCP，封装比较臃肿；对服务和调用方没有任何技术、语言的限定，自由灵活；RESTful，Spring Cloud

4. Spring RestTemplate示例工程导入

分析：

一般情况下有如下三种http客户端工具类包都可以方便的进行http服务调用：

  • httpClient
  • okHttp
  • JDK原生URLConnection

spring 提供了RestTemplate的工具类对上述的3种http客户端工具类进行了封装，可在spring项目中使用RestTemplate进行服务调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RunWith(SpringRunner.class)
@SpringBootTest
public class RestTemplateTest {

    @Autowired
    private RestTemplate restTemplate;

    @Test
    public void test(){
        String url = "http://localhost/user/8";
        //restTemplate可以对json格式字符串进行反序列化
        User user = restTemplate.getForObject(url, User.class);
        System.out.println(user);
    }
}

5. Spring Cloud概述

  • Spring Cloud的组件可以有很多组件；常见的组件有：eureka注册中心，Gateway网关，Ribbon负载均衡，Feign服务调用，Hystrix熔断器。在有需要的时候项目添加对于的启动器依赖即可。
  • 版本特征：以英文单词命名（伦敦地铁站名）

6. 创建微服务工程

目标：创建微服务父工程nateshao-cloud-02-mybatis、用户服务工程user-service、服务消费工程user-consumer

分析：

需求：查询数据库中的用户数据并输出到浏览器

  • 父工程nateshao-cloud-02-mybatis：添加spring boot父坐标和管理其它组件的依赖
  • 用户服务工程user-service：整合mybatis查询数据库中用户数据；提供查询用户服务
  • 服务消费工程user-consumer：利用查询用户服务获取用户数据并输出到浏览器

小结：

1
2
3
4
5
6
7
8
<!-- springCloud -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-dependencies</artifactId>
    <version>${spring-cloud.version}</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

通过 scope 的import可以继承 spring-cloud-dependencies 工程中的依赖

创建微服务父工程nateshao-cloud-02-mybatis

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<?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>org.example</groupId>
    <artifactId>nateshao-cloud-02-mybatis</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>user-service</module>
        <module>user-consumer</module>
    </modules>
    <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>5.1.46</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>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-config</artifactId>
            </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>

7. 搭建配置user-service工程

user-service工程结构

目标：配置user-service工程并能够根据用户id查询数据库中用户

分析：

需求：可以访问http://localhost:9091/user/8输出用户数据

实现步骤：

  1. 添加启动器依赖（web、通用Mapper）；
  2. 创建启动引导类和配置文件；
  3. 修改配置文件中的参数；
  4. 编写测试代码（UserMapper，UserService，UserController）；
  5. 测试

小结：

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<?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>nateshao-cloud-02-mybatis</artifactId>
        <groupId>org.example</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>
            <version>2.3.3.RELEASE</version>
        </dependency>
        <!-- 通用Mapper启动器 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>1.4.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
    </dependencies>

</project>
  • 编写配置文件application.yml
1
2
3
4
5
6
7
8
server:
  port: ${port:9091}
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud
    username: root
    password: 123456

启动器UserApplication.java

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.nateshao.user;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan("com.nateshao.user.mapper")
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class, args);
    }
}

UserController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.nateshao.user.controller;

import com.nateshao.user.pojo.User;
import com.nateshao.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;
/**
 * @date Created by 邵桐杰 on 2020/8/27 23:07
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 */
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User queryById(@PathVariable Long id){
        /*try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        return userService.queryById(id);
    }
}

UserMapper.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.nateshao.user.mapper;

import com.nateshao.user.pojo.User;
import tk.mybatis.mapper.common.Mapper;
/**
 * @date Created by 邵桐杰 on 2020/8/27 23:06
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 */
public interface UserMapper extends Mapper<User> {
}

User.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package com.nateshao.user.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
/**
 * @date Created by 邵桐杰 on 2020/8/27 23:06
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 */
@Data
@Table(name = "tb_user")
public class User{
    // id
    @Id     //开启主键自动回填
    @KeySql(useGeneratedKeys = true)
    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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.nateshao.user.service;

import com.nateshao.user.mapper.UserMapper;
import com.nateshao.user.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @date Created by 邵桐杰 on 2020/8/27 23:08
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 */
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 根据主键查询用户
     * @param id 用户id
     * @return 用户
     */
    public User queryById(Long id){
        return userMapper.selectByPrimaryKey(id);
    }
}

启动UserApplication.java ，访问http://localhost:9091/user/9

访问结果

8. 搭建配置consumer-demo工程

consume工程结构

目标：编写测试类使用restTemplate访问user-service的路径根据id查询用户

分析：

需求：访问http://localhost:8080/consumer/8 使用RestTemplate获取http://localhost:9091/user/8的数据

实现步骤：

  1. 添加启动器依赖；
  2. 创建启动引导类（注册RestTemplate）和配置文件；
  3. 编写测试代码（ConsumerController中使用restTemplate访问服务获取数据）
  4. 测试

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
<?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>nateshao-cloud-02-mybatis</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-consumer</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-commons</artifactId>
            <version>3.0.6.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-commons</artifactId>
            <version>3.0.6.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-commons</artifactId>
            <version>3.0.6.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-commons</artifactId>
            <version>3.0.6.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-commons</artifactId>
        </dependency>
    </dependencies>
</project>

ConsumerController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.nateshao.consumer.controller;

import java.util.List;

/**
 * @date Created by 邵桐杰 on 2020/8/28 0:33
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 */
@RestController
@RequestMapping("/consumer")
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/{id}")
    public User queryById(Long id){

        String url = "http://localhost:9091/user/9" ;
        return restTemplate.getForObject(url, User.class);
    }
}

​ User.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.nateshao.consumer.pojo;

import lombok.Data;

import java.util.Date;
/**
 * @date Created by 邵桐杰 on 2020/8/28 0:36
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 */
@Data
public class User {
    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;
}

ConsumerApplication.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.nateshao.consumer;

/**
 * @date Created by 邵桐杰 on 2020/8/28 0:31
 * @微信公众号 千羽的编程时光
 * @个人网站 www.nateshao.cn
 * @博客 https://nateshao.gitee.io
 * @GitHub https://github.com/nateshao
 * @Gitee https://gitee.com/nateshao
 */
@SpringCloudApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }

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

启动user-service和user-consumer工程

访问结果

小结：

  • 服务管理
    如何自动注册和发现
    如何实现状态监管
    如何实现动态路由
  • 服务如何实现负载均衡
  • 服务如何解决容灾问题
  • 服务如何实现统一配置

上述的问题都可以通过Spring Cloud的各种组件解决。

9. Eureka注册中心说明

Eureka的主要功能是进行服务管理，定期检查服务状态，返回服务地址列表。

Eureka注册中心原理

10. 搭建eureka-server工程

eureka-目录

目标：添加eureka对应依赖和编写引导类搭建eureka服务并可访问eureka服务界面

分析：

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

搭建步骤：

  1. 创建工程；
  2. 添加启动器依赖；
  3. 编写启动引导类（添加Eureka的服务注解）和配置文件；
  4. 修改配置文件（端口，应用名称…）；
  5. 启动测试

小结：

  • 启动器依赖
1
2
3
4
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
  • 配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
server:
  port: ${port:10086}  # 如果提供端口则用port，没有就默认10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    service-url:
      # eureka 服务地址，如果是集群的话；需要指定其它集群eureka地址
      defaultZone: http://127.0.0.1:10086/eureka
    # 不注册自己
    register-with-eureka: false
    # 不拉取服务
    fetch-registry: false
  server:
    # 服务失效剔除时间间隔，默认60秒
    eviction-interval-timer-in-ms: 60000
    # 关闭自我保护模式（默认是打开的）
    enable-self-preservation: false
  • EurekaServerApplication.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.naateshao;

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

//声明当前应用时Eureka服务
@EnableEurekaServer
@SpringBootApplication
@EnableDiscoveryClient //开启Eureka客户端发现功能
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

11. 服务注册与发现

将user-service的服务注册到eureka并在consumer-demo中可以根据服务名称调用

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

    • 添加依赖；
    • 改造启动引导类；添加开启Eureka客户端发现的注解；
    • 修改配置文件；设置Eureka 服务地址

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

    • 添加依赖；

    • 改造启动引导类；添加开启Eureka客户端发现的注解；

    • 修改配置文件；设置Eureka 服务地址；

    • 改造处理器类ConsumerController，可以使用工具类DiscoveryClient根据服务名称获取对应服务地址列表。

  • 添加Eureka客户端依赖；

    pom.xml (user-consumer)

1
2
3
4
5
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

  • 添加启动引导类注解；

    ConsumerApplication.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @EnableDiscoveryClient //开启Eureka客户端发现功能
    @EnableCircuitBreaker //开启熔断*/
    @SpringCloudApplication
    public class ConsumerApplication {
        public static void main(String[] args) {
            SpringApplication.run(ConsumerApplication.class, args);
        }

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

  • 修改配置

    application.yml

1
2
3
4
5
6
7
spring:
  application:
    name: user-consumer
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

ConsumerController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@RestController
@RequestMapping("/consumer")
@Slf4j
@DefaultProperties(defaultFallback = "defaultFallback")
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/{id}")
    public String queryById(@PathVariable Long id){
        String url = "http://localhost:9091/user/"+id;
        List<ServiceInstance> serviceInstances = discoveryClient.getInstances("user-service");
        ServiceInstance serviceInstance = serviceInstances.get(0);

        url = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/user/" + id;
        return restTemplate.getForObject(url, String.class);
    }
}

访问http://localhost:9091/user/9，就看获取服务内容。

在服务的消费过程中，根据服务名称可以得到服务内容。

12. Eureka Server高可用配置

目标：可以启动两台eureka-server实例；在eureka管理界面看到两个实例

10086

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

10087

访问10086和10087端口

访问10087端口也可以看到两个

小结：

高可用配置：将Eureka Server作为一个服务注册到其它Eureka Server，这样多个Eureka Server之间就能够互相发现对方，同步服务，实现Eureka Server集群。

13. Eureka客户端与服务端配置

Eureka作为一个成熟的服务注册中心当然也有合理的内部维护服务节点的机制，比如服务下线、失效剔除、自我保护，也正是因为内部有这种维护机制才让Eureka更健壮、更稳定。

目标：配置eureka客户端user-service的注册、续约等配置项，配置eureka客户端consumer-demo的获取服务间隔时间；了解失效剔除和自我保护

分析：

  • Eureka客户端工程

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

  • Eureka服务端工程 eureka-server

    • 失效剔除 :Eureka Server在启动完成后会创建一个定时器每隔60秒检查一次服务健康状况，如果其中一个服务节点超过90秒未检查到心跳，那么Eureka Server会自动从服务实例列表内将该服务剔除。

      由于非正常关闭不会执行主动下线动作，所以才会出现失效剔除机制，该机制主要是应对非正常关闭服务的情况，如：内存溢出、杀死进程、服务器宕机等非正常流程关闭服务节点时。

    • 自我保护 :Eureka Server的自我保护机制会检查最近15分钟内所有Eureka Client正常心跳的占比，如果低于85%就会被触发。 我们如果在Eureka Server的管理界面发现如下的红色内容，就说明已经触发了自我保护机制。

小结：

  • user-service 
1
2
3
4
5
6
7
8
9
10
11
12
13
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
  • user-consumer
1
2
3
4
5
6
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
    # 获取服务地址列表间隔时间，默认30秒
    registry-fetch-interval-seconds: 10
  • eureka-server
1
2
3
4
5
6
eureka:
  server:
    # 服务失效剔除时间间隔，默认60秒
    eviction-interval-timer-in-ms: 60000
    # 关闭自我保护模式（默认是打开的）
    enable-self-preservation: false

14. 负载均衡Ribbon简介

  • 负载均衡和ribbon的作用

负载均衡是一个算法，可以通过该算法实现从地址列表中获取一个地址进行服务调用。在Spring Cloud中提供了负载均衡器：Ribbon

小结：

Ribbon提供了轮询、随机两种负载均衡算法（默认是轮询）可以实现从地址列表中使用负载均衡算法获取地址进行服务调用。

15. Ribbon负载均衡应用

目标：配置启动两个用户服务，在consumer-demo中使用服务名实现根据用户id获取用户

分析：

需求：可以使用RestTemplate访问http://user-service/user/8获取服务数据。

可以使用Ribbon负载均衡：在执行RestTemplate发送服务地址请求的时候，使用负载均衡拦截器拦截，根据服务名获取服务地址列表，使用Ribbon负载均衡算法从服务地址列表中选择一个服务地址，访问该地址获取服务数据。

实现步骤：

  1. 启动多个user-service实例（9091,9092）；
  2. 修改RestTemplate实例化方法，添加负载均衡注解；
  3. 修改ConsumerController；
  4. 测试

小结：

在实例化RestTemplate的时候使用@LoadBalanced，服务地址直接可以使用服务名。

16. 熔断器Hystrix简介

熔断器Hystrix的作用

Hystrix是一个延迟和容错库，用于隔离访问远程服务，防止出现级联失败。

17. 线程隔离&服务降级

目标：了解什么是线程隔离和服务降级

分析：

Hystrix解决雪崩效应：

  • 线程隔离：用户请求不直接访问服务，而是使用线程池中空闲的线程访问服务，加速失败判断时间。
  • 服务降级：及时返回服务调用失败的结果，让线程不因为等待服务而阻塞。

pom.xml(user-consumer)

1
2
3
4
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

  • 开启熔断 

    1
    2
    3
    4
    5
    // @SpringBootApplication
    //@EnableDiscoveryClient //开启Eureka客户端发现功能
    //@EnableCircuitBreaker //开启熔断*/

    @SpringCloudApplication 等于上面三个注解
  • 降级逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@RestController
@RequestMapping("/consumer")
@Slf4j
@DefaultProperties(defaultFallback = "defaultFallback")
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/{id}")
    //@HystrixCommand(fallbackMethod = "queryByIdFallback")
    @HystrixCommand
    public String queryById(@PathVariable Long id){
        /*String url = "http://localhost:9091/user/"+id;
        
        //获取eureka中注册的user-service的实例
        List<ServiceInstance> serviceInstances = discoveryClient.getInstances("user-service");
        ServiceInstance serviceInstance = serviceInstances.get(0);

        url = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/user/" + 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 "默认提示：对不起，网络太拥挤了！";
    }
}

第一次访问

  • 修改超时配置

    刷新

1
2
3
4
5
6
7
hystrix:
  command:
    default:4e
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 2000

18. 服务熔断

  • 了解熔断器工作原理

1560682028169

可以通过配置服务熔断参数修改默认：

1
2
3
4
5
6
7
8
9
10
11
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 2000
      circuitBreaker:
        errorThresholdPercentage: 50 # 触发熔断错误比例阈值，默认值50%
        sleepWindowInMilliseconds: 10000 # 熔断后休眠时长，默认值5秒
        requestVolumeThreshold: 10 # 熔断触发最小请求次数，默认值是20

请求10次，看一下效果

访问次数过多，断路器打开状态，进行服务降级：

出问题了

过了几秒，形成了半开状态，允许部分访问

等待几秒，再次访问，又可以了

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 1210331079@qq.com

💰

Title:cloud-01-Eureka-Ribbon-hystrix

Count:5.4k

Author:千 羽

Created At:2020-08-23, 14:05:11

Updated At:2020-09-13, 12:46:51

Url:https://nateshao.github.io/2020/08/23/cloud-01-Eureka-Ribbon-hystrix/

Copyright: 'Attribution-non-commercial-shared in the same way 4.0' Reprint please keep the original link and author.

©2016-2020 千羽

Built with Hexo and 3-hexo theme

×

donation.headline

// 底部音乐
//右上角Github图标