什么是SpringCloud

     Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、熔断器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。 
     Spring Cloud项目的官方网址：http://projects.spring.io/spring-cloud/ 
   **SpringCloud与SpringBoot的关系**  
   Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务，Spring Cloud是一个基于Spring Boot实现的云应用开发工具；Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架； Spring Boot使用了默认大于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置，Spring Cloud很大的一部分是基于Spring Boot来实现，可以不基于Spring Boot吗？不可以。 Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
   **SpringCloud主要框架** 
   服务发现——Netflix Eureka 
   服务调用——Netflix Feign 
   熔断器——Netflix Hystrix 
   服务网关——Netflix Zuul 
   分布式配置——Spring Cloud Config 
   消息总线 —— Spring Cloud Bus 
   **Spring Cloud和Dubbo对比** 
   或许很多人会说Spring Cloud和Dubbo的对比有点不公平，Dubbo只是实现了服务治理，而Spring Cloud下面有17个子项目（可能还会新增）分别覆盖了微服务架构下的方方面面，服务治理只是其中的一个方面，一定程度来说，Dubbo只是Spring Cloud Netflix中的一个子集。

SpringCloud由于是一系列框架组合，为了避免与包含的自框架版本产生混淆，采用伦敦地铁站的名称作为版本名，形式为版本名+里程碑号。 M9为第9个里程碑版本。
服务发现组件 Eureka
Eureka是Netflix开发的服务发现框架，SpringCloud将它集成在自己的子项目spring-cloud-netflix中，实现SpringCloud的服务发现功能。Eureka包含两个组件：Eureka Server和Eureka Client。
Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。
Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就是一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)
Eureka Server之间通过复制的方式完成数据的同步，Eureka还提供了客户端缓存机制，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API。综上，Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性。
Eureka服务端开发
（1）创建_eureka模块
（2）引入依赖父工程pom.xml定义SpringCloud版本

!--dependencyManagement 用于锁版本的 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.M9</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

eureka模块pom.xml引入eureka-server

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

（2）添加application.yml

server:
  port: 7979
eureka:
  client:
    register-with-eureka: false #是否将自己注册到Eureka服务中，本身就是所有无需注册
fetch-registry: false #是否从Eureka中获取注册信息
    service-url: #Eureka客户端与Eureka服务端进行交互的地址
      defaultZone: http://127.0.0.1:${server.port}/eureka/

3）编写启动类

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

4）启动运行启动类，然后在浏览器地址栏输入 http://localhost:7979/ 运行效果如下：

主界面中system status为系统信息 General Info为一般信息 Instances currently registered with Eureka为注册到的所有微服务列表

熔断器Hystrix
为什么要使用熔断器
在微服务架构中通常会有多个服务层调用，基础服务的故障可能会导致级联故障,进而造成整个系统不可用的情况，这种现象被称为服务雪崩效应。服务雪崩效应是一种因“服务提供者”的不可用导致“服务消费者”的不可用,并将不可用逐渐放大的过程
如果下图所示：A作为服务提供者，B为A的服务消费者，C和D是B的服务消费者。A不可用引起了B的不可用，并将不可用像滚雪球一样放大到C和D时，雪崩效应就形成了。

什么是Hystrix

Hystrix [hɪst’rɪks]的中文含义是豪猪, 因其背上长满了刺,而拥有自我保护能力
Hystrix 能使你的系统在出现依赖服务失效的时候，通过隔离系统所依赖的服务，防止服务级联失败，同时提供失败回退机制，更优雅地应对失效，并使你的系统能更快地从异常中恢复。了解熔断器模式请看下图：

Feign 本身支持Hystrix，不需要额外引入依赖
微服务模块之间的调用如果出现被调用方崩掉就采用Hystrix
在调用方配置文件中加入

feign: 
  hystrix: enabled: 
     true #把feign中的熔断器打开

（2）在gy.client包下创建impl包，包下创建熔断实现类，实现自接口LabelClient

@Component   //将实现类放入spring容器中public class LabelClientImpl implements LabelClient { @Override public Result findById(String id) { return new Result(false, StatusCode.ERROR,"熔断器启动了"); } }

