首页手记 SpringCloud应用学习：从入门到初级实战

SpringCloud应用学习：从入门到初级实战

标签：

Spring Cloud 微服务

概述

本文详细介绍了SpringCloud应用学习的各个方面，从SpringCloud的基本概念和核心组件到快速搭建微服务架构，涵盖了服务注册与发现、负载均衡、服务容错等关键技术点。文章还通过实战案例展示了如何构建一个简单的电商微服务系统，帮助读者全面掌握SpringCloud的使用方法。

SpringCloud应用学习：从入门到初级实战

1. SpringCloud简介

什么是SpringCloud

SpringCloud是一系列微服务框架的集合，旨在简化分布式系统基础设施的搭建与开发。它基于SpringBoot的约定优于配置的哲学，提供了微服务架构下的服务治理解决方案，包括服务注册与发现、配置中心、负载均衡、断路器等，使得开发者可以快速构建出具有分布式系统特性的应用。

SpringCloud的核心组件

SpringCloud的核心组件包括：

Eureka：服务注册与发现。
Ribbon：客户端负载均衡。
Feign：声明式服务调用。
Hystrix：断路器。
Zuul：API Gateway。
Config：配置中心。
Consul：服务发现和配置管理。

这些组件通过SpringCloud的统一配置和约定，实现了自动化部署、配置管理、服务发现、断路器、智能路由、微代理、控制总线、全局锁、领导选举、分布式会话、集群状态等关键功能。

SpringCloud的优势和应用场景

SpringCloud的优势包括：

快速构建分布式系统：通过SpringCloud，可以快速搭建分布式系统，减少重复开发的工作。
高度可扩展：可以根据需要灵活地添加或移除服务。
自动化配置：通过SpringBoot的自动化配置，减少重复配置的工作。
服务治理：内置服务治理方案，简化了服务发现、负载均衡、熔断等操作。
社区活跃：SpringCloud拥有庞大的开发者社区，持续更新和完善。

SpringCloud的应用场景包括：

电商系统：如订单系统、支付系统、库存系统等，实现高可用、高并发、分布式部署。
金融服务：如交易系统、风控系统、资产管理等，对系统稳定性和安全性要求较高。
物流配送系统：如配送跟踪、订单管理、库存管理等，实现高效、可靠的物流服务。
在线教育平台：如课程管理系统、用户管理系统、支付系统等，实现灵活的服务部署和负载均衡。

2. SpringBoot快速入门

SpringBoot的基本概念

SpringBoot是Spring框架的一个简化和增强版本，旨在简化新Spring应用的初始搭建以及开发过程。它通过约定优于配置的方式，提供了丰富的自动配置，使得开发者可以快速搭建和部署应用。

创建第一个SpringBoot项目

创建工程：

使用IDEA或Maven构建一个SpringBoot项目。

<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

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

   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
   </dependencies>
</project>

创建主类：

创建一个主类，并使用@SpringBootApplication注解启动应用。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

创建控制器：

创建一个简单的控制器，提供HTTP服务。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
   @GetMapping("/hello")
   public String hello() {
       return "Hello, World!";
   }
}

SpringBoot的常用注解和配置

@SpringBootApplication：包含@Configuration、@EnableAutoConfiguration、@ComponentScan三个注解，启用自动配置和组件扫描。
@Configuration：标记类为配置类，可以包含@Bean注解的成员。
@EnableAutoConfiguration：启用自动配置。
@ComponentScan：指定扫描的包名，自动扫描包内的组件类。
@Controller：标记类为控制器，处理HTTP请求。
@Service：标记类为服务层，执行业务逻辑。
@Repository：标记类为数据访问层，处理数据访问逻辑。
@Bean：标记方法返回的对象为Spring容器中的bean。
@Value：用于注入值到属性中。

SpringBoot的配置文件

SpringBoot提供了application.properties或application.yml两种配置文件，用于配置应用的属性。

# application.properties
server.port=8080
spring.application.name=demo-app

# application.yml
server:
  port: 8080
spring:
  application:
   name: demo-app

3. SpringCloud微服务架构搭建

微服务架构的基本概念

微服务架构是一种将单体应用拆分为多个小的、独立的服务的架构风格。每个服务都可以独立部署、扩展和升级，提高了系统的灵活性和可维护性。

使用SpringCloud搭建简单的微服务

创建父工程：

创建一个Maven多模块工程，包含多个微服务模块。

<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example</groupId>
   <artifactId>spring-cloud-demo</artifactId>
   <version>1.0.0-SNAPSHOT</version>
   <packaging>pom</packaging>
   <modules>
       <module>service-a</module>
       <module>service-b</module>
       <module>service-c</module>
   </modules>
</project>

