记录springcloud ==Hoxtonl版本_springcloud 版本 hoxtonl-CSDN博客

本文链接：https://blog.csdn.net/weixin_44540130/article/details/117458892

系列文章目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、pandas是什么？

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、使用步骤

1.引入库

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.读入数据

代码如下（示例）：

data = pd.read_csv(
    'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())

该处使用的url网络请求的数据。

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
记录springcloud

giree 地址：https://gitee.com/wx_c3b99916a9/SpringCloud/tree/master/

Spring Cloud 是什么？

在学习本课程之前，读者有必要先了解一下 Spring Cloud。

Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的开发便利性简化了分布式系统的开发，比如服务发现、服务网关、服务路由、链路追踪等。Spring Cloud 并不重复造轮子，而是将市面上开发得比较好的模块集成进去，进行封装，从而减少了各模块的开发成本。换句话说：Spring Cloud 提供了构建分布式系统所需的“全家桶”。

Spring Cloud 优缺点

其主要优点有：

集大成者，Spring Cloud 包含了微服务架构的方方面面。
约定优于配置，基于注解，没有配置文件。
轻量级组件，Spring Cloud 整合的组件大多比较轻量级，且都是各自领域的佼佼者。
开发简便，Spring Cloud 对各个组件进行了大量的封装，从而简化了开发。
开发灵活，Spring Cloud 的组件都是解耦的，开发人员可以灵活按需选择组件。

接下来，我们看下它的缺点：

项目结构复杂，每一个组件或者每一个服务都需要创建一个项目。
部署门槛高，项目部署需要配合 Docker 等容器技术进行集群部署，而要想深入了解 Docker，学习成本高。

Spring Cloud 的优势是显而易见的。因此对于想研究微服务架构的同学来说，学习 Spring Cloud 是一个不错的选择。

Spring Cloud 和 Dubbo +zeekeep ()对比

Dubbo 只是实现了服务治理，而 Spring Cloud 实现了微服务架构的方方面面，服务治理只是其中的一个方面。下面通过一张图对其进行比较：

这里写图片描述

SpringCloud分布式开发五大组件详解

服务发现——Netflix Eureka （Eureka 模块服务的注册于发现现在比较流行的nacos相似！！）

客服端负载均衡——Netflix Ribbon（Ribbon，nginx, Lvs,）

断路器——Netflix Hystrix

服务网关——Netflix Zuul

分布式配置——Spring Cloud Config

Eureka的使用：

大部分的这类似帮组的框架，大致的步骤分为：、

1，映入对应的框架的maven包，

2, 编写yml 配置文件，

3，添加注解，

首先新建一个maven 的项目，在里面建好，eureka 注册模块，服务提供者模块，消费者模块，这三个最基本的环境，

pom文件注意版本，在使用springboot与springcloud 版本

大版本对应：

Spring Cloud	Spring Boot
Angel版本	兼容Spring Boot 1.2.x
Brixton版本	兼容Spring Boot 1.3.x，也兼容Spring Boot 1.4.x
Camden版本	兼容Spring Boot 1.4.x，也兼容Spring Boot 1.5.x
Dalston版本、Edgware版本	兼容Spring Boot 1.5.x，不兼容Spring Boot 2.0.x
Finchley版本	兼容Spring Boot 2.0.x，不兼容Spring Boot 1.5.x
Greenwich版本	兼容Spring Boot 2.1.x
Hoxtonl版本	兼容Spring Boot 2.2.x

eureka 注册模块

 
启动类上需要加的注解@EnableEurekaServer   //声明这是一个Eureka服务器
    
 yaml文件代码 
    server:
  port: 8761    #声明端口号
eureka:
  instance:
    hostname: eureka7001 //定义eureka名称
  client:
    register-with-eureka: false    #默认是true，将自己注册到eureka上
    fetch-registry: false      #是否从eureka上获取信息，由于本案例是单机，无需从别的eureka上获取注册信息
    service-url:
      defaultZone: http://localhost:8762/eureka,http://localhost:8761/eureka
      #设置与

服务提供者模块

 启动类上需要加的注解 @EnableEurekaClient
//@EnableDiscoveryClient   //也可以用EnableDiscoveryClient代替，前者兼容性更大，后者仅能兼容Eureka
 perproties文件代码 

server.port=8000
spring.thymeleaf.cache=false
spring.datasource.username=root
spring.datasource.password=root123
spring.datasource.url=jdbc:mysql://localhost:3306/demo01?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.application.name=provider8000 //定义模块名称
eureka.client.service-url.defaultZone= http://localhost:8761/eureka,http://localhost:8762/eureka ///需要把模块注册到对应的euireka 中去，
eureka.instance.prefer-ip-address=true
///答案就是eureka.instance.prefer-ip-address=true。配置eureka.instance.prefer-ip-address = true 就可以将IP注册到Eureka Server上，而如果不配置就是机器的主机名。

消费者模块

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

使用ribbojn 实现负载均衡（多个模块在euerka 集群中，互相注册，euerka 直间互相调用模块）

主要修改的是在消费者中；

Eureka 的自我保护j机制，如果在eureka中注册的服务断开，eureka中就会出现下列中的保护字眼，但是我们一样去运行该模块中的方法，依旧是可查询到数据，

这就需要说一下eureka的底层遵循的一个CAP原则；

一个好的分布式系统，不肯能同时满足CAP三个原则，

在eureka中同时满足了AP (具有很好的可用性，容错性，但是当我们的服务崩掉了，理论上在eureka中，服务应该不存在才对，但是我们的调用方法，还能是实现，这就是eureka不能很好保障服务的C(一致性)，eureka自身的保护机制，它会班把我们的服务依旧留在eureka中，但是它会提示我们，提示的现象就是下面的红色字体，说明eureka已经开启了自我保护机制)

C一致性，A可用性，P容错性，

Feign（Ribbon）组件的使用

Ribbon

ribbon是在我们的客户端接口中实现对方法的查询，通过模块的吗名称在eureka 集群中查询到我们的方法，执行

第一步，导入我们的ribbon 包：

<!-- springcloud  + ribbon 负载均衡   进程式   -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-eureka</artifactId>
            <version>2.2.2</version>
        </dependency>

第二步：加载配置

需要我们重写一个restTemplate 的配置类，利用地址的跳转；

@Configuration
public class confingBean {
    @Bean
    @LoadBalanced  ///ribbon 的注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

第三步：启动类上加一个注解

@SpringBootApplication
@EnableDiscoveryClient
@RibbonClient(name="SPRINGBOOT-PROVIDER-DEPT") SPRINGBOOT-PROVIDER-DEPT依据查询的模块名称
spring.application.name=SPRINGBOOT-PROVIDER-DEPT
public class ServerConsumer {
    public static void main(String[] args) {
        SpringApplication.run(ServerConsumer.class, args);
    }
}

第四部：编写控制器中的方法

   @Autowired
    private RestTemplate restTemplate;

    private  static final String REST_URL_PREFIX="http://SPRINGBOOT-PROVIDER-DEPT";
    @GetMapping("/hello")
    public String getUser() {
        return this.restTemplate.getForObject(REST_URL_PREFIX+"/hello", String.class);
    }

上述是我们使用ribbon 实现复制啊负载均衡的一个最简单的方法，这里我们查询到多个模块中相同的方法的时候，ribbon内部是有一个默认使用轮训方法，依次去各个模块中查询到数据，我们也可以去自己写一个rulun 的方法

这里我就不写了，想了解的去csdn 中查询到对应的关键字，学习就好了，

ribbon 负载均衡中，选择哪一个模块中的方法，需要我们自己写一个轮训的方法

Feign 服务调用

不同于ribbon 是依据模块名称来找方法，我们在实际的开发中，更加喜欢使用springIOC 注入一股接口方法，

导入maven依赖包

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

在我们的客户端启动类中加@EnableFeignClients(basePackages = {“com.demo”})

接口类

@FeignClient(value = “SERVICEWOMAN”,fallbackFactory = server800xFallbackFactory.class)

SERVICEWOMAN===模块名称，server800xFallbackFactory 使用熔断机制server800xFallbackFactory，

当方法的访问量太多导致方法，崩溃时，执行的方法，像一个保险丝一样保护着服务，

@FeignClient(value = "SERVICEWOMAN",fallbackFactory = server800xFallbackFactory.class)
@Component
@WebService
public interface server800X {
    @GetMapping("/helloFeign")
    public String index();
}

server800xFallbackFactory.class

@Component
public class server800xFallbackFactory implements FallbackFactory {
    @Override
    public Object create(Throwable throwable) {
        return "01熔断器测试方法实现成功！！！！";
    }
}

这里比较长晕倒的一个问题

Description:

Field ServerFeign in com.demo.controller.HelloController required a bean of type 'com.demo.client.server800X' that could not be found.


Action:
（com.demo.client.server800X这个类没有注入到我们的项目里面去，需要值配置一个bean ）
Consider defining a bean of type 'com.demo.client.server800X' in your configuration.

这边需要检查我们的接口类，有没有写@Service（其它注入注解也可以）这个注解，

//@ComponentScan(basePackages = {"com.demo.client","com.demo.controller"})

你也可以单独让启动类去扫描我们指定的一个包路径

Hystrix 服务熔断器

在微服务架构中，根据业务来拆分成一个个的服务，服务与服务之间可以相互调用（RPC），在Spring Cloud可以用RestTemplate+Ribbon和Feign来调用。为了保证其高可用，单个服务通常会集群部署。由于网络原因或者自身的原因，服务并不能保证100%可用，如果单个服务出现问题，调用这个服务就会出现线程阻塞，此时若有大量的请求涌入，Servlet容器的线程资源会被消耗完毕，导致服务瘫痪。服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的“雪崩”效应。

第一步导入我们需要使用的maven 依赖包

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

启动类中加上注解

//启动类
@SpringBootApplication
@EnableEurekaClient //在服务启动后，自动注册到Eureka中
@EnableDiscoveryClient //服务发现
@EnableCircuitBreaker //添加对熔断的支持

直接在controller中使用需要加上一个注解，@HystrixCommand(fallbackMethod = “hystrixGet”)

@HystrixCommand 开启熔断的注解，fallbackMethod 熔断之后调用的一个备用方法，提示用户方法崩掉了

@GetMapping("/dept/get/{id}")
@HystrixCommand(fallbackMethod = "hystrixGet")
public Dept queryById(@PathVariable("id") Long id){
    Dept dept = deptService.queryById(id);
    if(dept == null){
        throw new RuntimeException("id => " + id + ",不存在该用户，或者无法找到");
    }
    return dept;
}

//备选方法
public Dept hystrixGet(@PathVariable("id") Long id){
    return new Dept().setDeptno(id)
            .setDename("id => " + id + "没有对应的信息，null--@Hystrix")
            .setDb_source("no this database i在n mysql");

}

Feign中使用断路器

服务降级：什么是服务降级，通俗的来说，就是把进程少的服务，方法关闭，把多余的资源拿去给我们的访问量大的方法，降级是指自己的待遇下降了，从RPC调用环节来讲，就是去访问一个本地的伪装者而不是真实的服务。当双11活动时，把无关交易的服务统统降级，如查看蚂蚁深林，查看历史订单，商品历史评论，只显示最后100条等等。避免发生服务雪崩，

在feign服务调用的基础上加上一个接口的实现类，

@Component
public class server800xFallbackFactory implements FallbackFactory {
    @Override
    public Object create(Throwable throwable) {
        return "01熔断器测试方法实现成功！！！！";
    }
}

@FeignClient(value = "SERVICEWOMAN",fallbackFactory = server800xFallbackFactory.class)

（熔断器部分，实现不出来熔断的效果…)

Hystrix 的Dashboard

Hystrix 的Dashboard的一个并发检测的东西，只需要直接见一个模块，模块中导入一个maven 的包，在需要检测的模块中在加上一个包

下列中：

<---  hystrix-dashboard 检测的包 ---> 
<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
            <version>1.4.6.RELEASE</version>
        <dependency>
   各模块需要加的包
     <!--完善监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

启动这个模块可以看到这样的一个页面：

Hystrix 的Dashboard 提供了-----集群检测，服务检测，单个模块检测，

这里以单个服务检测的一个错误为例，也可以更加熟知Hystrix 的Dashboard ；

hystrix.stream 访问一直ping并且Hystrix Dashboard 一直loading的问题

现象描述在访问hystrix.stream一直ping
在这里插入图片描述
Hystrix Dashboard一直loading 如图：

依赖加了

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

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

注解加了：

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
@EnableFeignClients//PROVIDER
public class ClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(ClientApplication.class, args);
    }
}

