SpringCloud学记笔记（一）

最新推荐文章于 2024-09-10 13:49:09 发布
最新推荐文章于 2024-09-10 13:49:09 发布
阅读量327 收藏 1
点赞数 1
分类专栏： java-微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it147/article/details/104546534
版权

首先说一下springcloud的几个官网吧

  • 中文网 https://www.springcloud.cc/spring-cloud-dalston.html
  • 中国社区：http://springcloud.cn/

接下来便是在学习springcloud的过程中记录的知识点

1：Eureka Server的首页在正常访问后过一点时间在去访问界面 或出现如下红色字体

EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.

这个出现的原因是SpringCloud Eureka的自我保护机制
简介SpringCloud的自我保护机制

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

2：Eureka修改服务名称

instance:
    instance-id: consumer

在这里插入图片描述
3：Eureka比zookeeper强的地方

作为服务注册中心，Eureka比Zookeeper好在哪里

著名的CAP理论指出，一个分布式系统不可能同时满足C(一致性)、A(可用性)和P(分区容错性)。由于分区容错性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还在，就能保证注册服务可用(保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。除此之外，
Eureka还有一种自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，
此时会出现以下几种情况：

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

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

4：为Eureka Server添加用户认证
这一块大概是因为版本的问题吧，差一点整自闭。不管是跟着视频做，还是看课本就是不行。后来百度了一下 终于搞了出来。
先说一下此处用的版本是

  • springboot2.1.7
  • springcloud：Greenwich

步骤：

  • 首先在pom文件中添加maven依赖
		<!--springboot的安全策略依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
  • 在properties配置文件添加配置,设置账户密码
#新版本开启权限
spring.security.user.name=user
spring.security.user.password=123

倘若在此不设置账户密码的话，则账户默认为user，密码为随机产生，在项目启动的时候随即打出。

  • 在yml文件中添加如下配置
eureka:
  client:
    service-url:
      defaultZone: http://username:password@localhost:端口号/eureka  #设置与eureka service的交互地址
  • 新版本的springcloud说是因为 Spring Security 默认开启了所有 CSRF 攻击防御，需要禁用 /eureka 的防御。因此需要重写WebSecurityConfigurerAdapter的configure方法，
    详细代码：
package eureka.springcloud.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception{
        // 开启认证
        http.authorizeRequests().anyRequest().authenticated().and().httpBasic();
        http.csrf().ignoringAntMatchers("/eureka/**");
        super.configure(http);
    }
}

至此，eureka服务的配置完成，输入eureka地址登陆即可看到监控页面。

接下来若想要将为服务注册进入Eureka Server，

  • yml配置文件作如下配置
eureka:
  client:
    service-url:
      defaultZone: http://username:password@localhost:端口号/eureka
    instance: 
      prefer-ip-address: true
  • pom.xml添加依赖
		<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

启动项目便可将服务注册进eureka中。

需要注意的是：

  • eureka.instance.prefer-ip-address = true表示将自己的ip注册进Eureka Server中。如不配置或将其设置成false，则表示注册微服务所在操作系统的hostname到Eureka Server中。

  • 在springcloud Edgware之前，想要将服务注册进Eureka Server或其他服务发现组件，必须在启动类上添加@EnableEurekaClient或@EnableDiscoveryClient注解

  • 在更高的版本中，只需要添加相应的依赖便可自动注册。

  • 若不想将服务注册进Eureka中，则只需设置spring.cloud.service-registry.auto-registration.enabled=false或@EnableDiscoveryClient(auto-Register = false)即可

5：使用Ribbon实现客户端侧负载均衡
Ribbon能够自动的帮助服务消费者去请求。默认为我们提供了很多负载均衡地算法，例如轮询，随机等，我们也可以为Ribbon自定义负载均衡算法（不会。。。待学习。。。）

为服务消费者整合Ribbon

  • 为项目引入Ribbon的依赖。
		<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stater-netflix-ribbon</artifactId>
        </dependency>

如果项目中已经引入了如下依赖，则无需再次引入Ribbon的依赖，因为下面的包含Ribbon。

  	   <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
       </dependency>
  • 为RestTemplate添加@LoadBalanced注解，就可为RestTemplate整合Ribbon，使其具有负载均衡的能力。
   @Bean
   @LoadBalanced
   public RestTemplate restTemplate(){
       return new RestTemplate();
   }

修改Controller代码,具体如下

@RestController
public class UserController {

