Spring Cloud入门

最新推荐文章于 2024-08-17 19:48:03 发布

暗影杀神

最新推荐文章于 2024-08-17 19:48:03 发布

阅读量499

点赞数

分类专栏： Spring Cloud

本文链接：https://blog.csdn.net/weixin_43714592/article/details/104238217

版权

Spring Cloud 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、为什么需要Spring Cloud?

1.Monolith（单体应用）架构

1.1.什么是单体应用？

首先请回想一下我们所开发的项目是什么样子的。通常情况下，这个服务所对应的代码由多个项目所组成，各个项目会根据自身所提供功能的不同具有一个明确的边界。在编译时，这些项目将被打包成为一个个JAR包，并最终合并在一起形成一个WAR包。接下来，我们需要将该WAR包上传到Web容器中，解压该WAR包，并重新启动服务器。在执行完这一系列操作之后，我们对服务的编译及部署就已经完成了。这种将所有的代码及功能都包含在一个WAR包中的项目组织方式被称为Monolith

1.2.缺点

①编译难，部署难，测试难
②技术选择难
③扩展难
按照Monolith组织的代码将只产生一个包含了所有功能的WAR包，因此在对服务的容量进行扩展的时候，我们只能选择重复地部署这些WAR包来扩展服务能力，而不是仅仅扩展出现系统瓶颈的组成：
在这里插入图片描述是这种扩展方式极大地浪费了资源。就以上图所展示的情况为例：在一个服务中，某个组成的负载已经达到了90%，也就是到了不得不对服务能力进行扩容的时候了。而同一服务的其它三个组成的负载还没有到其处理能力的20%。由于Monolith服务中的各个组成是打包在同一个WAR包中的，因此通过添加一个额外的服务实例虽然可以将需要扩容的组成的负载降低到了45%，但是也使得其它各组成的利用率更为低下。

2.MicroService(微服务)架构

2.1.为什么需要？

使用微服务架构就可以解决单体项目缺点。

2.2.什么是MicroService架构？

微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务间采用轻量级的通信机制互相沟通（通常是基于HTTP的RESTful API）。每个服务都围绕着具体业务进行构建，并且能够被独立地部署到生产环境、类生产环境等。另外，应尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具对其进行构建。
微服务是一种架构风格，一个大型复杂软件应用由一个或多个微服务组成。系统中的各个微服务可被技术选型,独立开发,独立部署,独立运维，各个微服务之间是松耦合的。每个微服务仅关注于完成一件任务并很好地完成该任务。在所有情况下，每个任务代表着一个小的业务能力。
在这里插入图片描述

2.3.微服务远程调用方式

常见的远程调用方式有以下几种：

RPC：Remote Produce Call远程过程调用，类似的还有RMI。自定义数据格式，基于原生TCP通信，速度快，效率高。早期的webservice，现在热门的dubbo，都是RPC的典型
Http：http其实是一种网络传输协议，基于TCP，规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用Http协议。也可以用来进行远程服务调用。缺点是消息封装臃肿。
现在热门的Rest风格，就可以通过http协议来实现

2.3.1.认识RPC

实现远程调用其他计算机的服务
- 要实现远程调用，肯定是通过网络传输数据。A程序提供服务，B程序通过网络将请求参数传递给A，A本地执行后得到结果，再将结果返回给B程序。这里需要关注的有两点：
  - 1）采用何种网络通讯协议？
    - 现在比较流行的RPC框架，都会采用TCP作为底层传输协议
  - 2）数据传输的格式怎样？
    - 两个程序进行通讯，必须约定好数据传输格式。就好比两个人聊天，要用同一种语言，否则无法沟通。所以，我们必须定义好请求和响应的格式。另外，数据在网路中传输需要进行序列化，所以还需要约定统一的序列化的方式。
像调用本地服务一样调用远程服务
- 如果仅仅是远程调用，还不算是RPC，因为RPC强调的是过程调用，调用的过程对用户而言是应该是透明的，用户不应该关心调用的细节，可以像调用本地服务一样调用远程服务。所以RPC一定要对调用的过程进行封装

