SpringCloud

最新推荐文章于 2023-01-30 23:01:17 发布

y_大白菜

最新推荐文章于 2023-01-30 23:01:17 发布

阅读量263

点赞数

文章标签： java spring

本文链接：https://blog.csdn.net/qq_44991374/article/details/115858830

版权

SpringCloud

大佬链接

1. 微服务

1.1. 微服务和SOA的对比

SOA就是面向服务的架构,是一种设计软件的原则,在SOA中,所有的组件都是独立自主的,并能为其他的组件提供服务.大体上,SOA架构与微服务非常相似
微服务是细粒度的SOA组件.换句话说,某单个SOA组件还可以被拆分多个微服务,而这些微服务通过分工协作,可以提供与原SOA组件同级别的功能.
微服务更多关注的更窄的轻量级服务,微服务推崇执行的标准(HTTP)是人们广泛了解并使用的.我们可以通过选择合适的编程语言或工具来构建某个组件,除了技术栈和微服务模块之外,在SOA与微服务之间还有一个更大的区别就是: 领域模型.
在一个基于微服务的软件中,每个微服务应该在本地存储自身管理的数据,并将领域模型分别隔离到单个服务中,而在SOA架构中,数据往往集中存储在某单个大型的数据库中.
微服务更强调单一职责.

SOA	微服务
系统性的改变需要修改整体	系统性改变只需要新建一个微服务
专注于业务功能的重用	更注重于"上下文边界"的概念
容器(Docker)的使用不方便	容器在微服务效果比较好
共享数据存储	每个微服务都有一个独立的数据存储

1.2. 微服务的优缺点

优点

简单灵活,独立部署
测试相对容易
可伸缩性较强,可靠性较强
可以跨语言
可以协同开发,专注高效
开发与平台无关,方便系统的迭代
松耦合,高内聚,易扩展

缺点

开发成本高,运维成本高,部署成本高
接口兼容版本问题
分布式本身的复杂性
分布式事务问题(三选二,可能导致数据不一致性)

1.3. 微服务的设计原则

开发模型

瀑布模型
项目经理和产品经理讨论,功能是否可以实现,用什么技术等
开发工程师根据需求文档开发
测试
运维
客户
敏捷开发模型
把项目经理,产品经理,开发,测试,运维,集中到一起,根据甲方提出的需求,然后一起讨论,提出解决方案

1.3.1. AKF的拆分原则

业界对于可扩展的系统架构设计有一个默认理念: 通过增加服务器可以解决容量和可用性问题\

AKF设计原则
从三个维度

X轴: 水平复制.一个单体系统不行,此时可以考虑运行多个单体实例,形成集群+负载均衡
Y轴:基于服务功能进行划分.基于不同的业务拆分。
Z轴:基于类似的数据分区,比如某个地区数据量较大,给该地区增加一个数据分区

1.3.2. 前后端分离原则

前端和后端都需要根据提供的接口文档来开发

1.3.3. 无状态服务原则

如果一个数据需要被多个服务共享，才能完成一笔交易，那么这个数据被称为状态。进而依赖这个“状态”数据的服务被称为有状态服务，反之称为无状态服务。

场景说明：例如我们以前在本地内存中建立的数据缓存、Session 缓存，到
现在的微服务架构中就应该把这些数据迁移到分布式缓存中存储，让业务服务变
成一个无状态的计算节点。迁移后，就可以做到按需动态伸缩，微服务应用在运
行时动态增删节点，就不再需要考虑缓存数据如何同步的问题。

最后简单来说，就是：把数据模块单独提取，只考虑业务拓展，不考虑数据

1.3.4. Rest通信风格

它是基于"无状态通信原则"

好处

无状态的Http协议,扩展能力强.比如网络进行数据传输需要加密,–>https
Json报文序列化,轻量简单,成本较低
与平台无关,各种编程语言都支持Restful API
Restful 风格返回的数据必须是Json数据

在这里插入图片描述

1.4. 微服务架构需要的功能以及适用场景

1 需要把整个系统根据业务拆分成几个子系统
2 每个子系统都可以部署多个应用,多个应用之间使用负载均衡
3 需要一个服务注册中心,所有的服务都在注册中心进行注册,多个应用之间的负载均衡他也是通过注册中心注册的服务来实现的(负载均衡策略)
4 所有的客户端都通过同一个网关地址访问后台的服务,通过路由配置网关来判断一个url请求应该有哪一个服务来处理,请求就转发到哪个服务上(负载均衡)
5 服务之间有时候也需要相互访问
6 需要一个熔断器(用来断路由),即使处理服务调用时的超时和错误,防止由于一个服务的问题导致整体系统的瘫痪
7 需要一个监控器, 用来监控每个服务调用花费的时间等.
8 主流的微服务架构有Dubbo,SpringCloud,thrift,hessian等