3）修改LabelClient的注解

@FeignClient(value="tensquare‐base",fallback =LabelClientImpl.class) 
重新启动问答微服务，测试看熔断器是否运行。

微服务网关Zuul
为什么需要微服务网关
不同的微服务一般有不同的网络地址，而外部的客户端可能需要调用多个服务的接口才能完成一个业务需求。比如一个电影购票的收集APP,可能会调用电影分类微服务，用户微服务，支付微服务等。如果客户端直接和微服务进行通信，会存在一下问题：

客户端会多次请求不同微服务，增加客户端的复杂性
存在跨域请求，在一定场景下处理相对复杂
认证复杂，每一个服务都需要独立认证难以重构，随着项目的迭代，可能需要重新划分微服务，如果客户端直接和微服务通信，那么重构会难以实施
某些微服务可能使用了其他协议，直接访问有一定困难上述问题，都可以借助微服务网关解决。微服务网关是介于客户端和服务器端之间的中间层，所有的外部请求都会先经过微服务网关。
什么是Zuul
Zuul是Netflix开源的微服务网关，他可以和Eureka,Ribbon,Hystrix等组件配合使用。Zuul组件的核心是一系列的过滤器，这些过滤器可以完成以下功能：
审查与监控：
动态路由：动态将请求路由到不同后端集群
压力测试：逐渐增加指向集群的流量，以了解性能
负载分配：为每一种负载类型分配对应容量，并弃用超出限定值的请求
静态响应处理：边缘位置进行响应，避免转发到内部集群
多区域弹性：跨域AWS Region进行请求路由，旨在实现ELB(ElasticLoad Balancing)使用多样化 Spring Cloud对Zuul进行了整合和增强。
使用Zuul后，架构图演变为以下形式

Zuul路由转发
管理后台微服务网关
1）创建子模块manager，pom.xml引入eureka-client 和zuul的依赖

<dependencies>
    <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-zuul</artifactId>
    </dependency>
</dependencies>

（2）创建application.yml

server:
  port: 9011
spring:
  application:
    name: manager
eureka:
  client:
    service-url: #Eureka客户端与Eureka服务端进行交互的地址
      defaultZone: http://127.0.0.1:6868/eureka/
  instance:
    prefer-ip-address: true #为了以后布到线上的时候模块之间可以跨域访问
zuul:
  routes:
    tensquare-base: #基础
      path: /base/** #配置请求URL的请求规则
      serviceId: base #指定Eureka注册中心中的服务id
    tensquare-user: #基础
      path: /user/** #配置请求URL的请求规则
      serviceId: user #指定Eureka注册中心中的服务id
    tensquare-qa: #基础
      path: /qa/** #配置请求URL的请求规则
      serviceId: qa #指定Eureka注册中心中的服务id

（3）编写启动类

@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy
public class ManagerApplication {

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

网站前台的微服务网关
（1）创建子模块web，pom.xml引入依赖zuul

<dependencies>
    <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-zuul</artifactId>
    </dependency>
</dependencies>

（2）创建application.yml

server:
  port: 9012
spring:
  application:
    name: tensquare-web
eureka:
  client:
    service-url: #Eureka客户端与Eureka服务端进行交互的地址
      defaultZone: http://127.0.0.1:6868/eureka/
  instance:
    prefer-ip-address: true #为了以后布到线上的时候模块之间可以跨域访问
zuul:
  routes:
    tensquare-base: #基础
      path: /base/** #配置请求URL的请求规则
      serviceId: tensquare-base #指定Eureka注册中心中的服务id
    tensquare-user: #基础
      path: /user/** #配置请求URL的请求规则
      serviceId: tensquare-user #指定Eureka注册中心中的服务id
    tensquare-qa: #基础
      path: /qa/** #配置请求URL的请求规则
      serviceId: tensquare-qa #指定Eureka注册中心中的服务id

（3）编写启动类

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

Zuul过滤器
我们现在在manager 创建一个简单的zuul过滤器

@Component
public class ManagerFilter extends ZuulFilter {
    @Override
    public String filterType() {
        /**
         * 在请求前pre或者后post执行
         */
        return "pre";
    }

