SpringCloud使用笔记

阅读数: 次 2023-01-27

文章导航

SpringCloud学习笔记

SpringCloud和SpringBoot关系

SpringBoot专注于快速方便的开发单个个体微服务。
SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起分布式会话等等集成服务。
SpringBoot可以离开SpringClooud独立使用，开发项目，但是SpringCloud离不开SpringBoot, 属于依赖关系
SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架

创建springCloud

Rest环境搭建

在父模块导入jar包

<properties>
    <maven.compiler.source>15</maven.compiler.source>
    <maven.compiler.target>15</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit.version>4.13.1</junit.version>
    <lombok.version>1.18.18</lombok.version>
    <log4j.version>1.2.17</log4j.version>
    <logback.version>1.2.3</logback.version>
</properties>


<dependencyManagement>
        <dependencies>
            <!-- spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2020.0.1</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
            <!-- spring-boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <type>pom</type>
                <scope>import</scope>
                <version>2.4.3</version>
            </dependency>
            <!-- mysql -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.23</version>
            </dependency>
            <!-- druid 数据源 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.4</version>
            </dependency>
            <!-- springboot 启动器 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.3</version>
            </dependency>
            <!-- junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </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>
            <!-- logback 日志测试-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>${logback.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

子模板可以有Api，生产者(提供)，消费者,Eurekazhuce中心

服务提供者

如果有同一个服务提供者的集群，只需要保持==spring.application.name==相同即可，如：

创建完后，在子模板的pom文件添加该子模板需要的jar包

如果子模板需要另一个子模板的pojo，也可以在pom文件中导入其他子模板

<dependencies>
        <!-- 需要拿到实体类,所以需要将包含实体类的module配置一下 -->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </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-web</artifactId>
        </dependency>

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

        <!-- jetty -->
        <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>

按需求配置yaml文件

如果api模板或者其他模板不需要就可以不配置，依各模板情况编写

server:
  port: 8081		#端口

mybatis:
  apper-locations: classpath:mybatis/mapper/*.xml
  type-aliases-package: com.flf.springcloud.pojo
  #config-location: classpath:mybatis/mybatis-config.xml

spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/xiaoxi?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: 123456

编写dao，service等

mapper(dao)层，service，serviceImpl，controller，mapper.xml,启动类

例子：

dao

@Mapper
@Repository
public interface DeptDao {

    public Boolean addDept(Dept dept);

    public Dept queryById(Long id);

    public List<Dept> queryAll();
}

service

public interface DeptService {

    public Boolean addDept(Dept dept);

    public Dept queryById(Long id);

    public List<Dept> queryAll();
}

serviceImpl

@Service
public class DeptServiceImpl implements DeptService{

    @Resource
    DeptDao deptDao;

    @Override
    public Boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryById(Long id) {
        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

controller

//提供restful服务
@RestController
public class DeptController {

    @Resource
    private DeptService deptService;

    @PostMapping("/dept/add")
    public Boolean addDept(Dept dept){

        return deptService.addDept(dept);
    }
	
    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id){

        return deptService.queryById(id);
    }

    @GetMapping("/dept/list")
    public List<Dept> queryAll(){

        return deptService.queryAll();
    }
    
    //获取注册在注册中心的实例
    @GetMappering("/dept/discovery")
    public Object discovery(){
        //获取所有实例
        List<String> services = client.getServices();
        System.out.println("discovery->services:" +services);

        //获取一个具体的微服务信息  参数是 application，即yaml文件中spring.application.name的值
        List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");

        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getInstanceId() + "\t"+
                    instance.getHost() + "\t"+
                    instance.getPort() + "\t"+
                    instance.getUri()
            );
        }
        
        return this.client;
    }

}

mapper.xml

<?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.flf.dao.DeptDao">

    <insert id="addDept" parameterType="Dept">
        insert into dept(deptName,db_source)
        values (#{deptName},DATABASE())
    </insert>

    <select id="queryById" parameterType="Long" resultType="Dept">
        select * from dept where deptNo = #{deptNo}
    </select>

    <select id="queryAll" resultType="Dept">
        select * from dept
    </select>

</mapper>

启动类

//启动类
@SpringBootApplication
public class DeptProviderStart_8081 {

    public static void main(String[] args) {

        SpringApplication.run(DeptProviderStart_8081.class,args);
    }

}

服务消费者

导入jar包

 <!-- 一般消费者只需要实体类和web -->
<dependencies>

     <dependency>
         <groupId>org.example</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>

配置yaml 文件

只需要配置端口号即可，一般默认为 80

配置RestTemplate

建立一个 config文件夹，在文件夹里编写

@Configuration
public class ConfigBean {

    @Bean   //需要什么就把什么当做返回值
    public RestTemplate getRestTemplate(){

        return new RestTemplate();	//默认配置
    }

编写controller层

/**
 *
 * 消费者，不需要service业务层
 * 自定义RestTemplate，注册到spring中
 * 通过 RestTemplate 来获取提供者的方法
 * 参数 ：String url(路径),  Object request(实体，通常用Map,也可以使用实体), Class<T> responseType(返回的参数类型)
 */
@Resource			//自己配置的RestTemplate
private RestTemplate restTemplate;  //提供多种便捷访问远程http服务的方法，简单的Restful服务模板

private static final String REST_URL_PREFIX = "http://localhost:8081";

@RequestMapping("/consumer/dept/add")
public Boolean add(Dept dept){
    //restTemplate之后 用post 还是 get 取决于提供者的controller
    return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
}

@RequestMapping("/consumer/dept/get/{id}")
public Dept getDept(@PathVariable("id") Long id){

    return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
}

@RequestMapping("/consumer/dept/list")
public List<Dept> list(){

    return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
}

Eureka

什么是Eureka

Eureka遵循AP原则
Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST的服务，用于定位服务，以实现云端中间层发现和故障转移，服务注册与发现对微服务很重要，有了服务发现注册，只需要使用服务的标识符，就可以访问到服务器，而不需要修改服务调用的配置文件了，功能类似于Dubbo的注册中心，如：zookeeper

原理

Eureka的基本架构

SpringCloud 封装了NetFlix公司开发的Eureka模块来实现服务注册和发现(对比Zookeeper)。Eureka采用了C-S的架构设计，EurekaServer 作为服务注册功能的服务器,他是服务注册中心
而系统中的其他微服务。使用Eureka的客户端连接到EurekaServer并维持心跳连接。这样系统的维护人员就可以通过EurekaServer来监控系统中各个微服务是否正常运行，SpringCloud的一些其他模块(比如Zuul)就可以通过EurekaServer来发现系统中的其他微服务，并执行相关的逻辑;
Eureka 包含两个组件: Eureka Server和Eureka Client 。
Eureka Server提供服务注册服务，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server中的服务注册表中将会村粗所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。
Eureka Client是一个Java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器。在应用启动后，将会向EurekaServer发送心跳(默认周期为30秒)。如果
Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除掉(默认周期为90秒)

三大角色

Eureka Server:提供服务的注册于发现。
Service Provider:将自身服务注册到Eureka中，从而使消费方能够找到。
Service Consumer:服务消费方从Eureka中获取注册服务列表，从而找到消费服务。

配置Eureka

1.导入jar包

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

       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-devtools</artifactId>
       </dependency>
   </dependencies>

2.配置yaml文件

server:
  port: 7001

eureka:
  instance:
    hostname: localhost   #Eureka服务端的实例名
  client:
    register-with-eureka: false   #表示是否向Eureka注册中心注册自己
    fetch-registry: false     #fetch-registry 如果为false，标明自己为注册中心
    service-url:    #监控页面
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

3.加注解

@SpringBootApplication
@EnableEurekaServer     //服务端的启动类,可以接受别人注册服务
public class Eureka_7001_Start {

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

错误

进入 localhost:7001 后可能会出现 404，原因可能是 springboot和springCloud版本不兼容

==推荐版本:springBoot:2.3.3.RELEASE springCloud:Hoxton.SR8==

版本对应查询地址 https://spring.io/projects/spring-boot#learn

服务注册

1.在服务提供者的pom文件加入jar包

在之前Rest环境搭建中的服务提供者的基础上额外加入该jar包

 <!--spring-cloud-starter-netflix-eureka-client -->
<dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
     <version>2.2.7.RELEASE</version>
</dependency>

//如果没加该jar包，在Eureka注册中心页面，点击状态会跳转404网页
//导入之后需要咋子 yaml文件配置信息
<!-- 完善监控信息 -->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2.在yaml文件加入 Eureka配置

该配置service-url 需要和==注册中心==的地址一致

#Eureka
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: spring-cloud-provider-dept-8081  #修改状态名

#info信息,导入actuator之后配置,这个用于查看注册中心中，点击该服务，弹出提供该服务的信息
info:		#json格式即可，可任意配置
  app.name: flf
  company.name: zzz

点击此处

然后调出页面，页面显示的为 info 配置的信息

3.在启动类加注解

@SpringBootApplication
@EnableEurekaClient			//服务提供者,服务启动后，自动注册到Eureka中
public class DeptProviderStart_8081 {

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

自我保护机制

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

默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例(==默认90秒==)。但是当网络分区故障发生时，微服务与Eureka之间无法正常通行，以上行为可能变得非常危险了-因为微服务本身其实是健康的，此时本不应该注销这个服务。Eureka通过自我保护机制来解决这个问题—当EurekaServer节点在短时间内丢失过多客户端时(可能发生了网络分区故障)，那么这个节点就会进入==自我保护模式==。一旦进入该模式（==当实例少于85%时，会进入该模式==），EurekaServer就会保护服务注册表中的信息，不再删除服务注册表中的数据(也就是不会注销任何微服务)。当网络故障恢复后，该EurekaServer 节点会自动退出自我保护模式。
在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例。当它收到的心跳数重新恢复到阈值以上时，该EurekaServer 节点就会自动退出自我保护模式。宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。
综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务(健康的微服务和不健康的微服务都会保留)，也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮和稳定
在SpringCloud中, 可以使用eureka. server. enable-self-preservation = false 禁用自我保护模式[不推荐关闭自我保护机制]

Eureka集群

1.配置注册中心yaml

需要几个注册中心，就新建几个木块

或者在之前的注册中心的 yaml文件用 --- 分隔，做不同的配置，然后不同配置启动同一个模块

yaml文件配置

server:
  port: 7001

eureka:
  instance:
    hostname: 7001  #Eureka服务端的实例名
  client:
    register-with-eureka: false   #表示是否向Eureka注册中心注册自己
    fetch-registry: false     #fetch-registry 如果为false，标明自己为注册中心
    service-url:    #监控页面
      #这个是单机时候用的
      #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群时，互相关联				//这个地方需要与另外的注册中心关联，其中localhost是其他注册中心的ip地址，这里是主机ip
      defaultZone: http://localhost:7002/eureka/,http://localhost:7003/eureka/

其他的yaml文件除了 hostname ，port和defaultZone 不同之外，其余都一样

2.配置服务提供者yaml

只需要添加其他注册中心的注册地址即可

#Eureka
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka,http://localhost:7002/eureka,http://localhost:7003/eureka
  instance:
    instance-id: spring-cloud-provider-dept-8081  #修改状态名

3.依次启动

启动三个注册中心，然后启动服务提供者就可以

每个注册中心都会注册服务提供者的服务

当一个节点挂掉之后，不会影响服务

CAP原则

REDMS(MySQL,Oracle,sqlServer) —> ACID

NoSQL(redis,mongdb) —> CAP

ACID

A (Atomicity) 原子性
C (Consistency) 一致性
I (Isolation) 隔离性
D (Durability) 持久性

CAP

C (Consistency) 强一致性
A (Availability) 可用性
P (Partition tolerance) 分区容错性

CAP的三进二：CA，AP，CP

CAP核心理论

1.一个分布式系统不可能同时很好地满足一致性，可用性，分区容错性三个需求

2.根据CAP原理，将NoSQL数据库分成了满足CA原则，AP原则，CP原则三大类

CA:单点集群，满足一致性，可用性的系统，通常可拓展性较差
CP:满足一致性，分区容错性，通常性能不是特别高
AP:满足可用性，分区容错性，可能对一致性要求稍低

由于在分布式系统中，分区容错性p 是必要的，因此只能在A，和C之间权衡

Zookeeper保证的是CP
Eureka保证的是AP

Zookeeper：CP

当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接受服务直接down掉不可用。也就是说，服务注册功能对可用性的要求要高于一致性。但是zk会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举。问题在于，选举leader的时间太长，30-120s，且选举期间整个zk集群都是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因为网络问题使得zk集群失去master节点是较大概率会发生的事件，虽然服务最终能够恢复，但是漫长的选举时间导致的注册长期不可用是不能容忍的。

Eureka：AP

Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册时，如果发现连接失败，则会自动切换至其他节点，只要有一台Eureka还在，就能保住注册服务的可用性，只不过查到的信息可能不是最新的，除此之外，Eureka还有一种自我保护机制，如果在15分钟内超过15%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，此时会出现以下几种情况:

Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务
Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其他节点上(即保证当前节点依然可用)
当网络稳定时，当前实例新的注册信息会被同步到其他节点中

因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像Zookeeper那样使整个注册服务瘫痪

Ribbon

Ribbon简介

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套==客户端负载均衡==的工具。
简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将NetFlix的中间层服务连接在一起。 Ribbon的客户端组件提供一系列完整的配置项如: 连接超时、重试等等。简单的说，就是在配置文件中列出LoadBalancer (简称LB: 负载均衡)后面所有的机器，Ribbon会自动的帮助你基于某种规则(如简单轮询，随机连接等等)去连接这些机器，也很容易使用Ribbon实现自定义的负载均衡算法

Ribbon作用

LB,即负载均衡(Load Balance) ，在微服务或分布式集群中经常用的一一种应用。
负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA (高可用)。
常见的负载均衡软件有Nginx, Lvs 等等
dubbo. SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义
负载均衡简单分类:
- 集中式LB
  - 即在服务的消费方和提供方之间使用独立的LB设施，如Nginx(反向代理服务器),油该设施负责把访问请求通过某种策略转发至服务的提供方!
- 进程式LB
  - 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出-个合适的服务器。
  - ==Ribon属于进程内LB==. 它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址!

springCloud加入Ribbon

1.在消费者中加入Jar包

加入ribbon以及Eureka的jar包

<!-- spring-cloud-starter-netflix-ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>

 <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>

2.配置yaml

#Eureka
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/

3.加注解

在启动类上加上 @EnableEurekaClient

4.配置config

配置文件

@Configuration
public class ConfigBean {
    @Bean   //需要什么就把什么当做返回值
    @LoadBalanced   //负载均衡
    public RestTemplate getRestTemplate(){

        return new RestTemplate();	//默认配置
    }
}

5.更改controller

由于做了负载均衡，所以访问地址是根据负载均衡算法选择的，而不是单机时固定的路径，所以要改变访问路径

6.新建多个模块/多个配置文件

新建多个模块或者通过不同配置文件启动同一个模块,只需要保持==spring.application.name==相同

7.分别启动

分别启动消费者，注册中心，多个提供者，然后通过消费者调用提供者(查看结果，会发现数据来自不同数据库，均衡模式默认是轮询)

Ribbon下的springCloud例子

负载均衡有ribbon和feign，ribbon更具有restful风格，而feign更像是Service和Controller层之间的调用(面向接口)，==feign默认集成了ribbon==，ribbon的完整例子：

API接口模块

api模块只有一个pojo类

@Data       //get.set.toString
@NoArgsConstructor  //无参构造
@Accessors(chain = true)    //支持链式写法
public class Dept implements Serializable { //实体类序列化

    private Long deptNo;
    private String deptName;
    //该字段表示此数据存在于哪一个数据库，微服务，一个服务可能对应一个数据库，同一个信息可能存在不同的数据库
    private String db_source;

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

    /*
    * 链式写法，如：
    * Dept dept = new Dept();
    *
    * dept.setDeptNo(11).setDeptName("zz").setDb_source("001");
    *
    * */

Eureka注册中心

jar包

eureka以及热部署

<!-- spring-cloud-starter-netflix-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

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

    </dependencies>

yaml配置

server:
  port: 7001

eureka:
  instance:
    hostname: 7001  #Eureka服务端的实例名
  client:
    register-with-eureka: false   #表示是否向Eureka注册中心注册自己
    fetch-registry: false     #fetch-registry 如果为false，标明自己为注册中心
    service-url:    #监控页面
      #这个是单机时候用的
      #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群时，互相关联
      defaultZone: http://localhost:7002/eureka/,http://localhost:7003/eureka/

主启动类

@SpringBootApplication
@EnableEurekaServer		//注册中心用EnableEurekaServer，提供者用EnableEurekaClient
public class Eureka_7001_start {

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

}

提供者

jar包

<dependencies>
        <!-- 需要拿到实体类,所以需要将包含实体类的module配置一下 -->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--spring-cloud-starter-netflix-eureka-client -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

        <!-- 完善监控信息,这个jar包用于Eureka注册中心页面查看实例信息 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <version>2.3.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </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-web</artifactId>
        </dependency>

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

        <!-- jetty -->
        <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>

yml配置

server:
  port: 8081

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


spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/xiaoxi?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: 123456

#Eureka
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka,http://localhost:7002/eureka,http://localhost:7003/eureka
  instance:
    instance-id: spring-cloud-provider-dept-8081  #修改状态名

#info
info:
  app.name: flf
  company.name: zzz

省略Dao，Service，Impl,Mapper.xml

Controller

@RestController
public class DeptController {

    @Resource
    private DeptService deptService;

    @Resource
    private DiscoveryClient client;

    @PostMapping("/dept/add")
    public Boolean addDept(Dept dept){

        return deptService.addDept(dept);
    }

    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id){

        return deptService.queryById(id);
    }

    @GetMapping("/dept/list")
    public List<Dept> queryAll(){

        return deptService.queryAll();
    }

    //获取注册在注册中心的实例
    @RequestMapping("dept/discovery")
    public Object discovery(){
        //获取所有实例
        List<String> services = client.getServices();
        System.out.println("discovery->services:" +services);

        //获取一个具体的微服务信息  参数是 application，即yaml文件中spring.application.name的值
        List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");

        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getInstanceId() + "\t\t"+
                    instance.getHost() + "\t\t"+
                    instance.getPort() + "\t"+
                    instance.getUri()
            );
        }

        return this.client;
    }

}

启动类

@SpringBootApplication
@EnableEurekaClient		//除了注册中心是EnableEurekaServer，无论是provider和consumer都是EnableEurekaClient
public class DeptProviderStart_8081 {

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

消费者

jar包

<dependencies>

        <!-- spring-cloud-starter-netflix-ribbon -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.example</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>

yaml文件

server:
  port: 80

#Eureka
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/

RestTemplate

restTemplate与controller同级

//配置文件 注解
@Configuration
public class ConfigBean {

    @Bean   //需要什么就把什么当做返回值
    @LoadBalanced   //负载均衡
    public RestTemplate getRestTemplate(){

        return new RestTemplate();	//默认配置
    }
}

controller

@RestController
public class DeptConsumer_80 {

    /**
     *
     * 消费者，不需要service业务层
     * 自定义RestTemplate，注册到spring中
     * 通过 RestTemplate 来获取提供者的方法
     * 参数 ：String url(路径),  Object request(实体，通常用Map,也可以使用实体), Class<T> responseType(返回的参数类型)
     */
    @Resource
    private RestTemplate restTemplate;  //提供多种便捷访问远程http服务的方法，简单的Restful服务模板

    /*
    *   单机情况下的配置
    *   private static final String REST_URL_PREFIX = "http://localhost:8081";
    * */
    //当有负载均衡时，访问路径前缀不再是 固定的了，此时应该 用application作为访问路径
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    @RequestMapping("/consumer/dept/add")
    public Boolean add(Dept dept){
        //restTemplate之后 用post 还是 get 取决于提供者的controller
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept getDept(@PathVariable("id") Long id){

        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){

        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }
}

启动类

//Eureka集成了Ribbon后，客户端可直接调用方法
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "myRlue",configuration = myRule.class)	//自定义的均衡策略，文件在controller的上一级
public class DeptConsumer_80_start {

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

访问路径，按照==消费者Controller中配置的路径==

自定义负载均衡算法

负载均衡种类

RandomRule：随机选取负载均衡策略，随机Random对象，在所有服务实例中随机找一个服务的索引号，然后从上线的服务中获取对应的服务。
RoundRobinRule：线性轮询负载均衡策略。
WeightedResponseTimeRule：响应时间作为选取权重的负载均衡策略，根据平均响应时间计算所有服务的权重，响应时间越短的服务权重越大，被选中的概率越高。刚启动时，如果统计信息不足，则使用线性轮询策略，等信息足够时，再切换到WeightedResponseTimeRule。
RetryRule：使用线性轮询策略获取服务，如果获取失败则在指定时间内重试，重新获取可用服务。
ClientConfigEnabledRoundRobinRule：默认通过线性轮询策略选取服务。通过继承该类，并且对choose方法进行重写，可以实现更多的策略，继承后保底使用RoundRobinRule策略。
BestAvailableRule：继承自ClientConfigEnabledRoundRobinRule。从所有没有断开的服务中，选取到目前为止请求数量最小的服务。
PredicateBasedRule：抽象类，提供一个choose方法的模板，通过调用AbstractServerPredicate实现类的过滤方法来过滤出目标的服务，再通过轮询方法选出一个服务。
AvailabilityFilteringRule：按可用性进行过滤服务的负载均衡策略，会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，还有并发的连接数超过阈值的服务，然后对剩余的服务列表进行线性轮询。
ZoneAvoidanceRule：本身没有重写choose方法，用的还是抽象父类PredicateBasedRule的choose。

注意

自定义的负载均衡策略不能与主启动类位于同一级目录下，这样会被springBoot扫描到，自定义的规则必须在Eureka的规则实例化以后再实例化才会生效

//Eureka集成了Ribbon后，客户端可直接调用方法
@SpringBootApplication
@EnableEurekaClient		//加入注解，随意写名字，confinguration的值是自定义策略的类
@RibbonClient(name = "myRlue",configuration = myRule.class)
public class DeptConsumer_80_start {

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

Feign负载均衡

简介

feign是声明式的web service客户端，它让微服务之间的调用变得更简单，类似于controller调用service接口，springCloud集成了Ribbo和Eureka，可在使用Feign时提供负载均衡的http客户端

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

feign，主要是社区，都习惯面向接口编程，调用微服务访问两种方法:

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

Feign作用

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

feign编码

1.导入依赖

在api 模块以及 feign(消费者)模块导入feign jar包

<!-- spring-cloud-starter-openfeign -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>

2.api接口配置service

在api接口新建一个service，并在类上引入@FeignClient

@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT") //服务实例名
public interface FeignService {

    @RequestMapping("/dept/add")
    public Boolean add(Dept dept);

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept getDept(@PathVariable("id") Long id);

    @RequestMapping("/dept/list")
    public List<Dept> list();
}

3.在消费者注册

在消费者中注册api的service，并调用

@RestController
public class DeptConsumer_feign {

    @Resource
    private FeignService feignService;

    @RequestMapping("/consumer/dept/add")
    public Boolean add(Dept dept){
        return this.feignService.add(dept);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept getDept(@PathVariable("id") Long id){

        return this.feignService.getDept(id);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){

       return this.feignService.list();
    }
}

4.在消费者启动类加注解

在主启动类上加入@EnableFeignClients(basePackages = {“com.flf.springcloud”}),值为api接口service所在的目录

Hystrix

分布式面临的问题

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

服务雪崩

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

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

什么是Hystrix

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

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

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

服务熔断

1.导入依赖

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

2.编写备用方法

3.在方法上加入注解

@RequestMapping("/dept/get/{id}")
    @HystrixCommand(fallbackMethod = "hystrix")	//hystrix 是备用的方法名字，该方法失败后，会调用备用方法
    public Dept queryById(@PathVariable("id") Long id){

        return deptService.queryById(id);
    }

4.在启动类上配置

在启动类上加入 @EnableCircuitBreaker ，开启熔断机制

服务降级

1.在api模块写失败返回工厂

@Component
public class DeptClientServiceFallBack implements FallbackFactory {
    @Override
    public FeignService create(Throwable throwable) {
        return new FeignService() {
            @Override
            public List<Dept> list() {
                return null;
            }

            @Override
            public Dept get(Long id) {
                return new Dept().setDeptNo(id)
                        .setDeptName("已被关闭")
                        .setDb_source("not found in any datasource");
            }
        };
    }
}

2.api接口引入返回工厂类

//feign 默认集成了 Hystrix，value是 spring，application.name 	关闭服务时，客户再次访问服务时，定义的返回
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallBack.class)
public interface FeignService {

    @RequestMapping("/dept/list")
    public List<Dept> list();

    @RequestMapping("dept/get/{id}")
    public Dept get(@PathVariable("id")Long id);
}

3.配置消费者yaml文件

#开启降级
feign:
  hystrix:
    enabled: true

服务关闭后，再次访问的页面信息

Dashboard流监控

1.新建dashboard模块

导入jar包

<!-- 新加入两个jar包 -->	
<dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
           <version>2.2.7.RELEASE</version>
       </dependency>

       <!-- hystrix-dashboard -->
       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
           <version>2.2.7.RELEASE</version>
       </dependency>

       
       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
           <version>2.2.7.RELEASE</version>
       </dependency>

       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
           <version>2.2.7.RELEASE</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>

配置yml

server:
  port: 9001

eureka:
  client:
    register-with-eureka: false

#如果不配置，http://localhost:9001/hystrix/monitor 可能会出现找不到服务
hystrix:
  dashboard:
    proxy-stream-allow-list: "*"

然后配置主启动类

2.配置提供者

==需要在有Hystrix熔断的提供者中配置==,即提供者的主配置类需要有@EnableCircuitBreaker,并且方法需要用到@HystrixCommand

如果提供者没有熔断，访问时会出现404

在主启动类中注册一个servlet

@Bean
public ServletRegistrationBean hystrixMetricsStreamServlet(){

       ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());

       servletRegistrationBean.addUrlMappings("/actuator/hystrix.stream");

       return servletRegistrationBean;
   }

在进入提供者的 /actuator/hystrix.stream 页面时，需先==调用一次提供者里的方法，否则会一直ping,却没有数据==

3.进入监控页面

进入http://localhost:9001/hystrix，并在stream中输入提供者的ip

Zuul

概述

Zuul包含了对请求的==路由==和==过滤==两个最主要的功能:

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

注意: Zuul服务最终还是会注册进Eureka提供:代理+路由+过滤三大功能

使用

1.添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>

2.配置yml

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka,http://localhost:7002/eureka,http://localhost:7003/eureka
  instance:
    instance-id: zuul

spring:
  application:
    name: zuul-9527
zuul:
  routes:
    serviceId: springcloud-provider-dept
    path: /Mydept/**
  ignored-services: springcloud-provider-dept	#不允许访问的路径

3.主启动类

@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy //网关
public class Zuul_9527 {
    public static void main(String[] args) {
        SpringApplication.run(Zuul_9527.class,args);
    }
}

本文作者： 腾飞
本文链接： https://www.tengfei.eu.org/article/def94604.html
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！

SpringCloud和SpringBoot关系

创建springCloud

Rest环境搭建

在父模块导入jar包

服务提供者

按需求配置yaml文件

编写dao，service等

服务消费者

Eureka

什么是Eureka

原理

配置Eureka

1.导入jar包

2.配置yaml文件

3.加注解

错误

服务注册

1.在服务提供者的pom文件加入jar包

2.在yaml文件加入 Eureka配置

3.在启动类加注解

自我保护机制

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

Eureka集群

1.配置注册中心yaml

2.配置服务提供者yaml

3.依次启动

CAP原则

ACID

CAP

CAP核心理论

Zookeeper：CP

Eureka：AP

Ribbon

Ribbon简介

Ribbon作用

springCloud加入Ribbon

1.在消费者中加入Jar包

2.配置yaml

3.加注解

4.配置config

5.更改controller

6.新建多个模块/多个配置文件

7.分别启动

Ribbon下的springCloud例子

API接口模块

Eureka注册中心

jar包

yaml配置

主启动类

提供者

jar包

yml配置

省略Dao，Service，Impl,Mapper.xml

Controller

启动类

消费者

jar包

yaml文件

RestTemplate

controller

启动类

自定义负载均衡算法

负载均衡种类

注意

Feign负载均衡

简介

Feign作用

feign编码

1.导入依赖

2.api接口配置service

3.在消费者注册

4.在消费者启动类加注解

Hystrix

服务雪崩

什么是Hystrix

作用

服务熔断

1.导入依赖

2.编写备用方法

3.在方法上加入注解

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