1.5. Dubbo+Zookeeper/SpringCloud对比

虽然Dubbo+Zookeeper和SpringCloud没有谁优谁劣之分,但是SpringCloud背靠Spring全家桶,所以用的相对较多

Dubbo

国内的技术,支持Restful风格的API,调用远程API就像调用本地的一样
Restful是基于HTTP的各种动作来定义各种资源的一种处理风格
get请求就是想获取资源
post请求就是想添加资源
put请求就是想更新资源
delete请求就是想删除资源

对比

对比项	SpringCloud	Dubbo
服务注册中心	Eureka	Zookeeper
服务调用方式	Ｒｅｓｔ　ＡＰＩ	ＲＰＣ
服务网关	Ｚｕｕｌ	Ｄｕｂｂｏ　Ｐｒｏｘｙ
服务熔断	Ｈｙｓｔｒｉｘ	Ｓｅｎｔｉｎｅｌ
分布式配置	ｃｏｎｆｉｇ	Ｎａｃｏｓ
消息总线	Ｂｕｓ

总结

dubbo由于基于二进制的传输,占用带宽比较小
SpringCloud采用Http协议传输,带宽较多同时使用Http协议一般会使用Json格式,销毁也会很大

Dubbo开发难度大,原因是Dubbo使用的jar包依赖问题很多没有
SpringCloud的接口协议比较自由,需要有强有力的行政措施来约束或限制接口无序升级

Dubbo的注册中心采用Zookeeper,Redis等,SpringCloud一般使用自己的注册中心Eureka

3. SpringCloud概述

3.1. 版本介绍

版本介绍
springCloud的版本为什么采用单词定义而不是数字呢?

之所以这样设计,原因是为了更好的管理每个SpringCloud的子项目,避免总版本号与子版本号混淆.

定义规则

采用伦敦的地铁站站名来作为SpringCloud版本号命名的
根据首字母进行排序,字母顺序越靠后的版本越新

发布计划

版本号	版本	说明
Build-XXX	开发板	开发团队内部使用
M	里程碑版	MilStone M1 表示第一个里程碑版本,同时还会添加PRC(预览版)
RC	候选发布版	Release Candidate,正式发布版的前一个观察期,不再添加新功能
SR	正式发布版	SR1表示的是第一个正式版本
GA	稳定版本	经过全面测试并且可以对外发行

子项目版本说明
比如:Spring Cloud Azure 2.2.0

第一个2 表示主版本好当功能有较大更新或整体架构有变化
第二个2 只是局部变化
0 一般是Bug的修复或小的变更
RELEASE 希腊字母版本号用来标注当前版本的软件处于哪个开发阶段

希腊字母版本说明

Base: 设计阶段,只有设计没有具体实现
Alpha: 软件的初级版本
Bate: 它相对于Alpha版本有较大的改进,消除许多bug
Gamma: 小对于Bate版本继续升级,基本修复了所有的bug,成为正式发布版的候选版
RELEASE: 该版本表示最终版本

3.2. 概述

SpringCloud是基于SpringBoot的一整套解决微服务

3.3. 架构

在这里插入图片描述
流程

请求统一通过 API 网关（Zuul）来访问内部服务。
网关接收到请求后，从注册中心（Eureka）获取可用服务。
由 Ribbon 进行均衡负载后，分发到后端具体实例。
微服务之间通过 Feign 进行通信处理业务。
Hystrix 负责处理服务超时熔断。
Turbine 监控服务间的调用和熔断相关指标。

3.4. 特点

约定优于配置
开箱即用,快速启动
适用于各种环境
轻量级的组件
组件丰富,功能齐全

4. 服务的注册与发现 Eureka

创建父工程时,在pom文件指定springboot和springcloud的版本,并对springcloud版本进行控制,使用springboot内置的tomcat插件
Eureka的搭建首先需要在pom文件中引入eureka-server的依赖,在配置文件application.yml文件中指定该服务的端口号,应用名称,主机名,和路由,在单击环境下需要关闭自己作为客户端注册到注册中心和拉取服务的功能

开发步骤