创建服务模块：

每个服务模块都包含一个主类和控制器。

// service-a
package com.example.servicea;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

// service-b
package com.example.serviceb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

服务注册与发现：

使用Eureka作为服务注册与发现中心。

// service-a
package com.example.servicea;

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

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

// service-b
package com.example.serviceb;

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

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

配置文件：

在每个服务模块的application.yml中配置Eureka注册中心的地址。

# service-a
spring:
 application:
   name: service-a
eureka:
 client:
   service-url:
     defaultZone: http://localhost:8761/eureka/

# service-b
spring:
 application:
   name: service-b
eureka:
 client:
   service-url:
     defaultZone: http://localhost:8761/eureka/

负载均衡与服务路由

配置服务提供者：

服务提供者需要配置服务名称和端口，以便其他服务能够找到它们。

# service-a
spring:
 application:
   name: service-a
server:
 port: 8081

# service-b
spring:
 application:
   name: service-b
server:
 port: 8082

配置服务消费者：

服务消费者使用@LoadBalanced注解的RestTemplate来实现负载均衡。

// service-b
package com.example.serviceb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

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

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

调用服务：

在服务消费者中通过RestTemplate调用服务提供者。

// service-b
package com.example.serviceb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ServiceBController {
   @Autowired
   private RestTemplate restTemplate;

   @GetMapping("/call-service-a")
   public String callServiceA() {
       return restTemplate.getForObject("http://service-a/hello", String.class);
   }
}

4. SpringCloud配置中心

使用SpringCloud Config管理配置

SpringCloud Config提供了服务端和客户端支持，用于集中管理应用的配置文件。服务端可以存储配置文件，客户端可以从服务端拉取配置文件。

配置中心的基本原理

服务端：
- 配置中心服务端可以存储配置文件，支持多种存储方式，如Git、本地文件等。
- 使用spring-cloud-config-server依赖实现。
客户端：
- 配置中心客户端可以从服务端拉取配置文件，支持动态刷新配置。
- 使用spring-cloud-config-client依赖实现。

实战：配置中心的使用与部署

创建配置中心服务端：

创建一个SpringBoot应用，并添加spring-cloud-config-server依赖。

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

配置文件：

配置服务端的application.yml文件。

server:
 port: 8888
spring:
 cloud:
   config:
     server:
       git:
         uri: https://github.com/example/configrepo
         default-label: master

启动服务端：

启动配置中心服务端应用。

package com.example.configserver;

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

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

创建配置中心客户端：

创建一个SpringBoot应用，并添加spring-cloud-config-client依赖。

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

配置文件：

配置客户端的bootstrap.yml文件。

spring:
 cloud:
   config:
     uri: http://localhost:8888
     name: service-a
     profile: dev

获取配置：

在客户端应用中，可以通过@Value注解注入配置值。

package com.example.servicea;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceAController {
   @Value("${message:Hello, World!}")
   private String message;

   @GetMapping("/message")
   public String getMessage() {
       return message;
   }
}

5. SpringCloud服务容错与保护

服务容错的基本概念

服务容错是指在分布式系统中，面对各种异常情况（如服务不可用、网络故障等）时，系统能够继续正常运行的能力。常用的策略包括断路器、服务熔断、降级等。

断路器（Hystrix）的使用

Hystrix是一个用于处理分布式系统延迟和容错的库。它通过隔离依赖服务的访问点、故障fallback、请求缓存和请求合并来提高系统的整体可用性。

添加依赖：

添加spring-cloud-starter-netflix-hystrix依赖。

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

启用Hystrix：

在主类中启用Hystrix。

package com.example.serviceb;

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

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

定义Fallback：

在服务调用中定义Fallback逻辑。

package com.example.serviceb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ServiceBController {
   @Autowired
   private RestTemplate restTemplate;

   @GetMapping("/call-service-a")
   public String callServiceA() {
       return restTemplate.getForObject("http://service-a/hello", String.class);
   }

   @GetMapping("/call-service-a-with-fallback")
   public String callServiceAWithFallback() {
       return restTemplate.getForObject("http://service-a/hello", String.class, (method, url) -> {
           return restTemplate.execute(url, method, null, null);
       });
   }
}

配置Hystrix：

在配置文件中配置Hystrix的超时时间和失败阈值。

hystrix:
 command:
   default:
     execution:
       isolation:
         thread:
           timeoutInMilliseconds: 2000

服务熔断与降级策略

服务熔断是一种保护机制，当请求的失败率超过一定阈值时，系统会自动将请求进行暂时隔离，避免整个系统雪崩。

熔断策略：

在服务端配置熔断策略。