    /**
     * 提供一个用于访问rest接口的模板对象
     */
    @Autowired
    private RestTemplate restTemplate;
    
    /*首先是将请求的地址改成生产者为服务的虚拟主机名。当Ribbon和Eureka配合使用时，会自动地将虚拟主机名映射成		为服务的网络地址*/
    private static final String url = "http://PROVIDER-USER";

    @GetMapping("/persion")
    public Persion[] getConsumer(){
        /**
         * 通过访问 rest 获取到json对象 然后转换成user对象
         */
        System.out.println("来到了ribbon。。。。。。。。。。");
        //注意： 返回的是List集合对象，用数组接收   
        Persion[] persion =  restTemplate.getForObject(url + "/persion/", Persion[].class);
        System.out.println("====================>:"+persion);
        return persion;
    }
}

负载均衡基本配置完成。在此说一个碰见过的坑，超级坑，搞了半天。
情况是，之前我使用RestTemplate请求生产者，返回值是单个对象，在反序列化的时候报错，后来查明原因是反序列化的时候，对象需要有无参构造。
这次是返回结果是List集合。消费者在接收数据的时候用的也是List集合来接收的。结果在反序列化的时候报错反序列化失败。json依赖引入了，无参构造也有，但就是不成。后来查资料说是在接收的时候要用到数组。便改成了上面的接收方式。成了。。。。。
无语了，改了半天。但是具体的使用原因还不明白。如果有哪位知道的可以留言。

6：上面已经配置了Ribbon实现了负载均衡。下面大概的说一下Riddon的负载均衡算法。
首先时Ribbon默认使用轮询算法来实现负载均衡。即按顺序依次使用服务的提供者。
若想要使用其他的算法，则只需要在配置类中将其注册即可
例如下面使用的随机算法

	@Bean
    public IRule myRule(){
        return new RandomRule();
    }

还有RetryRule算法。这个算法是先按照轮询的算法的策略获取服务，实现负载均衡。如果获取服务失败则会在指定时间内进行重试，获取可用服务。即若服务有挂掉的，则在一定时间内尝试从新连接这个服务。若连接不上则忽略这个服务，剩下的服务按照轮询算法实施。

负载均衡算法
在这里插入图片描述
7:之前记录了Ribbon整合Eureka及Ribbon的负载均衡算法，下面就该说一下自定义的负载均衡算法了

  • 首先创建一个配置类，用来编写负载均衡算法
@Configuration
public class MySelfRule {

    @Bean
    public IRule ribbonRule(){
        return new RandomRule();
    }
}
//随机算法

在此需要注意：该类不应该在主应用程序上下文中的@CompontScan所扫描的包中。
因为@SpringBootApplication注解包含@ComponentScan注解

  • 在启动类上添加@RibbonClient注解
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "RIBBON-ORDER",configuration = MySelfRule.class)
public class RibbonApplication {

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


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

@RibbonClient: name属性客户端的服务名称，@configuration则为自定义配置类

接下来说一个自定义配置类的例子
将轮询算法改成 每个生产者访问5次后，在去访问下一个生产者。

  • 这个是随机算法的git地址
    解析源码：https://github.com/Netflix/ribbon/blob/master/ribbon-loadbalancer/src/main/java/com/netflix/loadbalancer/RandomRule.java

  • 通过解析源码实现自定义需求的轮询算法

public class MySelfRule_LML extends AbstractLoadBalancerRule {


    private int total = 0;
    private int index = 0;

    public Server choose(ILoadBalancer lb, Object key) {

        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();
            List<Server> allList = lb.getAllServers();

            int serverCount = allList.size();
            if (serverCount == 0) {
                return null;
            }
			/********************************************************************/
            if (total < 5) {
                System.out.println("******************");
                server = upList.get(index);
                total++;
            } else {
                total = 0;
                index++;
            }
                if (index >= upList.size()) {
                    index = 0;
                }
                根据需求改造的代码
                /****************************************************************/

                if (server == null) {
                    Thread.yield();
                    continue;
                }

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

                server = null;
                Thread.yield();
            }
            return server;
        }

    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {

    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(),key);
    }
}
  • 定义一个配置类将自定义负载均衡算法添加进IOC
@Configuration
public class MyRule {
    @Bean
    public IRule mySelfRule(){
            return new MySelfRule_LML();
    }
}
  • 最后在启动类上添加@RibbonClient注解

