首页手记 SpringCloud项目开发入门教程

SpringCloud项目开发入门教程

标签：

Spring Cloud 微服务

概述

本文详细介绍了SpringCloud项目开发的入门教程，包括环境搭建、快速创建项目、服务提供者与服务消费者实现、服务注册与发现、服务网关配置及服务容错与负载均衡等内容。通过这些步骤，您可以轻松掌握SpringCloud项目开发的基本方法和技巧。

SpringCloud项目开发入门教程

SpringCloud简介与环境搭建

SpringCloud是什么

Spring Cloud 是一系列框架的有序集合，用于开发分布式（也称为微服务）系统的服务治理解决方案。它基于 Spring Boot 提供了一整套配置和服务，能够快速搭建分布式系统。

Spring Cloud 通过封装一些常见的分布式应用场景，并为这些应用场景提供了一套简单易用的编程模型，极大地简化了基于Spring Boot的应用开发。

开发环境搭建

开发 Spring Cloud 应用需要一个合适的开发环境。以下是一般推荐的环境配置：

Java开发环境：建议使用 JDK 8 或更高版本。配置环境变量以确保 Java 环境可被系统识别。
IDE：推荐使用 IntelliJ IDEA 或 Eclipse。
Spring Boot：使用 Spring Boot 版本 2.x。
Maven 或 Gradle：用于构建项目。
Spring Cloud 版本：建议使用 Hoxton 版本（例如：2020.0.3）。

快速创建SpringCloud项目

创建一个 Spring Cloud 项目可以通过 Spring Initializr 在线生成器来完成，也可以手动创建。以下是手动创建的步骤：

新建 Maven 项目，在 pom.xml 文件中添加以下依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.3</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<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>
</dependencies>

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

创建 application.yml 文件，配置 Spring Cloud 基本的信息：

server:
  port: 8080

spring:
  application:
  name: eureka-client

eureka:
 client:
  serviceUrl:
    defaultZone: http://localhost:8761/eureka/

创建主启动类：

package com.example.demo;

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

@SpringBootApplication
@EnableEurekaClient
public class DemoApplication {

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

运行主启动类，启动项目。

服务提供者与服务消费者

服务提供者的实现

服务提供者是提供服务的微服务，它将服务注册到服务注册中心，并根据请求提供相应的服务。以下是服务提供者的实现步骤：

创建服务提供者项目：
- 使用 Spring Initializr 创建新项目，添加 spring-cloud-starter-netflix-eureka-server 依赖。
- 修改 application.yml 文件，配置服务提供者的端口和服务名称：

server:
  port: 8761

spring:
 application:
  name: eureka-server

eureka:
 instance:
  hostName: localhost
  appname: eureka-server
 client:
  registerWithEureka: false
  fetchRegistry: false
  serviceUrl:
    defaultZone: http://localhost:8761/eureka/

创建主启动类：

package com.example.eurekaserver;

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

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

创建服务提供者控制器：

package com.example.serviceprovider;

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

@RestController
public class ServiceProviderController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Service Provider!";
    }
}

服务消费者的实现

服务消费者是消费服务的微服务，它通过服务注册中心查找服务提供者，并与之进行通信。以下是服务消费者的实现步骤：

创建服务消费者项目：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-netflix-eureka-client 和 spring-cloud-starter-openfeign 依赖。
- 修改 application.yml 文件，配置服务消费者的端口和服务名称：

server:
  port: 8081

spring:
 application:
  name: service-consumer

eureka:
 client:
  serviceUrl:
    defaultZone: http://localhost:8761/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.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ServiceConsumerApplication {

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

创建服务消费者实际消费逻辑：

package com.example.serviceconsumer;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "service-provider")
public interface ServiceConsumerClient {

    @GetMapping("/hello")
    String hello();
}

创建服务消费者的控制器：

package com.example.serviceconsumer;

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

@RestController
public class ServiceConsumerController {

    @Autowired
    private ServiceConsumerClient serviceConsumerClient;

    @GetMapping("/consumer")
    public String consumer() {
        return serviceConsumerClient.hello();
    }
}

服务调用示例

创建服务提供者的控制器：

package com.example.serviceprovider;

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

@RestController
public class ServiceProviderController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Service Provider!";
    }
}

启动服务提供者和消费者项目：
- 启动 EurekaServerApplication 项目，启动 Eureka 服务器。
- 启动 ServiceProviderApplication 项目，启动服务提供者。
- 启动 ServiceConsumerApplication 项目，启动服务消费者。
测试服务调用：
- 访问 http://localhost:8081/consumer，可以返回 "Hello, Service Provider!"。

服务注册与发现

Eureka服务注册与发现

Eureka 是 Netflix 开源的一个服务治理组件，主要用于提供服务注册和服务发现。以下是 Eureka 服务注册与发现的实现步骤：

创建服务提供者：
- 以上面的 ServiceProviderApplication 项目为例，添加 spring-cloud-starter-netflix-eureka-client 依赖到 pom.xml 文件，并在 application.yml 文件中配置服务提供者的注册信息：