**
     * 多个过滤器的执行顺序,数字越小,越先执行
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

/**
     * 当前过滤器是否开启true表示开启
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }
/**
     * 过滤器内执行的操作 return 任何Object的值都表示继续执行
     * setsendzuulResponse(false)表示不再继续执行
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
 System.out.println("经过后台过滤器了");
        return null;
    }
}

启动manager会发现过滤器已经执行
filterType：返回一个字符串代表过滤器的类型，在zuul中定义了四种不同生
命周期的过滤器类型，具体如下：
pre ：可以在请求被路由之前调用
route ：在路由请求时候被调用
post ：在route和error过滤器之后被调用
error ：处理请求时发生错误时被调用
filterOrder ：通过int值来定义过滤器的执行顺序
houldFilter ：返回一个boolean类型来判断该过滤器是否要执行，所以通
过此函数可实现过滤器的开关。在上例中，我们直接返回true，所以该过滤器总是生效
run ：过滤器的具体逻辑

管理后台过滤器实现token校验
manager的过滤器, 因为是管理后台使用，所以需要在过滤器中对token进行验证。
manager引入common依赖，因为需要用到其中的JWT工具类

<dependency>
    <groupId>com.tensquare</groupId>
    <artifactId>tensquare_common</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

（2）修改manager配置文件application.yml

jwt: 
  config: 
     key: itcast

（3）修改manager的启动类,添加bean

@Bean
public JwtUtil jwtUtil(){
    return new JwtUtil();
}

（4）manager编写过滤器类

/**
 * 过滤器内执行的操作 return 任何Object的值都表示继续执行
 * setsendzuulResponse(false)表示不再继续执行
 * @return
 * @throws ZuulException
 */
 @Override
public Object run() throws ZuulException {
    System.out.println("经过后台过滤器了");
    //得到request上下文
    RequestContext requestContext = RequestContext.getCurrentContext();
    //得到request域
    HttpServletRequest request = requestContext.getRequest();
    if(request.getMethod().equals("OPTIONS")){
        return null;
    }
    if(request.getRequestURL().indexOf("login")>0){
     return null;
}

/得到头信息
String header = request.getHeader("Authorization");
if(header!=null && !"".equals(header)){
    if(header.startsWith("Bearer ")){
        String token = header.substring(7);
        try{
            Claims claims = jwtUtil.parseJWT(token);
            String roles = (String) claims.get("roles");
            if(roles.equals("admin")){
                //表示把头信息转发下去并且放行
                requestContext.addZuulRequestHeader("Authorization",header);
                return null;
                }
                }catch (Exception e){
   e.printStackTrace();
    requestContext.setSendZuulResponse(false);//终止运行
}
}
requestContext.setSendZuulResponse(false);//终止运行
requestContext.setResponseStatusCode(403);
requestContext.setResponseBody("权限不足");
requestContext.getResponse().setContentType("text/html;charset=utf-8");
return null;
}
}

集中配置组件SpringCloudConfig
Spring Cloud Config简介
在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件。在Spring Cloud中，有分布式配置中心组件spring cloud config ，它支持配置服务放在配置服务的内存中（即本地），也支持放在远程Git仓库中。在spring cloud config 组件中，分两个角色，一是config server，二是configclient。
Config Server是一个可横向扩展、集中式的配置服务器，它用于集中管理应用程序各个环境下的配置，默认使用Git存储配置文件内容，也可以使用SVN存储，或者是本地文件存储。 Config Client是Config Server的客户端，用于操作存储在Config Server中的配置内容。微服务在启动时会请求Config Server获取配置文件的内容，请求到后再启动容器.详细内容看在线文档：
https://springcloud.cc/spring-cloud-config.html
配置服务端将配置文件提交到码云
使用GitHub时，国内的用户经常遇到的问题是访问速度太慢，有时候还会出现无法连接的情况。如果我们希望体验Git飞一般的速度，可以使用国内的Git托管服务——码云（gitee.com）。和GitHub相比，码云也提供免费的Git仓库。此外，还集成了代码质量检测、项目演示等功能。对于团队协作开发，码云还提供了项目管理、代码托管、文档管理的服务。
步骤：
（1）浏览器打开gitee.com，注册用户，注册后登陆码云管理控制台

