SpringCloud应用项目实战入门教程-原创手记-慕课网

概述

本文介绍了SpringCloud应用项目实战的入门教程，从SpringCloud的基础概念、优点和应用场景开始，详细讲解了开发环境的搭建和项目基础配置。接着深入探讨了服务注册与发现、微服务间通信、负载均衡与路由等关键技术，并通过实战项目展示了如何构建一个简单的微服务系统。

SpringCloud应用项目实战入门教程

引导章节：SpringCloud简介

SpringCloud是什么

Spring Cloud是一套基于Spring Boot的微服务开发框架，它提供了快速构建分布式系统的工具。Spring Cloud简化了服务治理、服务发现、配置管理、服务调用、负载均衡、断路器等一系列微服务相关的难题。通过Spring Cloud，开发人员可以专注于业务逻辑的实现，而无需过多关注微服务架构带来的复杂性。

SpringCloud的优点和应用场景

优点

快速集成：Spring Cloud提供了多种组件，帮助开发人员快速集成到微服务架构中。
开箱即用：许多组件提供了开箱即用的功能，无需复杂的配置。
组件丰富：Spring Cloud集成了多个成熟的服务组件，如Eureka、Ribbon、Hystrix等。
易用性：简化了服务治理、服务发现、配置管理等微服务的复杂性，使开发更加高效。

应用场景

分布式系统：适用于构建分布式系统，如电商平台、金融交易系统。
微服务架构：适用于微服务架构的应用场景，如服务拆分、服务化等。
云原生应用：适用于云原生应用的开发，支持在公有云、私有云、混合云等多种环境部署。

准备开发环境

环境要求

JDK：建议使用JDK 1.8及以上版本。
Spring Boot：建议使用最新版本。
IDE：推荐使用IntelliJ IDEA或Eclipse。
Maven：用于构建项目。
Git：用于版本控制（可选）。

创建Maven项目

在IDE中创建一个新的Maven项目，项目结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── application
│   │               └── Application.java
│   └── resources
│       ├── application.yml
│       └── log4j.properties
└── test
    └── java
        └── com
            └── example
                └── ApplicationTest.java

在pom.xml中添加Spring Boot和Spring Cloud相关依赖：

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

搭建SpringBoot项目基础

创建SpringBoot项目

使用Spring Initializr（如在Spring Tool Suite中）创建一个新的Spring Boot项目。选择以下依赖项：

Spring Web
Eureka Client

项目结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── application
│   │               └── Application.java
│   └── resources
│       ├── application.yml
│       └── log4j.properties
└── test
    └── java
        └── com
            └── example
                └── ApplicationTest.java

创建主应用程序类Application.java：

package com.example.application;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

添加SpringCloud相关依赖

在pom.xml中添加Spring Boot和Spring Cloud相关依赖：

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

项目结构和基本配置

项目结构已如上创建好，接下来配置基本的Spring Boot和Spring Cloud设置。

在application.yml中配置应用程序的基本设置：

spring:
  application:
    name: eureka-client # 应用名称
server:
  port: 8080
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址

服务注册与发现

介绍服务注册中心Eureka

Eureka是Netflix公司开源的一个基于REST的服务注册和发现框架。它提供了服务注册、服务发现、客户端负载均衡等功能。Spring Cloud集成了Eureka，可以方便地使用它来构建服务注册中心。

Eureka服务器端

Eureka服务器端运行在服务注册中心，负责维护服务实例的信息。服务提供者通过注册中心注册自身，服务消费者通过注册中心获取服务实例的信息，从而实现服务间的通信。

Eureka客户端

Eureka客户端运行在服务提供者和服务消费者中。服务提供者启动时会将自身注册到Eureka服务器，服务消费者从Eureka服务器获取服务实例的信息，基于获取到的信息进行服务调用。

实现服务注册与发现的代码示例

服务提供者

创建一个服务提供者项目，添加Eureka客户端依赖：

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

配置application.yml：

spring:
  application:
    name: eureka-client # 应用名称
server:
  port: 8081
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址

创建服务提供者接口HelloController.java：

package com.example.serviceprovider;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableEurekaClient
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from Eureka Client";
    }
}

服务消费者

创建一个服务消费者项目，添加Eureka客户端依赖：

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

配置application.yml：

spring:
  application:
    name: eureka-client # 应用名称
server:
  port: 8082
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址

创建服务消费者接口ConsumerController.java：

package com.example.serviceconsumer;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@EnableEurekaClient
public class ConsumerController {
    @RequestMapping("/consumer")
    public String callService() {
        RestTemplate restTemplate = new RestTemplate();
        String result = restTemplate.getForObject("http://EUREKA-CLIENT/hello", String.class);
        return result;
    }
}

测试服务注册与发现功能

启动Eureka服务器、服务提供者和消费者。访问http://localhost:8081/hello可以访问到服务提供者提供的服务，访问http://localhost:8082/consumer可以调用服务提供者的服务。

微服务间通信

RESTful API调用

RESTful API是一种面向资源的API设计风格，它使用HTTP协议的标准方法（如GET、POST、PUT、DELETE）来操作资源。在微服务架构中，服务提供者和消费者之间可以通过RESTful API进行通信。

示例代码

服务提供者提供一个RESTful API接口：

package com.example.serviceprovider;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableEurekaClient
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from Eureka Client";
    }
}

服务消费者通过RESTful API调用服务提供者：

package com.example.serviceconsumer;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@EnableEurekaClient
public class ConsumerController {
    @RequestMapping("/consumer")
    public String callService() {
        RestTemplate restTemplate = new RestTemplate();
        String result = restTemplate.getForObject("http://EUREKA-CLIENT/hello", String.class);
        return result;
    }
}

Feign客户端调用