spring:
 application:
  name: service-provider

eureka:
 client:
  serviceUrl:
    defaultZone: http://localhost:8761/eureka/

启动服务提供者：
- 启动 EurekaServerApplication 项目，启动 Eureka 服务器。
- 启动 ServiceProviderApplication 项目，启动服务提供者。
查看注册信息：
- 访问 http://localhost:8761，可以看到服务提供者已经注册到 Eureka 服务器。

Consul服务注册与发现

Consul 是 Hashicorp 开源的服务治理组件，提供服务发现、配置、健康检查等功能。以下是 Consul 服务注册与发现的实现步骤：

创建服务提供者：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-consul-discovery 依赖到 pom.xml 文件，并在 application.yml 文件中配置服务提供者的注册信息：

spring:
 application:
  name: service-provider

consul:
 client:
  service:
    register: true
    enabled: true
    port: 8080
    tags: []
    address: localhost
    host: localhost
    name: service-provider
    id: 1001
    tags:
      - provider

discovery:
 client:
  serviceUrl:
    defaultZone: http://localhost:8500/v1/kv/discovery

启动服务提供者：
- 启动 ServiceProviderApplication 项目，启动服务提供者。
查看注册信息：
- 访问 http://localhost:8500/ui，可以看到服务提供者已经注册到 Consul 服务器。

Zookeeper服务注册与发现

Zookeeper 是 Apache 开源的一个分布式协调服务，用于实现服务注册与发现。以下是 Zookeeper 服务注册与发现的实现步骤：

创建服务提供者：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-zookeeper-discovery 依赖到 pom.xml 文件，并在 application.yml 文件中配置服务提供者的注册信息：

spring:
 application:
  name: service-provider

zookeeper:
 client:
  connect-string: localhost:2181

启动服务提供者：
- 启动 ServiceProviderApplication 项目，启动服务提供者。
查看注册信息：
- 访问 http://localhost:8080/，可以看到服务提供者已经注册到 Zookeeper 服务器。

服务网关

Gateway的基本使用

Spring Cloud Gateway 是基于 Spring Cloud 和 Spring Boot 2.0 的微服务网关。它基于 Spring Framework 5.0，Project Reactor 3.1 以及 RouterFunction，为微服务提供统一、动态、可插拔、可组合的路由配置。

创建服务网关项目：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-gateway 依赖到 pom.xml 文件，并在 application.yml 文件中配置服务网关的基本信息：

server:
 port: 8082