2.3.2.认识Http

Http协议：超文本传输协议，是一种应用层协议。规定了网络传输的请求格式、响应格式、资源定位和操作的方式等。但是底层采用什么网络传输协议，并没有规定，不过现在都是采用TCP协议作为底层传输协议。说到这里，大家可能觉得，Http与RPC的远程调用非常像，都是按照某种规定好的数据格式进行网络通信，有请求，有响应。没错，在这点来看，两者非常相似，但是还是有一些细微差别。

RPC并没有规定数据传输格式，这个格式可以任意指定，不同的RPC协议，数据格式不一定相同。
Http中还定义了资源定位的路径，RPC中并不需要
最重要的一点：RPC需要满足像调用本地服务一样调用远程服务，也就是对调用过程在API层面进行封装。Http协议没有这样的要求，因此请求、响应等细节需要我们自己去实现。
- 优点：RPC方式更加透明，对用户更方便。Http方式更灵活，没有规定API和语言，跨语言、跨平台
- 缺点：RPC方式需要在API层面进行封装，限制了开发的语言环境。

2.3.3.如何选择

速度来看，RPC要比http更快，虽然底层都是TCP，但是http协议的信息往往比较臃肿，不过可以采用gzip压缩。
难度来看，RPC实现较为复杂，http相对比较简单
灵活性来看，http更胜一筹，因为它不关心实现细节，跨平台、跨语言。

因此，两者都有不同的使用场景：

如果对效率要求更高，并且开发过程使用统一的技术栈，那么用RPC还是不错的。 dubbo
如果需要更加灵活，跨语言、跨平台，显然http更合适 springcloud

那么我们该怎么选择呢？
微服务，更加强调的是独立、自治、灵活。而RPC方式的限制较多，因此微服务框架中，一般都会采用基于Http的Rest风格服务。

2.3.4.Http客户端工具

HttpClient、OKHttp、URLConnection、Spring的RestTemplate
Spring提供了一个RestTemplate模板工具类，对基于Http的客户端进行了封装，并且实现了对象与json的序列化和反序列化，非常方便。RestTemplate并没有限定Http的客户端类型，而是进行了抽象，目前常用的3种都有支持（HttpClient、OKHttp、URLConnection）。

2.4.优势

复杂度可控、独立部署、技术选型灵活、容错、扩展

3.使用场景

在这里插入图片描述规模大小，不是并发量，而是功能多少，功能很多，代码量大。

4.MicroService实现技术-spring解决方案

4.1.MicroService只是一种架构思想

4.2.实现技术-springboot

Java中可以使用传统ssm ssj等架构，当然更加推荐Springboot。Spring Boot是一套快速配置脚手架，可以基于Spring Boot快速开发单个微服务

4.3.服务治理框架

springcloud是一个基于Spring Boot实现的服务治理工具包。
springcloud是用来管理和协调微服务架构中多个服务.

二、Spring cloud概述

1.是什么？

Spring cloud是一个基于Spring Boot实现的服务治理工具包，用于微服务架构中管理和协调服务的。

2.组成部分

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Springcloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。
五大神兽：
服务注册发现——Netflix Eureka ：注册所有微服务的通信地址
客服端负载均衡——Netflix Ribbon\Feign ：服务之间的调用问题
断路器——Netflix Hystrix ：解决微服务故障问题，微服务的隔离
服务网关——Netflix Zuul ：微服务的统一入口
分布式配置——Spring Cloud Config ：统一管理微服务的配置文件
所有组成
共19个
Spring Cloud共集成了19个子项目，里面都包含一个或者多个第三方的组件或者框架！

Spring Cloud 工具框架

1、Spring Cloud Config 配置中心，利用git集中管理程序的配置。