有一点比较迷，就是网上包括书本上说的 自定义配置类不应该在主应用程序上下文中的@CompontScan所扫描的包中。因为@SpringBootApplication注解包含@ComponentScan注解，否则自定义配置类就会被所有的Ribbon客户端共享。这个地方不太明白。
所以上面我写的自定义负载均衡算法都写在了启动类包下。如果有明白这句话的可以给我留言，教教我

8：使用Feign实现负载均衡
  在Ribbon详解中，我们使用Ribbon客户端负载均衡实现微服务之间的调用，Ribbon本质上就是一个RestTemplate对象。使用RestTemplate时，除了要编写所调用微服务的URL，还需要包装所调用微服务所返回的结果。为了克服这些不足，Spring Cloud提供了声明式调用组件—Feign。
  Feign是一个基于接口的编程方式，开发者只需要声明接口和配置注解，在调度接口方法时，Spring Cloud根据配置来调度对应的REST风格的请求，从其他微服务系统中获取数据。

  • 首先第一步肯定是引入坐标
		 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
  • yml配置文件
server:
  port: 6900

spring:
  application:
    name: ribbon-order

eureka:
  instance:
    prefer-ip-address: true
    instance-id: ribbon  #更改服务在eureka中的名称

-properties配置文件

#设置Eureka Server交互的地址，查询和注册服务都需要依赖这个地址，与注册中心地址一致
eureka.client.service-url.defaultZone=http://user:123@eureka:10000/eureka
#集群使用  暂时注释,http://eureka-A:11000/eureka,http://eureka-B:12000/eureka
  • 创建一个Feign接口，并添加@FeignClient注解
    自我解释此接口就是用来对应Eureka中的生产者中的接口
@FeignClient(name = "PROVIDER-USER")
@Service
public interface Feign {

    @RequestMapping("/persion")
    public List<Persion> getPersion();


    @RequestMapping("/findById/{id}")
    @ResponseBody
    public Persion findById(@PathVariable("id") int id);
}

@FeignClient注解中的PROVIDER-USER是任意一个客户端的名称，用于创建负载均衡器。在此因为使用了Eureka，所以将其解析为Eureka Server服务注册表中的服务。

  • 修改controller代码，将其之前的RestTemplate换成接口调用
@RestController
public class UserController {


    @Autowired
    private Feign feign;

    @GetMapping("/persion")
    public List<Persion> getPersion(){
        List<Persion> persion = this.feign.getPersion();
        System.out.println("feign------------查询所有");
        return persion;
    }

    @RequestMapping("/findById/{id}")
    @ResponseBody
    public Persion findById(@PathVariable("id") int id){
        Persion persion = this.feign.findById(id);
        System.out.println("feign------------根据ID："+persion);
        return persion;
    }
}
  • 修改启动类，添加@EnableFeignClients注解

这样，消费者微服务就可以用Feign去调用生产者微服务的API了