spring:
 cloud:
  gateway:
  routes:
  - id: test_route
    uri: http://localhost:8081
    predicates:
    - Path=/test/**
    - Method=GET

启动服务网关项目：
- 启动 GatewayApplication 项目，启动服务网关。
测试路由规则：
- 访问 http://localhost:8082/test，可以看到请求被路由到 http://localhost:8081。

Zuul的基本使用

Zuul 是 Netflix 开源的一个服务网关，用于提供路由转发和过滤功能。以下是 Zuul 的基本使用步骤：

创建服务网关项目：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-netflix-zuul 依赖到 pom.xml 文件，并在 application.yml 文件中配置服务网关的基本信息：

server:
 port: 8083

spring:
 application:
 name: gateway-zuul

zuul:
 routes:
  test:
    path: /test/**
    url: http://localhost:8081

启动服务网关项目：
- 启动 GatewayZuulApplication 项目，启动服务网关。
测试路由规则：
- 访问 http://localhost:8083/test，可以看到请求被路由到 http://localhost:8081。

网关规则配置与路由

路由规则的配置可以使网关更加灵活和强大。以下是网关规则配置与路由的实现步骤：

配置路由规则：
- 在 application.yml 文件中，通过 routes 指定具体的路由规则：

spring:
 cloud:
  gateway:
  routes:
  - id: test_route
    uri: http://localhost:8081
    predicates:
    - Path=/test/**
    - Method=GET
    filters:
    - name: RewritePath
      args:
        regex: /test/**
        replacement: /rewrite/**

测试路由规则：
- 访问 http://localhost:8082/test，可以看到请求被路由到 http://localhost:8081/rewrite。

配置中心与服务配置

Config配置中心的使用

Spring Cloud Config 是一个配置中心，它能够使分布式系统中的外部配置进行集中式管理，从而让配置管理工作变得更加简单。以下是 Config 配置中心的使用步骤：

创建配置中心项目：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-config 和 spring-boot-starter-actuator 依赖到 pom.xml 文件，并在 application.yml 文件中配置服务配置的注册信息：

spring:
 application:
 name: config-server

cloud:
 config:
  server:
    git:
      uri: https://github.com/yourname/config-repo
      username: yourname
      password: yourpassword

启动配置中心项目：
- 启动 ConfigServerApplication 项目，启动配置中心。
测试配置中心：
- 访问 http://localhost:8888/config-client/default，可以看到配置信息。

配置刷新与动态配置

Spring Cloud Config 支持配置刷新，应用程序可以动态获取配置的变化。以下是配置刷新与动态配置的实现步骤：

创建服务消费者项目：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-config 和 spring-boot-starter-actuator 依赖到 pom.xml 文件，并在 bootstrap.yml 文件中配置配置中心的地址：

spring:
 application:
 name: service-client

cloud:
 config:
  uri: http://localhost:8888

启动服务消费者项目：
- 启动 ServiceClientApplication 项目，启动服务消费者。
测试配置刷新：
- 在配置中心的 config-repo 上修改配置，然后访问 http://localhost:8084/refresh，可以看到配置已经刷新。

配置中心的服务集成

配置中心可以集成到任何 Spring Boot 应用程序中，以便在运行时获取配置。以下是配置中心的服务集成步骤：

创建服务消费者项目：
- 使用 Spring Initializr 创建一个新项目，添加 spring-cloud-starter-config 和 spring-boot-starter-actuator 依赖到 pom.xml 文件，并在 bootstrap.yml 文件中配置配置中心的地址：

spring:
 application:
 name: service-client

cloud:
 config:
 uri: http://localhost:8888

启动服务消费者项目：
- 启动 ServiceClientApplication 项目，启动服务消费者。
测试服务集成：
- 在配置中心的 config-repo 上修改配置，然后访问 http://localhost:8084/config，可以看到配置已经被集成。

服务容错与负载均衡

Hystrix服务容错处理

Hystrix 是 Netflix 开源的一个服务容错组件，用于提供断路器和线程隔离等功能。以下是 Hystrix 服务容错处理的实现步骤：

添加 Hystrix 依赖：
- 在 pom.xml 文件中添加 spring-cloud-starter-netflix-hystrix 依赖：

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

创建服务提供者项目：
- 在服务提供者的控制器中，使用 @HystrixCommand 注解来处理服务容错：

package com.example.serviceprovider;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceProviderController {

    @HystrixCommand(fallbackMethod = "fallback")
    @GetMapping("/hello")
    public String hello() {
        // 模拟服务异常
        throw new RuntimeException("Service Error");
    }

    public String fallback() {
        return "Fallback";
    }
}

启动服务提供者项目：
- 启动 ServiceProviderApplication 项目，启动服务提供者。
测试服务容错：
- 访问 http://localhost:8080/hello，可以看到返回 "Fallback"。

Ribbon负载均衡原理与使用

Ribbon 是 Netflix 开源的一个基于 HTTP 和 TCP 的客户端负载均衡器，它通过内置的负载均衡算法实现服务调用的均衡。以下是 Ribbon 负载均衡的原理与使用步骤：

添加 Ribbon 依赖：
- 在 pom.xml 文件中添加 spring-cloud-starter-netflix-ribbon 依赖：

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

创建服务消费者项目：
- 在服务消费者的控制器中，使用 @LoadBalanced 注解来配置 Ribbon 负载均衡：

package com.example.serviceconsumer;

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

@RestController
@RibbonClient(name = "service-provider", configuration = Config.class)
public class ServiceConsumerController {

    @Autowired
    private RestTemplate restTemplate;

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

自定义负载均衡配置：
- 创建配置类 Config，配置 Ribbon 的负载均衡策略：

package com.example.serviceconsumer;

import com.netflix.loadbalancer.RoundRobinRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Config {

    @Bean
    public RoundRobinRule roundRobinRule() {
        return new RoundRobinRule();
    }
}

启动服务消费者项目：
- 启动 ServiceConsumerApplication 项目，启动服务消费者。
测试服务调用：
- 访问 http://localhost:8081/consumer，可以看到服务调用被 Ribbon 均衡处理。

服务容错与负载均衡的实战案例

假设你有一个服务提供者集群，每个服务提供者可以处理不同的请求。以下是服务容错与负载均衡的实战案例：

创建多个服务提供者项目：
- 创建两个服务提供者项目，分别使用不同的端口，例如 ServiceProvider1Application 和 ServiceProvider2Application。

# ServiceProvider1Application
server:
 port: 8080

# ServiceProvider2Application
server:
 port: 8082

启动多个服务提供者项目：
- 启动 ServiceProvider1Application 和 ServiceProvider2Application 项目。
配置服务消费者：
- 在服务消费者的控制器中，使用 @LoadBalanced 注解配置 Ribbon 负载均衡：

package com.example.serviceconsumer;

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

@RestController
@RibbonClient(name = "service-provider", configuration = Config.class)
public class ServiceConsumerController {

    @Autowired
    private RestTemplate restTemplate;

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

测试服务调用：
- 访问 http://localhost:8081/consumer，可以看到服务调用被 Ribbon 均衡处理到不同的服务提供者。

通过以上步骤，你可以实现一个简单的服务容错与负载均衡的实战案例。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

喵喵时光机

手记
篇

粉丝

9

获赞与收藏

108

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6169 121

后端通用面试教程

41个小节 30787 345

网络编程入门教程

20个小节 12720 239

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空