为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 SpringCloud学习：从入门到初级实战指南

SpringCloud学习：从入门到初级实战指南

标签：
Spring Cloud
概述

本文全面介绍了SpringCloud学习的相关内容，包括SpringCloud的核心组件、版本管理以及依赖配置。文章还详细讲解了如何快速开始使用SpringCloud，包括创建项目、配置服务以及运行和测试基本服务。此外，文中还深入探讨了服务发现与注册、负载均衡、断路器、API网关和配置中心的实现方法。

SpringCloud简介

什么是SpringCloud

Spring Cloud是一个基于Spring Boot的微服务框架，它提供了多种组件，以简化分布式系统（如配置管理、服务发现、断路器、路由、微服务仪表盘等）中的一些常见模式。Spring Cloud的核心思想是利用Spring Boot的约定优于配置的理念，使得微服务开发变得更为简单。

SpringCloud的核心组件

Spring Cloud包含众多核心组件，以下是其中一些常用的组件：

  1. Eureka：服务注册与发现机制，它允许服务提供者和消费者之间进行自动发现和调用。
  2. Ribbon：客户端负载均衡服务，用于在多个服务提供者之间进行负载均衡。
  3. Hystrix：实现熔断器模式的一种工具，主要用于管理分布式环境中的容错。
  4. Feign：基于Ribbon和Hystrix的声明式服务调用，简化HTTP请求的调用。
  5. Zuul：API网关，用于路由请求到相应的服务，并提供过滤器进行预处理和后处理。
  6. Config：提供配置服务器和客户端，用于集中管理和动态更新应用配置。
  7. Consul：服务发现和配置工具，提供更丰富的服务发现功能，包括健康检查、服务注册、服务发现等。
  8. Spring Cloud Gateway：新一代API网关，用于API路由和过滤。

SpringCloud的版本与依赖管理

Spring Cloud与Spring Boot版本紧密相关，通常Spring Cloud发布的版本会兼容一个或多个特定的Spring Boot版本。当前主流版本的Spring Cloud与Spring Boot版本对应关系如下：

  • Spring Cloud 2021.0.x 版本，兼容 Spring Boot 2.6.x 版本
  • Spring Cloud 2020.0.x 版本，兼容 Spring Boot 2.5.x 版本
  • Spring Cloud 2019.0.x 版本，兼容 Spring Boot 2.3.x 版本
  • Spring Cloud 2018.0.x 版本，兼容 Spring Boot 2.2.x 版本

要使用这些版本，需要在项目的pom.xml文件中指定对应的Spring Cloud版本：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.3</version>
</parent>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

快速开始SpringCloud

创建SpringBoot项目

  1. 添加依赖：首先在Spring Initializr中创建一个新的Spring Boot项目，选择以下依赖：

    • Spring Web
    • Spring Boot DevTools
    • Spring Cloud Starter Eureka Client
  2. 项目结构：使用IDE，如IntelliJ IDEA或Eclipse，创建一个新的Maven项目，并导入以上依赖。
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>
  1. 主配置文件：在application.yml中添加Eureka配置，使服务实例能够注册到Eureka服务器。
spring:
  application:
     name: service-provider
eureka:
   client:
      service-url:
         defaultZone: http://localhost:8761/eureka/

配置SpringCloud服务

  1. 配置服务提供者：创建一个新的服务提供者，可以使用简单的REST接口。
package com.example.serviceprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
class ProviderController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from service provider!";
    }
}
  1. 配置服务消费者：创建一个服务消费者，使用Eureka客户端获取服务提供者的信息。
package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

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

@RestController
class ConsumerController {
    private final RestTemplate restTemplate;
    public ConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/consumer")
    public String consumer() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/hello", String.class);
    }
}

运行和测试基本服务

  1. 启动Eureka服务器：使用Spring Cloud构建一个Eureka服务注册中心。首先创建一个新的Spring Boot项目，添加Spring Cloud依赖并配置Eureka作为服务注册中心。
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
  1. 配置Eureka服务：在配置文件application.yml中配置Eureka服务端。
spring:
   application:
      name: eureka-server
eureka:
   instance:
      hostname: localhost
   client:
      register-with-eureka: false
      fetch-registry: false
   server: true

  1. 启动Eureka服务器：启动Eureka服务端应用，确保它运行在端口8761上。

  2. 启动服务提供者和消费者：分别启动服务提供者和服务消费者，确保它们都能注册到Eureka服务端。

  3. 访问服务：访问服务消费者提供的接口，查看服务调用结果。

服务发现与注册

使用Eureka实现服务注册与发现

  1. 服务提供者的注册：通过添加@EnableEurekaClient注解，服务提供者能够自动注册到Eureka服务端。
package com.example.serviceprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class ServiceProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(浭ServiceProviderApplication.class, args);
    }
}
  1. 服务消费者的发现：服务消费者通过Ribbon或Feign的负载均衡策略，实现对多个服务提供者的动态调用。