还叫康师傅
关注
专栏目录
Spring cloud 笔记
fan990719的博客
04-01 489
springcloud学习笔记
LINUX学记笔记16
qq_39764817的博客
03-20 664
使用Bind提供域名解析服务 DNS域名解析服务 相较于由数字构成的IP地址，域名更容易被理解和记忆，所以我们通常更习惯通过域名的方式来访问网络中的资源。但是，网络中的计算机之间只能基于IP地址来相互识别对方的身份，而且要想在互联网中传输数据，也必须基于外网的IP地址来完成。 为了降低用户访问网络资源的门槛，DNS（Domain Name System，域名系统）技术应运而生。这是一项用于管理和解...
编程不良人的SpringCloud笔记和资料，全套
06-21
编程不良人的SpringCloud笔记和资料，全套 编程不良人的SpringCloud笔记和资料，全套 编程不良人的SpringCloud笔记和资料，全套
springcloud-笔记
Y_hahaha的博客
03-17 540
webservice 第一代应用服务整合（XML+SOAP） 优点：是可跨平台的技术 缺点：处理速度慢、如果要使用远程接口调用则要生成很多的工具类代码 SOA（服务总线的形式调用） PRC技术-远程过程调用（比较流行的有阿里的double及REST-因为json的广泛使用） 使用rest实现RPC可以更快 REST（springcloud核心架构） 我简单的理解为http（理解不够深，如果错误后续修改） ...
Spring Cloud 学习笔记（1 3）_spring cloud笔记 巨轮
最新发布
2401_86637436的博客
09-10 2089
Consul官网Consul下载地址linkConsul是一个服务网格解决方案，它提供了一个功能齐全的控制平面，具有服务发现、配置和分段功能。这些特性中的每一个都可以根据需要单独使用，也可以一起用于构建全服务网格。Consul需要一个数据平面，并支持代理和本机集成模型。Consul船与一个简单的内置代理，使一切工作的开箱即用，但也支持第三方代理集成，如Envoy。consul英 [ˈkɒnsl] 美 [ˈkɑːnsl]n. 领事。
Spring Cloud 笔记
roods的博客
09-10 299
spring cloud
spring cloud笔记
p的博客
06-03 525
Springcloud 1.    怎么实现负载均衡 nginx,lvs,F5Springcloud 中用ribbon负载均衡 2.    什么是springcloud 一套完美微服务解决框架 rpc远程调用3.    Springcloud注册中心eureka rest作用:调用接口4.    Ribbon\feign负载均衡5.    Fegin客户端调用------接口方式调用6.    接...
《学记》读书笔记_心得感悟五篇范文.doc
09-14
《学记》读书笔记_心得感悟五篇范文.doc
《学记》读书笔记_心得感悟五篇范文精选.doc
10-11
《学记》读书笔记_心得感悟五篇范文精选.doc
Redis学记笔记 —— （13）阻塞
weixin_42510648的博客
12-03 759
Redis是典型的单线程架构，所有的读写操作都是在一条主线程中完成的。当Redis用于高并发场景时，这条线程就变成了它的生命线。如果出现阻塞，哪怕是很短时间，对于我们的应用来说都是噩梦。
LINUX学记笔记13
qq_39764817的博客
03-20 361
使用Apache服务部署静态网站 网站服务程序 我们平时访问的网站服务就是Web网络服务，一般是指允许用户通过浏览器访问到互联网中各种资源的服务。Web网络服务是一种被动访问的服务程序，即只有接收到互联网中其他主机发出的请求后才会响应，最终用于提供服务程序的Web服务器会通过HTTP（超文本传输协议）或HTTPS（安全超文本传输协议）把请求的内容传送给用户。 目前能够提供Web网络服务的程序有II...
Spring Cloud笔记
asdXT的博客
08-30 443
Spring Cloud 是一个基于 SpringBoot 实现的云原生应用开发工具，它为基于JVM的云原生应用开发中涉及的配置管理、服务发现、熔断器、智能路由、微代理、控制总线、分布式会话和集群状态管理等操作提供了一种简单的开发方式。 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。 单体架构 ...
SpringCloud进阶篇
m0_71093010的博客
05-25 388
1.Nacos与Eureka的区别 Nacos的服务实例分为两种l类型： 临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型。 非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。 配置一个服务实例为永久实例： spring: cloud: nacos: discovery: ephemeral: false # 设置为非临时实例 Nacos和Eureka整体结构类似，服务注册、服务拉取、心跳等待，但是也存在一些差
springcloud笔记
眼泪落在琴弦的博客
07-10 188
##springCloud和springCloudAlibaba(微服) 版本:springCloud决定springboot版本 本次为springcloud H版本和springboot2.2.2 ##技术栈: 注册中心:Nacos或consul 服务调用1:LoabBalancer 服务调用2:OpenFeign 服务降级:sentinel 服务网关:gateway 服务配置:Nacos 服务总线:Nacos 1.微服务是什么 微服务化核心是将传统的一站式应用,根据业务拆成一个个服务,彻底去耦合,每
SpringCloud笔记
weixin_49702090的博客
11-29 239
SpringCloud 框架 一、分布式概念 1、分布式的优点 处理高并发问题： ​ 面对越来越大的业务量，一台机器的性能已经无法满足。我们需要多台机器才能满足高并发的需求。因此我 们需要垂直或水平拆分业务系统，让它变成一个分布式的架构。 加强系统可用性： ​ 为了我们的系统不会因为一台机器出故障二导致整个系统不可用。所以需要利用分布式来消除单点故障，提 高系统可用性。 把模块拆分，使用接口通信，降低程序的耦合度 把项目拆分成若干个子项目，不同的团队负责不同的子项目 增加项目时只需增加一
《礼记·学记》：教学相长与一词多义探索
《学记》作为其中的一部分，对后世的教育理论产生了深远影响，直至今日仍然有很高的参考价值。 《礼记》也被称为《小戴礼记》，与《周礼》《仪礼》并称为"三礼"，主要涉及礼制、礼仪的解释。文中提到的"读准字音...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值