2、Spring Cloud Netflix 集成众多Netflix的开源软件
3、Spring Cloud Bus 消息总线，利用分布式消息将服务和服务实例连接在一起，用于在一个集群中传播状态的变化
4、Spring Cloud for Cloud Foundry 利用Pivotal Cloudfoundry集成你的应用程序
5、Spring Cloud Cloud Foundry Service Broker 为建立管理云托管服务的服务代理提供了一个起点。
6、Spring Cloud Cluster 基于Zookeeper, Redis, Hazelcast, Consul实现的领导选举和平民状态模式的抽象和实现。
7、Spring Cloud Consul 基于Hashicorp Consul实现的服务发现和配置管理。
8、Spring Cloud Security 在Zuul代理中为OAuth2 rest客户端和认证头转发提供负载均衡
9、Spring Cloud Sleuth SpringCloud应用的分布式追踪系统，和Zipkin，HTrace，ELK兼容。
10、Spring Cloud Data Flow 一个云本地程序和操作模型，组成数据微服务在一个结构化的平台上。
11、Spring Cloud Stream 基于Redis,Rabbit,Kafka实现的消息微服务，简单声明模型用以在Spring Cloud应用中收发消息。
12、Spring Cloud Stream App Starters 基于Spring Boot为外部系统提供spring的集成
13、Spring Cloud Task 短生命周期的微服务，为SpringBooot应用简单声明添加功能和非功能特性。
14、Spring Cloud Task App Starters
15、Spring Cloud Zookeeper 服务发现和配置管理基于Apache Zookeeper。
16、Spring Cloud for Amazon Web Services 快速和亚马逊网络服务集成。
17、Spring Cloud Connectors 便于PaaS应用在各种平台上连接到后端像数据库和消息经纪服务。
18、Spring Cloud Starters （项目已经终止并且在Angel.SR2后的版本和其他项目合并）
19、Spring Cloud CLI 插件用Groovy快速的创建Spring Cloud组件应用。

当然也在不断增加。。。。

3.Spring cloud 和 dubbo的比较

1)从两个公司的背景来谈：Dubbo，是阿里巴巴服务化治理的核心框架，并被广泛应用于中国各互联网公司；Spring Cloud是大名鼎鼎的Spring家族的产品。阿里巴巴是一个商业公司，虽然也开源了很多的顶级的项目，但从整体战略上来讲，仍然是服务于自身的业务为主。Spring专注于企业级开源框架的研发，不论是在中国还是在世界上使用都非常广泛，开发出通用、开源、稳健的开源框架就是他们的主业。

2）从社区活跃度这个角度来对比，Dubbo虽然也是一个非常优秀的服务治理框架，并且在服务治理、灰度发布、流量分发这方面做的比Spring Cloud还好，除过当当网在基础上增加了rest支持外，已有两年多的时间几乎都没有任何更新了。在使用过程中出现问题，提交到github的Issue也少有回复。

相反Spring Cloud自从发展到现在，仍然在不断的高速发展，从github上提交代码的频度和发布版本的时间间隔就可以看出，现在Spring Cloud即将发布2.0版本，到了后期会更加完善和稳定。

从整个大的平台架构来讲，dubbo框架只是专注于服务之间的治理，如果我们需要使用配置中心、分布式跟踪这些内容都需要自己去集成，这样无形中使用dubbo的难度就会增加。Spring Cloud几乎考虑了服务治理的方方面面，更有Spring Boot这个大将的支持，开发起来非常的便利和简单。

4）从技术发展的角度来讲，Dubbo刚出来的那会技术理念还是非常先进，解决了各大互联网公司服务治理的问题，中国的各中小公司也从中受益不少。经过了这么多年的发展，互联网行业也是涌现了更多先进的技术和理念，Dubbo一直停滞不前，自然有些掉队，有时候我个人也会感到有点可惜，如果Dubbo一直沿着当初的那个路线发展，并且延伸到周边，今天可能又是另一番景象了。

Spring 推出Spring Boot/Cloud也是因为自身的很多原因。Spring最初推崇的轻量级框架，随着不断的发展也越来越庞大，随着集成项目越来越多，配置文件也越来越混乱，慢慢的背离最初的理念。随着这么多年的发展，微服务、分布式链路跟踪等更多新的技术理念的出现，Spring急需一款框架来改善以前的开发模式，因此才会出现Spring Boot/Cloud项目，我们现在访问Spring官网，会发现Spring Boot和Spring Cloud已经放到首页最重点突出的三个项目中的前两个，可见Spring对这两个框架的重视程度。