package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;

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

    @Bean
    public FeignClientBuilder feignClientBuilder() {
        return Feign.builder()
                .options(new Request.Options(5000, TimeUnit.MILLISECONDS))
                .retryer(Retryer.NEVER_RETRY);
    }
}

Eureka集群搭建与高可用性

  1. 配置多个Eureka服务端：每个Eureka服务端需要配置不同的hostname和端口。
eureka:
   instance:
      hostname: eureka-server-1
   client:
      service-url:
         defaultZone: http://eureka-server-2:8761/eureka/,http://eureka-server-3:8761/eureka/

  1. Eureka服务端的注册：确保每个Eureka服务端实例都注册到集群中的其他节点，形成环形或星形拓扑结构。

  2. 服务的健康检查与监控：Eureka服务端提供Web界面来查看服务实例的注册、健康状态等信息。可以通过浏览器访问http://localhost:8761来查看集群状态。

负载均衡与断路器

使用Ribbon进行服务的负载均衡

  1. 引入Ribbon依赖：在服务消费者项目中添加Ribbon依赖。
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
  1. 配置负载均衡策略：自定义负载均衡策略，使用轮询方式调用服务提供者。
package com.example.serviceconsumer;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

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

使用Hystrix实现服务的断路器功能

  1. 添加Hystrix依赖：引入Hystrix依赖，并配置断路器策略。
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
  1. 启用Hystrix断路器：在服务消费者中添加Hystrix断路器配置。
package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;

@SpringBootApplication
@EnableCircuitBreaker
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}
  1. 熔断策略配置：配置Hystrix的熔断器策略，如失败率阈值、超时时间等。
hystrix:
   command:
      default:
         execution:
            isolation:
               thread:
                  timeoutInMilliseconds: 2000
         circuitBreaker:
            requestVolumeThreshold: 10
            errorThresholdPercentage: 50
            sleepWindowInMilliseconds: 5000

API网关和路由

使用Zuul实现API网关

  1. 引入Zuul依赖：在项目中引入Zuul的相关依赖。
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
  1. 配置路由规则：在application.yml中配置路由规则，将请求路由到相应的服务。
spring:
   application:
      name: api-gateway

zuul:
   routes:
      service-provider:
         path: /provider/**
         url: http://localhost:8080

Zuul的路由规则与动态路由

  1. 动态路由配置：通过Spring Cloud Config等配置中心，动态修改路由规则。
zuul:
   routes:
      service-provider:
         path: /provider/**
         sensitive-url: false
         strip-prefix: false
         url: ${ZUUL_SERVICE_PROVIDER_URL:http://localhost:8080}

Zuul的过滤器与安全策略

  1. 自定义过滤器：添加自定义过滤器，实现特定需求，如日志记录、认证等。
package com.example.apigateway;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import javax.servlet.http.HttpServletRequest;
import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;
import org.springframework.stereotype.Component;

@Component
public class CustomFilter extends ZuulFilter {

    @Override
    public String filterType() {
        return "pre";
    }

    @Override
    public int filterOrder() {
        return 1;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        System.out.println(String.format("%s request %s to %s", request.getMethod(), request.getRequestURL().toString(), request.getRemoteAddr()));
        return null;
    }
}

配置中心与分布式配置

使用SpringCloud Config实现配置中心

  1. 引入Spring Cloud Config依赖：在服务中引入Spring Cloud Config客户端的依赖。
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
  1. 配置文件：在服务中添加配置文件，指定配置中心的位置。
spring:
   application:
      name: service-consumer
cloud:
   config:
      uri: http://localhost:8888

分布式配置的版本控制

  1. 版本控制：配置中心可以支持文件的版本控制，通过配置文件名后缀来区分不同版本。
spring:
   cloud:
      config:
         server:
            git:
               uri: https://github.com/your-repo
               default-label: master
               clone-on-start: true

动态刷新配置与热部署

  1. 刷新配置：通过/actuator/refresh接口刷新配置。
package com.example.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}
  1. 配置刷新接口：在服务消费者中调用刷新接口，动态刷新配置。
package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

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

@RestController
@RefreshScope
class ConsumerController {
    private final RestTemplate restTemplate;

    public ConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/refresh")
    public String refresh() {
        restTemplate.getForObject("http://localhost:8888/actuator/refresh", String.class);
        return "Configuration refreshed";
    }
}

通过以上步骤，可以构建一个基础的Spring Cloud微服务体系，并实现服务发现、负载均衡、断路器、API网关和配置中心等功能。这为构建更复杂和高可用的微服务架构奠定了坚实的基础。

点击查看更多内容
发表于 2024.10.23 09:43， 共 158 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

守着一只汪

手记
篇
粉丝
11
获赞与收藏
37

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消