创建项目 config (点击右上角的加号，下拉菜单选择创建项目)
（1）上传配置文件，将base工程的application.yml改名为base-dev.yml后上传

可以通过拖拽的方式将文件上传上去

上传成功后列表可见

文件命名规则：
{application}-{profile}.yml或{application}-{profile}.properties
配置中心微服务
（1）创建工程模块配置中心微服务 config ,pom.xml引入依赖

<!-- 配置中心微服务的依赖-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
</dependencies>

（2）创建启动类ConfigServerApplication

@SpringBootApplication
@EnableConfigServer  //开启配置服务
public class ConfigApplication {
    public static void main(String[] args) {
 SpringApplication.run(ConfigApplication.class,args);
    }
}

（3）编写配置文件application.yml

server:
  port: 12000
spring:
  application:
    name: tensquare-config
  cloud:
    config:
      server:
git:
          uri: https://gitee.com/mengyang111/tensquare_dev84.git

4）浏览器测试：http://localhost:12000/base-dev.yml 可以看到配置内容
配置客户端
（1）在base工程添加依赖

!-- 找到cofig服务器的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

（1）添加bootstrap.yml ,删除application.yml

spring:
  cloud:
    config:
      name: base
      profile: dev
      label: master
      uri: http://127.0.0.1:12000

（3）测试：启动工程eureka,config ,base，看是

否可以正常运行 http://localhost:9001/label

消息总线组件SpringCloudBus
SpringCloudBus简介
如果我们更新码云中的配置文件，那客户端工程是否可以及时接受新的配置信息呢？我们现在来做有一个测试，修改一下码云中的配置文件中mysql的端口，然后测试http://localhost:9001/label 数据依然可以查询出来，证明修改服务器中的配置并没有更新立刻到工程，只有重新启动程序才会读取配置。那我们如果想在不重启微服务的情况下更新配置如何来实现呢? 我们使用SpringCloudBus来实现配置的自动更新。
代码实现
配置服务端

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-bus</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>

（2）修改application.yml ，添加配置

rabbitmq:
    host: 192.168.223.128
management: #暴露触发消息总线的地址
  endpoints:
    web:
      exposure:
        include: bus-refresh

配置客户端
我们还是以基础模块为例，加入消息总线
1）修改base工程，引入依赖

<!-- 消息总线客户端依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-bus</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>
<!-- 客户端监听-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

在码云的配置文件中配置rabbitMQ的地址：

rabbitmq: host: 192.168.184.135

（2）启动tensquare_eureka 、tensquare_config和tensquare_base 看是否正常运行
修改码云上的配置文件，将数据库连接IP 改为127.0.0.1 ，在本地部署一份数据库。
（4）postman测试 Url: http://127.0.0.1:12000/actuator/bus-refresh Method:
（5）再次观察输出的数据是否是读取了本地的mysql数据。

自定义配置的读取

（1）修改码云上的配置文件，增加自定义配置

sms:
   ip: 127.0.0.1

（1）在base工程中新建controller

@RestController 
public class TestController { 
@Value("${sms.ip}") 
private String ip; 
@RequestMapping(value = "/ip", method = RequestMethod.GET) 
public String ip() { 
return ip; 
}
 }

（3）运行测试看是否能够读取配置信息，OK.
（4）修改码云上的配置文件中的自定义配置
sms: ip: 192.168.223.129
（5）通过postman测试 Url: http://127.0.0.1:12000/actuator/bus-refresh Method: post
测试后观察,发现并没有更新信息。
这是因为我们的 controller少了一个注解@RefreshScope 此注解用于刷新配

今天的文章什么是SpringCloud分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：http://bianchenghao.cn/62208.html

什么是SpringCloud

相关推荐

发表回复