总结一下，dubbo曾经确实很牛逼，但是Spring Cloud是站在近些年技术发展之上进行开发，因此更具技术代表性。

三、微服务场景模拟—入门

第一步，搭建环境，以maven多模块化的方法搭建
第二步，服务提供者=提供服务
第三步，服务消费者-调用服务

1.搭建环境

父模块----springcloud01-parent
公共代码模块----product-common
服务提供者----product-service
服务消费者----product-consumers

1.1.搭建父模块

限定springboot版本-开发单个服务
限定springcloud版本-协调多个服务

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
        <springboot.version>2.0.5.RELEASE</springboot.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${springboot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2.服务提供者

第一步，导包

<dependencies>
        <!--公共代码依赖-->
        <dependency>
            <groupId>cn.itcast</groupId>
            <artifactId>product-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--springboot支持-->
        <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>
    </dependencies>

第二步，配置application.yml文件

server:
  port: 8001
spring:
  application:
    name: PRODUCT-SERVICE

第三步，写入口类

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

第四步，写服务代码

@RestController
@RequestMapping("/productService")
public class ProductServiceController {
    @GetMapping("/{id}")
    public Product getProduct(@PathVariable(name="id")Long id){
        return new Product(id,"hello spring cloud");
    }
}

第五步，测试
浏览器访问
http://localhost:8001/productService/1

3.服务消费者

第一步，导包

  <dependency>
        <groupId>cn.itcast</groupId>
        <artifactId>product-common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--springboot支持-->
    <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>

第二步，配置application.yml文件

server:
  port: 8002
spring:
  application:
    name: PRODUCT-CONSUMERS

第三步，写入口类

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

第四步，写测试代码

//配置RestTemplate 
@Configuration
public class CfgBean {
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

}
//测试
@RestController
@RequestMapping("/productConsumers")
public class ProductConsumersController {
    @Autowired
    private RestTemplate restTemplate;
    private final String URL_PREFIX="http://localhost:8001/productService/";
    @RequestMapping("/{id}")
    public Product getUser(@PathVariable("id")Long id){
        //调用远程服务 http请求
        String url = URL_PREFIX+id;
        return restTemplate.getForObject(url,Product.class );
    }
}

第五步，测试
浏览器访问
http://localhost:8002/productConsumers/1

四、Eureka注册中心-入门

1.介绍

1.1.为什么需要？

服务管理

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

1.2.常见的注册中心

由于Spring Cloud为服务治理做了一层抽象接口，所以在Spring Cloud应用中可以支持多种不同的服务注册中心，比如：Netflix Eureka、Consul、Zookeeper。在Spring Cloud服务治理抽象层的作用下，我们可以无缝地切换服务治理实现，并且不影响任何其他的服务注册、服务发现、服务调用等逻辑。

1.3.Eureka是什么？

Eureka是netflix的一个子模块，也是核心模块之一，Eureka是一个基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移。服务注册与发现对于微服务架构来说是非常重要的，有了服务发现和注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务，而不需要修改服务调用的配置文件了，功能类似于dubbo的注册中心，比如zookeeper。

1.4.原理

在这里插入图片描述 Eureka采用了C-S的设计架构。Eureka Server作为服务注册功能的服务器，它是服务注册时中心。
而系统中的其他微服务，使用eureka的客户端连接到eureka server并维持心跳连接。这样系统的维护人员就可以通过eureka server来监控系统中各个微服务是否正常运行。SpringCloud的一些其他模块就可以通过eureka server来发现系统中的其他微服务，并执行相关的逻辑。
三大角色：
Eureka server：提供服务注册和发现
Service Provider：服务提供方将自身服务注册到Eureka，从而使服务消费方能够找到。(Client)
Service Consumer：服务消费方从Eureka获取注册服务列表，从而能够消费服务。(Client)
Eureka client是一个java客户端，用于简化eureka server的交互，在应用启动后，将会向Eureka Server发送心跳。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表把这个服务节点移除。

2.Eureka注册中心搭建

2.1.导包

<!--springboot支持-->
<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>
<!--Eureka服务端支持-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

2.2.配置yml文件

server:
  port: 8003
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false #是否要注册到eureka
    fetchRegistry: false #表示是否从Eureka Server获取注册信息
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机配置

2.3.入口类

@SpringBootApplication
//标识为eureka服务端
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class);
    }
}