12345678910

配置文件也加了：

management:
  endpoints:
    web:
      exposure:
        include: env,health,metrics,info,hystrix.stream
12345

调用方法也写了：

@RestController
public class ClientController {
    @Autowired
    private DemoClient demoClient;

    @RequestMapping("query")
    public String query() {
        return demoClient.query();
    }
}
12345678910

还是不好使，为啥呢？
因为方法上面没有加注解 @HystrixCommand

@RestController
public class ClientController {
    @Autowired
    private DemoClient demoClient;

    @HystrixCommand(fallbackMethod = "fail2")
    @RequestMapping("query")
    public String query() {
        return demoClient.query();
    }

    private String fail2() {
        System.out.println("fail2");
        throw new RuntimeException();
    }
}
12345678910111213141516

加上注解重启启动在调用就好使了，原理还不太懂。继续研究中。。。
在这里插入图片描述

https://blog.csdn.net/weixin_43815847/article/details/103479294

zuul路由

一个包，一个配置，在eureka 集群内通过一个借口可以访问到所用的注册模块；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hzkkbx5K-1622592595057)(C:\Users\刘\AppData\Roaming\Typora\typora-user-images\image-20210220165303604.png)]

这里需要主要说吧一下的是配置文件：

# 路由网关配置
zuul:
  routes:
    mydept.serviceId: SPRINGBOOT-PROVIDER-DEPT//将zuul注册在eureka中，需要擦查询的模块名称
    mydept.path: /mydept/**
  # 不能再使用这个路径访问了，ignore : 忽略 | “*” 隐藏全部的微服务真实路径
  ignored-services: "*"
  prefix: /ljm # 公共设置的前缀

springCloud config

在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件。在Spring Cloud中，有分布式配置中心组件spring cloud config ，它支持配置服务放在配置服务的内存中（即本地），也支持放在远程Git仓库中。在spring cloud config 组件中，分两个角色，一是config server，二是config client。

我们的系统一般都是CS 架构（Client +Server)我们在这儿大致的演示一下如何创建一个springCloud config

Config-Server 服务端构建，

第一步：映入maven 依赖包

（spring，,springcloud，eureka ，,hystrix,，feig 等依赖包自己选择需求…）

 <!--config server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>

第二步：编写配置文件

spring.application.name=config-server
server.port=8888
spring.cloud.config.server.git.uri=https://gitee.com/wx_c3b99916a9/demo01.git
#gitee 或者giehub 克隆地址  
spring.cloud.config.server.git.searchPaths=respo
spring.cloud.config.label=master 
spring.cloud.config.server.git.username=your username
spring.cloud.config.server.git.password=your password
    //spring.cloud.config.server.git.username=your username
//spring.cloud.config.server.git.password=your password   依据你的仓库定义是否需要用户信息

第三步：编写启动类

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableConfigServer #开启config 服务端 
public class ConfigServer {
    public static void main(String[] args) {
   SpringApplication.run(ConfigServer.class,args);

    }
}

第三步：启动模块; 输入 http://localhost:8888/foo/dev 出现如下图，显示config 信息，即可

Config-Client 客户端构建，

第一步：映入maven 依赖包

（spring，,springcloud，eureka ，,hystrix,，feig 等依赖包自己选择需求…）

<!--config-client-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

第二步：编写配置文件

# 系统级别的配置
spring:
  cloud:
    config:
      uri: http://localhost:8888
      label: master
      name: config-client # 需要从git上读取的资源名称，不要后缀
      profile: dev

第三步：编写客户端调用服务端信息的方法

@RestController
public class ConfigClientController {

    @Value("${spring.application.name}")
    private String application;

    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaServer;

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

    @RequestMapping("/config")
    public String getConfig(){
        return "===============" + application + eurekaServer + port + "==========";
    }
}