hystrix:
 command:
   default:
     circuitBreaker:
       enabled: true
       requestVolumeThreshold: 10
       sleepWindowInMilliseconds: 5000
       errorThresholdPercentage: 50

降级处理：

在服务调用中定义降级逻辑。

package com.example.serviceb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@EnableCircuitBreaker
public class ServiceBController {
   @Autowired
   private RestTemplate restTemplate;

   @GetMapping("/call-service-a")
   public String callServiceA() {
       return restTemplate.getForObject("http://service-a/hello", String.class);
   }

   @GetMapping("/call-service-a-with-fallback")
   public String callServiceAWithFallback() {
       return restTemplate.getForObject("http://service-a/hello", String.class, (method, url) -> {
           return restTemplate.execute(url, method, null, null);
       });
   }
}

6. 实战案例：构建一个简单的电商微服务

案例背景与需求分析

本案例将构建一个简单的电商系统，包括订单服务、库存服务和支付服务。系统要求高可用、可扩展、易于维护。

分解服务模块

订单服务：
- 提供订单创建、查询、取消等功能。
库存服务：
- 提供商品库存查询、库存减少、库存增加等功能。
支付服务：
- 提供支付接口，处理支付请求。

服务集成与测试

订单服务：

创建订单服务，提供订单相关接口。

package com.example.orderservice;

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

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

package com.example.orderservice.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@EnableCircuitBreaker
public class OrderController {
   @Autowired
   @LoadBalanced
   private RestTemplate restTemplate;

   @GetMapping("/create-order")
   public String createOrder() {
       // 创建订单逻辑
       return "Order created successfully";
   }

   @GetMapping("/cancel-order")
   public String cancelOrder() {
       // 取消订单逻辑
       return "Order canceled successfully";
   }
}

库存服务：

创建库存服务，提供库存相关接口。

package com.example.stockservce;

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

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

package com.example.stockservce.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@EnableCircuitBreaker
public class StockController {
   @Autowired
   @LoadBalanced
   private RestTemplate restTemplate;

   @GetMapping("/check-stock")
   public String checkStock() {
       // 查询库存逻辑
       return "Stock available";
   }

   @GetMapping("/reduce-stock")
   public String reduceStock() {
       // 减少库存逻辑
       return "Stock reduced successfully";
   }

   @GetMapping("/increase-stock")
   public String increaseStock() {
       // 增加库存逻辑
       return "Stock increased successfully";
   }
}

支付服务：

创建支付服务，提供支付相关接口。

package com.example.payservice;

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

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

package com.example.payservice.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@EnableCircuitBreaker
public class PayController {
   @Autowired
   @LoadBalanced
   private RestTemplate restTemplate;

   @GetMapping("/pay")
   public String pay() {
       // 支付逻辑
       return "Payment successful";
   }
}

服务集成：

在订单服务中调用库存服务和支付服务。

package com.example.orderservice.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
@EnableCircuitBreaker
public class OrderService {
   @Autowired
   @LoadBalanced
   private RestTemplate restTemplate;

   public void createOrder() {
       // 创建订单逻辑
       restTemplate.postForObject("http://stock-service/check-stock", null, String.class);
       restTemplate.postForObject("http://pay-service/pay", null, String.class);
   }
}

测试服务：

使用Postman或SpringBoot的/actuator端点进行服务测试。

package com.example.orderservice;

import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ActuatorController implements ErrorController {
   private static final String PATH = "/error";

   @RequestMapping(PATH)
   public String error() {
       return "Error occurred";
   }

   @Override
   public String getErrorPath() {
       return PATH;
   }
}

通过以上步骤，可以构建一个简单的电商微服务系统，实现高可用、可扩展、易于维护的分布式架构。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

LEATH

手记
篇

粉丝

93

获赞与收藏

467

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6180 121

后端通用面试教程

41个小节 30936 346

网络编程入门教程

20个小节 12729 240

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

SpringCloud应用学习：从入门到初级实战

1. SpringCloud简介

什么是SpringCloud

SpringCloud的核心组件

SpringCloud的优势和应用场景

2. SpringBoot快速入门

SpringBoot的基本概念

创建第一个SpringBoot项目

SpringBoot的常用注解和配置

SpringBoot的配置文件

3. SpringCloud微服务架构搭建

微服务架构的基本概念

使用SpringCloud搭建简单的微服务

负载均衡与服务路由

4. SpringCloud配置中心

使用SpringCloud Config管理配置

配置中心的基本原理

实战：配置中心的使用与部署

5. SpringCloud服务容错与保护

服务容错的基本概念

断路器（Hystrix）的使用

服务熔断与降级策略

6. 实战案例：构建一个简单的电商微服务

案例背景与需求分析

分解服务模块

服务集成与测试

阅读免费教程