首页手记 SpringCloud应用项目实战入门教程

SpringCloud应用项目实战入门教程

标签：

Spring Cloud 微服务

概述

本文介绍了SpringCloud应用项目实战的全过程，涵盖了从环境搭建、服务发现与注册、配置中心使用到微服务架构设计和实战。详细讲解了Eureka服务注册与发现、Zuul服务网关、配置管理、服务容错与负载均衡等关键组件的使用方法。此外，还提供了构建与部署SpringCloud应用、测试与调试的指导。SpringCloud应用项目实战涵盖了微服务架构的方方面面，帮助开发者快速上手实战项目。

SpringCloud应用项目实战入门教程

SpringCloud简介与环境搭建

SpringCloud是什么

SpringCloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发。SpringCloud基于SpringBoot自动配置来简化分布式系统部署，将分布式系统中各个必需的组件进行整合，例如配置中心、服务发现、断路器、路由、微服务网关、分布式会话等。

开发环境搭建

Java版本：建议使用Java 8及以上版本。
SpringBoot版本：SpringCloud目前支持SpringBoot 2.x。
IDE：建议使用IntelliJ IDEA或者Eclipse。
Maven/Gradle：依赖管理工具。
Git：版本控制工具。

快速创建SpringBoot项目

使用Spring Initializr快速创建Spring Boot项目。选择Spring Boot版本和所需依赖，例如Spring Web, Spring Cloud Starter Config, Spring Cloud Starter Netflix Eureka等。

<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>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

服务发现与注册

Eureka服务注册与发现

Eureka是一个基于REST服务的服务注册和发现系统，它提供了服务注册与发现的功能。服务注册是指服务启动后向Eureka Server注册自己，服务发现是指服务启动后能够从Eureka Server获取注册的服务列表并调用相应服务。

配置Eureka Server

创建一个Eureka Server项目，添加依赖：

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

配置文件application.yml：

spring:
  application:
    name: eureka-server
server:
    port: 8761
eureka:
    instance:
        hostname: localhost
    client:
        register-with-eureka: false
        fetch-registry: false
        # not to query server node
        # serviceUrl:
        #     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类：

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

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

配置Eureka Client

创建一个Eureka Client项目，添加依赖：

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

配置文件application.yml：

spring:
    application:
        name: service-a
server:
    port: 8080
eureka:
    client:
        service-url:
            defaultZone: http://localhost:8761/eureka/

启动类：

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

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

Config配置中心使用

配置中心主要用于管理应用的配置文件。SpringCloud Config提供了配置服务器端（Config Server）和客户端（Config Client）。

创建配置服务器端

创建一个Spring Boot项目，添加依赖：

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

配置文件application.yml：

spring:
    application:
        name: config-server
server:
    port: 8888
spring:
    cloud:
        config:
            server:
                git:
                    uri: https://github.com/your-repo/config-repo
                    cloneOnStart: true

启动类：

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);
    }
}

创建配置客户端

修改ServiceAApplication项目，添加依赖：

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

配置文件bootstrap.yml：

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

远程配置文件

在配置服务器端的Git仓库中添加远程配置文件service-a.yml：

app:
    title: Hello World

Zuul服务网关介绍

Zuul是Netflix开源的一个基于Java的路由和服务的API Gateway，它可以帮助我们做统一的接口管理和服务路由处理，是微服务架构中常用的网关组件。

创建Zuul网关项目

创建一个Spring Boot项目，添加依赖：

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

配置文件application.yml：

spring:
    application:
        name: zuul-gateway
server:
    port: 9000