创建一个SpringCloud工作空间,在这个工作空间创建一个父工程parent
以下的工程都依赖于父工程parent
创建一个服务注册中心Eureka-server
依赖

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

使用@EnableEurekaServer注解打在启动类上,标记该服务为注册中心
配置eureka-server

eureka是一个高可用的组件,它没有后端缓存,每一个服务注册之后需要向注册中心发送心跳(renew),默认情况下,eureka-server它也是一个eureka-client,

在单节点下,注册中心不需要往自己内部注册和拉取服务,所以需要关闭
在集群下就需要了,默认是开启的

server:
  port: 8000
#应用名称
spring:
  application:
    name: Eureka-server
eureka:
  instance:
    #eureka-server的主机名
    hostname: localhost
  client:
    #false  关闭自己往自己内部注册
    register-with-eureka: false
    #false  关闭自己拉取自己服务
    fetch-registry: false
    #注册中心的路由
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

5. 创建服务提供者

首先引入eureka-client客户端和springboot的web启动器,如果连接数据库,还需要mysql的驱动包,如果整合了mybatis还需要引入mybatis和mybatis整合包,如果使用druid连接池,还需要使用druid的依赖
然后在配置文件中指定该服务的端口号,注册到eureka的应用名称,主机名和eureka的路由,配置mysql连接的信息

依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

在启动类打上注解@EnableEurekaClient
配置文件

server:
  port: 8001
spring:
  application:
    name: provider
#指定使用的注册中心服务地址
eureka:
  client:
    service-url: 
      defaultZone: http://localhost:8000/eureka/

启动eureka和provider,访问注册中心localhost:8088

服务提供者已经注册到eureka

在eureka暴露ip
eureka
instance:
instance-id: ${spring.cloud.client.ip.address}:$ {server.port}
prefer-ip-address: true

负载均衡

在这里即把该工程作为负载均衡,也作为服务消费者

在springCloud中关于服务调用有两种方式
第一种方式: ribbon+RestTemplate
第二种方式:采用feugn
服务与服务之间的通信采用http restful

Ribbon

ribbon是一个负载均衡的客户端,能够控制http和tcp的一些行为

依赖

        <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-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

设置服务提供者允许并行允许,然后提供者每启动一次修改一次端口号模拟集群,并且为了区分返回结果,每次启动前都修改一下controller的返回值
配置文件

server:
  port: 8002
spring:
  application:
    name: ribbon
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8000/eureka/

service.java

@Service
public class HelloService {

    @Autowired
    private RestTemplate restTemplate;//会报错


    public String test01(String name) {
        //服务远程调用,遵守http协议
        //provider主机名,这里的主机名相对于ip+端口号
        String template = restTemplate.getForObject("http://provider/hello.do?name="+name, String.class);
        System.out.println(template);
        return template;
    }
}

restTemplate会报错,说明它还没有注入到spring容器中,在启动类里

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient//把自己注册到注册中心
public class RibbonApplication {
    public static void main( String[] args ) {
        SpringApplication.run(RibbonApplication.class);
    }

    @Bean
    @LoadBalanced//负载均衡
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

controller.java

@RestController
public class RibbonController {

    @Resource
    private HelloService helloService;
    @RequestMapping("/hello.do")
    public String test01(String name) {
        return helloService.test01(name);
    }
}

测试
localhost:8002/hello.do

此时的项目结构
一个注册中心Eureka,端口号为8000
一个服务提供者Provider两个实例,端口号分别为8001,8099
一个服务消费者Consumer,采用负载均衡,通过RestTemplate调用provider的接口,因为采用了负载均衡,所以会轮流调用Provider的两个实例8001,8099的接口

负载均衡开启随机策略
在启动类把@LoadBalanced注释掉,添加

    //负载均衡开启随机策略
    @Bean
    public RandomRule getRandomRule() {
        return new RandomRule();
    }

Feign

feign是对ribbon的封装,使得写客户端非常容易.只需要创建一个接口添加一个注解即可,具有可插拔式的注解特性.
Feign默认集成了Ribbon,并且和Eureka进行了整合,默认实现了负载均衡效果.
简言之,Feign采用的是基于接口的注解;整合了Ribbon,具有负载均衡的功能;
整合了Hystrix,具有熔断的能力

首先需要引入依赖eurea-client客户端,web启动器,feign组件
之后在配置文件中指定端口号,应用名称,eureka-server的路由
在启动类中使用注解@EnableFeignClients开启远程调用功能和负载均衡功能
在service接口上打上@FeignClient注解,其属性为服务提供者的应用名称(它不是主机名),最后在方法上使用@Requestmapping映射请求资源,方法的返回值需要和请求资源映射的方法的返回值一致

开发步骤

创建feign-server工程

-依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

配置文件

server:
  port: 8003
spring:
  application:
    name: feign
eureka:
  client:
    service-url: 
      defualtZone: http://localhost:8000/eureka/

主启动类上

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
@EnableFeignClients //开启Feign,实现负载均衡
public class FeignApplication {

service.java接口

/**
 * @author yxk
 * @version 1.0
 * Date 2021/4/20 11:40
 * FeignClient("provider")注解的provider是在服务提供者的配置文件配置的应用名称
 */
@FeignClient("provider")
public interface FeignService {