2.4.注意事项

事项一：自我保护引发的错误，不影响使用。
在这里插入图片描述事项二：显示IP地址
解决方案：在客户端实现

 instance:
    prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
    ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找

3.服务提供者注册到Eureka

第一步，导包

<!--eureka客户端支持 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

第二步，修改yml配置

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8003/eureka,http://localhost:8004/eureka #告诉服务提供者要把服务注册到哪儿

第三步，启动类启用Eureka

@SpringBootApplication
//启用eureka
@EnableEurekaClient
public class ProductService8001Application {
    public static void main(String[] args) {
        SpringApplication.run(ProductService8001Application.class,args);
    }
}

4.服务消费者从Eureka调用服务

第一步，导包

<!-- Eureka客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

第二步，修改yml配置文件

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8003/eureka,http://localhost:8004/eureka #告诉服务提供者要把服务注册到哪儿

第三步，入口类启用eureka客户端

@SpringBootApplication
//启用eureka
@EnableEurekaClient
public class ProductConsumers8002Application {
    public static void main(String[] args) {
        SpringApplication.run(ProductConsumers8002Application.class);
    }
}

第三步，服务调用

@RestController
@RequestMapping("/productConsumers")
public class ProductConsumersController {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DiscoveryClient discoveryClient;
    //private final String URL_PREFIX="http://localhost:8001/productService/";
    @RequestMapping("/{id}")
    public Product getUser(@PathVariable("id")Long id){
        //调用远程服务 http请求
        List<ServiceInstance> instances = discoveryClient.getInstances("product-service");
        //因为只有一个PRODUCT-SERVICE服务，所以可以这样写
        ServiceInstance serviceInstance = instances.get(0);
        //获取ip和端口信息
        String URL_PREFIX="http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+"/productService/";
        String url = URL_PREFIX+id;
        return restTemplate.getForObject(url,Product.class );
    }
}

此时，有两大问题：
问题一：负载均衡
问题二：只有一个EurekaServer，挂了就不行了

五、Eureka注册中心集群

分布式：把不同业务分散到不同的服务器集群。
微服务架构也是特殊的分布式-拆分服务不就是拆分业务吗
集群：多个服务器协调完成一种业务。

1.为什么要集群？

如果只有一个注册中心服务器，会存在单点故障所以要集群。

2.怎么做？

生产环境：把一个eureka部署到多个服务器
模拟学习环境：不同的端口号代替多个服务器

3.搭建集群

拷贝一份eureka服务模块
改入口类名，改端口号
改hosts文件（C:\Windows\System32\drivers\etc下面的hosts文件）

127.0.0.1 eureka-8003.com
127.0.0.1 eureka-8004.com

两个eureka服务模块的yml文件配置
8003

server:
  port: 8003
eureka:
  instance:
    hostname: eureka-8003.com
  client:
    registerWithEureka: false #是否要注册到eureka
    fetchRegistry: false #表示是否从Eureka Server获取注册信息
    serviceUrl:
      #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机配置
      defaultZone: http://eureka-8004.com:8004/eureka/ #集群配置

8004

server:
  port: 8004
eureka:
  instance:
    hostname: eureka-8004.com
  client:
    registerWithEureka: false #是否要注册到eureka
    fetchRegistry: false #表示是否从Eureka Server获取注册信息
    serviceUrl:
      #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机配置
      defaultZone: http://eureka-8003.com:8003/eureka/ #单机配置

服务提供者和服务消费者的修改

defaultZone: http://localhost:8003/eureka,http://localhost:8004/eureka

启动服务并测试：
8003
在这里插入图片描述 8004

暗影杀神

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录