zuul:
    routes:
        service-a:
            path: /service-a/**
            url: http://localhost:8080/

启动类：

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 ZuulGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZuulGatewayApplication.class, args);
    }
}

实战微服务

微服务架构设计

微服务架构设计通常包括服务拆分、服务通信、服务发现等多种技术。服务拆分需要将业务拆分成多个独立的服务，每个服务负责不同的业务逻辑。服务通信可以通过RESTful API或者消息队列实现。服务发现可以使多个服务实例能够动态地发现并调用另一个服务实例。

实战：创建多个微服务模块

创建多个微服务模块，每个模块独立于其他模块运行。例如，创建两个微服务模块service-a和service-b，分别提供不同的功能。

创建`service-a`模块

添加依赖：

<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: service-a
server:
    port: 8080
eureka:
    client:
        service-url:
            defaultZone: http://localhost:8761/eureka/

启动类：

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

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

Controller：

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

@RestController
public class ServiceAController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from Service A";
    }
}

创建`service-b`模块

添加依赖：

<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: service-b
server:
    port: 8081
eureka:
    client:
        service-url:
            defaultZone: http://localhost:8761/eureka/

启动类：

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

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

Controller：

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

@RestController
public class ServiceBController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from Service B";
    }
}

微服务之间的通信

通过HTTP请求进行服务间通信，可以使用RestTemplate或者Feign等工具。

使用RestTemplate

在service-a模块中，通过RestTemplate调用service-b模块的接口。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ServiceAController {
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/call-service-b")
    public String callServiceB() {
        RestTemplate restTemplate = new RestTemplate();
        ServiceInstance instance = discoveryClient.getInstances("service-b").get(0);
        String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/hello";
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        return "Called Service B: " + response.getBody();
    }
}

使用Feign

在service-a模块中添加Feign依赖：

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

配置文件application.yml：

spring:
    application:
        name: service-a
eureka:
    client:
        service-url:
            defaultZone: http://localhost:8761/eureka/
feign:
    client:
        config:
            default:
                connectTimeout: 5000
                readTimeout: 5000

创建Feign客户端：

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

@FeignClient(name = "service-b")
public interface ServiceBClient {
    @RequestMapping("/hello")
    String hello();
}

使用Feign客户端：

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

@RestController
public class ServiceAController {
    @Autowired
    private ServiceBClient serviceBClient;

    @GetMapping("/call-service-b")
    public String callServiceB() {
        return serviceBClient.hello();
    }
}

服务容错与负载均衡

Ribbon负载均衡

Ribbon是Netflix开发的基于HTTP和TCP的服务发现工具，它是一个基于客户端的负载均衡器。Ribbon提供了一系列的策略来实现负载均衡，如轮询、随机、最少请求数等。

配置Ribbon

在service-a模块的配置文件中添加Ribbon配置：

spring:
    application:
        name: service-a
eureka:
    client:
        service-url:
            defaultZone: http://localhost:8761/eureka/
ribbon:
    eureka:
        enabled: true
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule

Controller：

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

@RestController
public class ServiceAController {
    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Autowired
    @LoadBalanced
    private RestTemplate restTemplate;

    @GetMapping("/call-service-b")
    public String callServiceB() {
        String serviceUrl = loadBalancerClient.choose("service-b").getUri().toString() + "/hello";
        return restTemplate.getForObject(serviceUrl, String.class);
    }
}

Hystrix服务容错

Hystrix是一个用于处理延迟和容错的开源库，主要用来隔离访问远程系统、服务或第三方库，防止出现级联失败。它以保护自己从这些失败中恢复的能力，实现了断路器、资源隔离以及补偿等功能。

配置Hystrix

在service-a模块中添加Hystrix依赖：

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

使用Hystrix命令：

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

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

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

    @GetMapping("/call-service-b-fallback")
    public String callServiceBFallback() {
        return "Service B is not available";
    }
}

使用Hystrix断路器：

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;

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

    @GetMapping("/call-service-b-hystrix")
    public String callServiceB() throws ExecutionException, InterruptedException {
        return new CommandServiceB().execute();
    }

    private class CommandServiceB extends HystrixCommand<String> {
        public CommandServiceB() {
            super(HystrixCommandGroupKey.Factory.asKey("ServiceBGroup"));
        }

        @Override
        protected String run() throws Exception {
            return restTemplate.getForObject("http://service-b/hello", String.class);
        }

        @Override
        protected String getFallback() {
            return "Service B is not available";
        }
    }
}

构建与部署SpringCloud应用

构建

使用Maven或Gradle构建项目。例如，使用Maven构建：

mvn clean package

生成的jar包位于target目录下。

部署

将生成的jar包部署到服务器上，并通过命令启动：

java -jar target/service-a.jar

使用Docker容器化部署

Docker可以将应用及其依赖打包到一个容器中，实现快速部署和隔离。

创建Dockerfile

FROM openjdk:8-jdk-alpine
VOLUME /tmp
COPY target/service-a.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

使用Docker构建镜像并运行：

docker build -t service-a .
docker run -d -p 8080:8080 --name service-a service-a

测试与调试

单元测试

单元测试是对软件中的最小可测试单元进行检查和验证。Spring Boot提供了@SpringBootTest注解，可以配合@Autowired注入需要测试的bean。

单元测试示例

创建一个单元测试类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class ServiceAControllerTest {
    @Autowired
    private ServiceAController serviceAController;

    @Test
    public void testHello() {
        String result = serviceAController.hello();
        assertEquals("Hello from Service A", result);
    }
}

集成测试

集成测试是对关联组件的测试，验证这些组件能否协同合作完成预定的功能。

集成测试示例

创建一个集成测试类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
public class ServiceAControllerIntegrationTest {
    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testHello() throws Exception {
        mockMvc.perform(get("/hello"))
            .andExpect(status().isOk())
            .andExpect(content().string("Hello from Service A"));
    }
}

日志与监控

日志记录可以帮助排查问题和了解程序运行情况。Spring Boot支持多种日志框架，如Logback、Log4j2等。

配置Logback

在src/main/resources目录下创建logback-spring.xml文件：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

监控可以帮助我们实时了解系统的运行状态，例如使用Spring Boot Actuator提供的监控端点。

配置Actuator

在pom.xml或build.gradle中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

配置文件application.yml：

spring:
    application:
        name: service-a
management:
    endpoints:
        web:
            exposure:
                include: "*"
    endpoint:
        health:
            show-details: always

访问http://localhost:8080/actuator可以查看监控信息。

通过以上步骤，你可以完成Spring Cloud应用项目的实战入门教程，了解如何搭建开发环境、配置服务发现、实现服务通信、使用负载均衡和容错机制、构建和部署应用，以及进行测试和监控。希望这篇教程能帮助你更好地理解和使用Spring Cloud。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

哆啦的时光机

手记
篇

粉丝

20

获赞与收藏

53

关注作者，订阅最新文章

相关文章推荐

Github点赞接近 70k 的Spring Cloud学习教程+实战项目推荐！牛批！

API网关才是大势所趋？SpringCloud Gateway保姆级入门教程

Github 上热门的 Spring Boot 项目实战推荐

SpringCloud+Vue微服务教程与实战(1)--全新的开始

Github标星25K+Star，SpringBoot实战电商项目mall出SpringCloud版本啦！

阅读免费教程

Spring Cloud Hystrix

15个小节 6089 120

后端通用面试教程

41个小节 30273 342

网络编程入门教程

20个小节 12461 235

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

SpringCloud应用项目实战入门教程

SpringCloud是什么

开发环境搭建

快速创建SpringBoot项目

Eureka服务注册与发现

配置Eureka Server

配置Eureka Client

Config配置中心使用

创建配置服务器端

创建配置客户端

远程配置文件

Zuul服务网关介绍

创建Zuul网关项目

微服务架构设计

实战：创建多个微服务模块

创建service-a模块

创建service-b模块

微服务之间的通信

使用RestTemplate

使用Feign

Ribbon负载均衡

配置Ribbon

Hystrix服务容错

配置Hystrix

构建

部署

使用Docker容器化部署

创建Dockerfile

单元测试

单元测试示例

集成测试

集成测试示例

日志与监控

配置Logback

配置Actuator

相关文章推荐

阅读免费教程

创建`service-a`模块

创建`service-b`模块