    /**
     * 根据@RequestMapping()的value值调用服务提供者的具体接口
     * @author yxk
     * @param name
     * @return java.lang.String
     * Date 2021/4/20 11:44
     */
    @RequestMapping("/hello.do")
    String feignTest01(@RequestParam("name") String name) ;
}

controller.java

@RestController
public class FeignController {

    @Autowired
    private FeignService feignService;
    @RequestMapping("/hello.do")
    public String test01(@RequestParam(name = "name")String name) {
        return feignService.feignTest01(name);
    }
}

测试
浏览器多次访问http://localhost:8003/hello.do?name=小米 (url自定义),查看是否实现了负载均衡

Hystrix(断路由)

是什么是雪崩效应?

在微服务架构中,通常会根据业务拆分成多个服务,服务与服务之间可以相互调用,在SpringCloud中可以使用Ribbon+RestTemplate或Feing来实现服务之间的调用.为了保证服务的高可用,单个服务通常会进行集群部署,由于网络或自身原因,服务并不能保证100%可用,如果单个服务出现问题,那么这个服务就会出现线程阻塞,此时如果大量的请求过来,Servlet容器的线程会在短时间内被迅速消耗完毕,导致服务瘫痪,服务与服务之间的依赖性,故障会传播,会对整个微服务系统灾难性的严重后果,这就是服务故障的雪崩效应.

Netflix开源了一个组件Hystrix，实现了断路器的模式，SpringCloud对这一组件进行了整合.在较低层的服务如果出现故障，会导致连锁故障，当对特定的服务不可用达到一个阈值(Hystrix是5秒20次)，Hystrix的断路器会被自动打开，会把不可用服务自动断开.路由断开后，会调用一个方法fallback,由fallback方法返回一个指定的固定值。

开发步骤

1 在消费者里引入Hystrix依赖,比如前面的ribbon-server

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

2 在主启动类添加注解@EnableHystrix,开启断路器模式
3 改造service.java

    @HystrixCommand(fallbackMethod = "errorMethod")
    public String test01(String name) {
        //服务远程调用,遵守http协议
        String template = restTemplate.getForObject("http://provider/hello.do?name="+name, String.class);
        System.out.println(template);
        return template;
    }