Feign是由Netflix公司开源的一个声明式HTTP客户端，它使得编写HTTP客户端变得更加简单。Feign使用注解的方式定义HTTP请求，可以像调用本地方法一样调用远程服务。

示例代码

在服务消费者项目中添加Feign依赖：

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

启用Feign客户端：

package com.example.serviceconsumer;

import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.cloud.openfeign.FeignClient;

@RestController
@EnableEurekaClient
@EnableFeignClients
public class ConsumerController {
    @FeignClient(name = "EUREKA-CLIENT")
    public interface HelloClient {
        @RequestMapping("/hello")
        String hello();
    }

    @RequestMapping("/consumer")
    public String callService() {
        HelloClient client = new HelloClient();
        return client.hello();
    }
}

Hystrix断路器保护

Hystrix是一个用于处理分布式系统中的延迟和容错的库，它实现了断路器模式，防止下游服务的延迟影响整个系统。Hystrix可以在服务调用时提供实时监控和响应，确保系统的稳定运行。

示例代码

在服务消费者项目中添加Hystrix依赖：

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

配置Hystrix：

package com.example.serviceconsumer;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@EnableFeignClients
@EnableHystrix
@RestController
@EnableEurekaClient
public class ConsumerController {
    @FeignClient(name = "EUREKA-CLIENT", fallback = HelloClientFallback.class)
    public interface HelloClient {
        @RequestMapping("/hello")
        String hello();
    }

    @RequestMapping("/consumer")
    public String callService() {
        HelloClient client = new HelloClient();
        return client.hello();
    }
}

package com.example.serviceconsumer;

public class HelloClientFallback implements HelloClient {
    @Override
    public String hello() {
        return "Fallback response";
    }
}

负载均衡与路由

使用Ribbon实现客户端负载均衡

Ribbon是一个基于HTTP和TCP的客户端负载均衡器，它实现了多种负载均衡算法，如轮询、随机、权重等。Ribbon可以与Eureka配合使用，实现服务发现和负载均衡。

示例代码

在服务消费者项目中添加Ribbon依赖：

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

配置Ribbon：

spring:
  application:
    name: eureka-client # 应用名称
server:
  port: 8082
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址
ribbon:
  eureka:
    enabled: true # 使用Eureka进行服务发现

Zuul作为API网关的作用与使用

Zuul是Netflix开源的一个基于Java的路由和服务代理组件，它支持动态路由、过滤器、请求和响应时间等特性。Zuul可以在微服务架构中作为API网关，提供统一的入口，管理和路由请求到后端服务。

示例代码

在API网关项目中添加Zuul依赖：

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

启用Zuul网关：

package com.example.apigateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

配置Zuul路由：

spring:
  application:
    name: api-gateway # 应用名称
server:
  port: 8080
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址
zuul:
  routes:
    service-provider:
      path: /provider/**
      url: http://localhost:8081 # 服务提供者的URL

路由规则配置和使用示例

配置Zuul路由规则：

spring:
  application:
    name: api-gateway # 应用名称
server:
  port: 8080
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址
zuul:
  routes:
    service-provider:
      path: /provider/**
      url: http://localhost:8081 # 服务提供者的URL

访问http://localhost:8080/provider/hello可以调用服务提供者提供的服务。

实战项目：构建简单微服务系统

设计一个简单的微服务架构

设计一个简单的微服务架构，包括以下组件：

订单服务：提供订单相关的API。
商品服务：提供商品相关的API。
用户服务：提供用户相关的API。
API网关：作为入口，路由请求到后端服务。

实现各个微服务间的交互

订单服务

订单服务提供订单相关的API。创建一个新的Spring Boot项目，并添加以下依赖：

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

配置application.yml：

spring:
  application:
    name: order-service # 应用名称
server:
  port: 8083
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址

创建订单服务接口OrderController.java：

package com.example.orderservice;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableEurekaClient
public class OrderController {
    @RequestMapping("/order")
    public String getOrder() {
        return "Order from Order Service";
    }
}

商品服务

商品服务提供商品相关的API。创建一个新的Spring Boot项目，并添加以下依赖：

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

配置application.yml：

spring:
  application:
    name: product-service # 应用名称
server:
  port: 8084
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址

创建商品服务接口ProductController.java：

package com.example.productservice;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableEurekaClient
public class ProductController {
    @RequestMapping("/product")
    public String getProduct() {
        return "Product from Product Service";
    }
}

用户服务

用户服务提供用户相关的API。创建一个新的Spring Boot项目，并添加以下依赖：

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

配置application.yml：

spring:
  application:
    name: user-service # 应用名称
server:
  port: 8085
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址

创建用户服务接口UserController.java：

package com.example.userservice;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableEurekaClient
public class UserController {
    @RequestMapping("/user")
    public String getUser() {
        return "User from User Service";
    }
}

API网关

API网关作为入口，路由请求到后端服务。创建一个新的Spring Boot项目，并添加以下依赖：

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

配置application.yml：

spring:
  application:
    name: api-gateway # 应用名称
server:
  port: 8080
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # Eureka服务器地址
zuul:
  routes:
    order-service:
      path: /order/**
      url: http://localhost:8083 # 订单服务的URL
    product-service:
      path: /product/**
      url: http://localhost:8084 # 商品服务的URL
    user-service:
      path: /user/**
      url: http://localhost:8085 # 用户服务的URL

启用Zuul网关：

package com.example.apigateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

测试和部署项目

启动所有服务，确保Eureka服务器、订单服务、商品服务、用户服务和API网关都正常运行。访问以下URL进行测试：

http://localhost:8080/order （调用订单服务）
http://localhost:8080/product （调用商品服务）
http://localhost:8080/user （调用用户服务）

通过上述步骤，你可以构建一个简单的微服务系统，并通过API网关进行路由和负载均衡。