    public String errorMethod(String name) {
        return "Hello"+name+",此服务正在维护,请稍后再试";
    }

测试
在服务提供者的提供一个错误,然后重启,浏览器访问
ribbon的服务http://localhost:8002/hello.do?name=小米

在Feign中使用断路由功能

1 在Feign服务的配置文件开启断路由功能

#开启断路由功能
feign:
  hystrix:
    enable: true

2 改造FeignService.java接口
只需要在注解@FeignClient使用fallback属性指定一个类

@FeignClient(value = "provider",fallback = FeignServerImpl.class)
public interface FeignService {

3 创建FeignService接口的实现类,重写方法,该重写方法是熔断方法,接口的原来方法是调用远程服务的方法

@Service
public class FeignServerImpl implements FeignService{
    @Override
    public String feignTest01(String name) {
        return "hello ,error"+name;
    }

注意:调用者和被调用者的返回值最好一样(pojo最好放到公共的工程上)
设置主机名和注册到注册中心的应用名称最好不一致
连接数据库时,在url上的数据库后面写上?useSSL=true&serverTimezone=UTC&characterEncoding=utf-8&autoReconnect=true

Zuul(路由网关)

在微服务体系结构中，一般需要一些服务治理组件:服务注册和发现、服务消费、负载均衡、断路器、智能路由、配置管理等，由这些组件协同工作，形成一个小型服务系统.
在微服务系统中,一种常见的负载均衡方式是: 客户端首先经过负载均衡器,再到达服务网关,然后才会到达具体的服务应用中.
服务一般统一注册到注册中心集群上,服务的所有配置文件由配置服务管理器进行统一管理,配置的服务文件一般放在Git仓库中,方便开发人员随时修改配置

Zuul的主要作用是转发和过滤
路由功能:
/api/user ===>转发到user服务中
/api/role ===>转发到role服务中
路由和服务肯定产生绑定,一一映射关系

Zuul默认和Ribbo整合,自带负载均衡效果

开发步骤

创建工程zuul-server
引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix-eureka-client</artifactId>
        </dependency>

配置文件

server:
  port: 8004
spring:
  application:
    name: zuul
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8000/eureka/
#配置网关路由
zuul:
  routes:
    api-a:
      #转发
      path: /api-a/**
      #配置文件设置的应用名称
      service-id: ribbon
    api-b:
      path: /api-b/**
      service-id: feign

在启动类上

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
@EnableZuulProxy//开启路由网关功能
public class ZuulApplication {

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

路由过滤

zuul不仅能起到路由转发,还可以路由过滤
实现方式:需要自定义一个ZuulFilter过滤器

1 创建一个类,继承ZuulFilter过滤器,重写抽象方法

@Component
public class ServerFilter extends ZuulFilter {

    /**
     * 返回一个字符串,这个字符串代表过滤器的类型,在zuul中定义了四种不同生命周期的过滤器类型
     *   pre: 路由之前
     *   routing: 路由之时
     *   post: 路由之后
     *   error: 发生错误调用
     * @author yxk
     * @return java.lang.String
     * Date 2021/4/20 16:05
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 定义过滤的顺序
     * @author yxk
     * @return int
     * Date 2021/4/20 16:08
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    /**
     * 添加一些逻辑判断,是否要过滤,返回false代表不过滤
     * @author yxk
     * @return boolean
     * Date 2021/4/20 16:08
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * 添加过滤器的具体逻辑,比如说对Sql和NoSql添加一些权限控制,令牌token进行拦截
     * @author yxk
     * @return java.lang.Object
     * Date 2021/4/20 16:09
     */
    @Override
    public Object run() throws ZuulException {
        //上下文
        RequestContext context = RequestContext.getCurrentContext();
        HttpServletRequest request = context.getRequest();
        String token = request.getParameter("token");
        System.out.println("================token================的值"+token);
        if (token == null) {
            System.out.println("token的只是空,不允许");
            context.setSendZuulResponse(false);
            context.setResponseStatusCode(401);
            //让页面显示一句话
            try {
                context.getResponse().getWriter().write("token的只是空,不允许");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

关掉服务重新启动,然后测试
http://localhost:8003/hello.do?name=小米?token=111

在默认情况下，zuul会使用Eureka中集成的基本负载均衡功能，如果想使用Ribbon的负载均衡功能，就需要指定一个serviceId，此操作需要禁止Ribbon使用Eureka，在E版之后新增了负载均衡的配置。

zuul:
  routes:
    client-a:
      path: /client/**
      serviceId: client-a
ribbon:
  eureka:
    enabled: false #禁止Ribbon使用Eureka
client-a:
  ribbon:
    NIWSServerListClassName: com.netflix.loadbalancer.ConfigurationBasedServerList
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
    listOfServers: localhost:8080,localhost:8081

Config(分布式配置中心)

Http请求地址和配置信息映射:
/{application}/{profile}/{lable}
/{application}/{profile}.yml
/{application}/{profile}.properties
/{lable}/{application}/{profile}.properties
{application} 就是应用名称，对应到配置文件上来，就是配置文件的名称部分，例如我上面创建的配置文件。
{profile} 就是配置文件的版本，我们的项目有开发版本、测试环境版本、生产环境版本，对应到配置文件上来就是以 application-{profile}.yml 加以区分，例如application-dev.yml、application-sit.yml、application-prod.yml。
{label} 表示 git 分支，默认是 master 分支，如果项目是以分支做区分也是可以的，那就可以通过不同的 label 来控制访问不同的配置文件了。

在分布式系统中，由于服务数量众多，为了方便服务配置文件统一进行管理，实时更新，所以需要搭建分布式配置中心组件，在SpringCloud中，分布式配置中心使用SpringCloud Config组件来实现
它支持配置服务放在配置服务的内存中(本地)，也支持远程Git仓库
在SpringCloud Config组件中，有两种角色来实现:第一个: config server第二个 config client

在Gitee创建一个仓库
点击AEADME创建一个repository目录(结尾输入/自动生成目录),在该目录下创建config-client-dev.properties文件
创建项目config-server,引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>

配置配置中心的文件

server:
  port: 8005
spring:
  application:
    name: config

  cloud:
    config:
      server:
        git:
          #指定远程仓库地址
          uri: https://gitee.com/yang-xikun/spring-cloud-config.git
          #指定配置文件所在的目录
          search-paths: repository
      #指定配置文件所在的分支
      label: master

注意: 如果远程仓库是私有仓库,需要指定远程仓库的账号和密码

启动类

@SpringBootApplication
@EnableConfigServer
public class ConfigApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigApplication.class);
    }
}

测试
-浏览器访问http://localhost:8005/username/dev
创建config-client工程,引入依赖

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

配置config-client配置文件

server:
  port: 8006
spring:
  application:
    name: config-client
  cloud:
    config:
      label: master
      profile: dev
      uri: http://localhost:8005/

注册中心高可用(搭建集群)

创建eureka-server01和eureka-server02工程,模拟Eureka集群
修改三个eureka-server的配置文件

server:
  port: 8000
#注册到eureka的应用名称
spring:
  application:
    name: Eureka-server
eureka:
  instance:
    #eureka-server的主机名,最好写在client前面
    hostname: master
  client:
    #false  关闭自己往自己内部注册
    #register-with-eureka: false
    #false  关闭自己拉取自己服务
    #fetch-registry: false
    #注册中心的路由
    service-url:
    #有多少个eureka-server就写多少个,自己的不用写
    #slave01是主机名(注意不是注册到eureka的应用名称)
      defaultZone: http://slave01:7000/eureka/,http://slave02:7777/eureka/

server:
  port: 7000
spring:
  application:
    name: Eureka-server
eureka:
  instance:
    hostname: slave01
  client:
    service-url:
      defaultZone: http://master:8000/eureka/,http://slave02:7777/eureka/

server:
  port: 7777
spring:
  application:
    name: Eureka-server
eureka:
  instance:
    hostname: slave02
  client:
    service-url:
      defaultZone: http://master:8000/eureka/,http://slave01:7000/eureka/

在本地的C:\Windows\System32\drivers\etc下的hosts文件配置映射

127.0.0.1 slave01
127.0.0.1 slave02
127.0.0.1 master

启动三个Eureka-server,分别访问localhost:端口号

可以看到它们相互注册

遇到的问题

我springboot使用的是2.1.12.RELEASE,springCloud使用的是Finchley.RELEASE
在搭建Eureka集群时,前两个能正常启动,启动第三个启动不了,最后添加了hystrix的依赖才能正常启动
疑惑?
第一个和第二个Eureka也没有hystrix依赖,但是能启动,但是第三个为什么需要加hystrix才能启动

配置中心的高可用

1 改造eureka-server集群
(1) 在pom文件引入config-server依赖
2 改造config-server
(1) 在pom文件引入eureka-client依赖
(2)修改配置文件

eureka:
  client:
    service-url: 
      defaultZone: http://master:8000/eureka/,http://slave01:7000/eureka/,http://slave02:7777/eureka/

(3)在启动类添加@EnableEurekaClient注解

3 改造config-client
(1) 在pom文件引入eureka-client依赖
(2) 修改配置文件

server:
  port: 8006

eureka:
  client:
    service-url:
      defaultZone: http://master:8000/eureka/,http://slave01:7000/eureka/,http://slave02:7777/eureka/
spring:
  cloud:
    config:
      profile: dev
      #开启从配置中心读取文件
      discovery:
        enabled: true
        #指定配置中心的应用名称
        service-id: config
        #连接配置中心,使用的是应用名称,而不是不再使用uri
        #如果有多个config-server,通过负载均衡达到高可用
     application:
        name: config-client

y_大白菜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringCloud

文章目录SpringCloud1. 微服务1.1. 微服务和SOA的对比1.2. 微服务的优缺点2. Dubbo+Zookeeper/SpringCloud对比SpringCloud1. 微服务1.1. 微服务和SOA的对比 SOA就是面向服务的架构,是一种设计软件的原则,在SOA中,所有的组件都是独立自主的,并能为其他的组件提供服务.大体上,SOA架构与微服务非常相似微服务是细粒度的SOA组件.换句话说,某单个SOA组件还可以被拆分多个微服务,而这些微服务通过分工协作,可以提供与原SOA
复制链接

扫一扫