首页手记 SpringCloud项目实战：入门到初级应用教程

SpringCloud项目实战：入门到初级应用教程

标签：

Spring Cloud 微服务

概述

本文将详细介绍如何从零开始搭建并应用SpringCloud项目，涵盖环境配置、服务注册与发现、路由与负载均衡等核心概念。通过实战案例，你将学会如何构建一个简单的微服务系统，包括服务注册中心、配置中心、API网关和微服务的创建与部署。SpringCloud项目实战不仅涉及理论知识，还包含详细的代码示例和部署步骤，帮助你快速上手微服务开发。

SpringCloud项目实战：入门到初级应用教程

SpringCloud简介与环境搭建

SpringCloud是什么

SpringCloud是一个基于Spring Boot的微服务框架。它提供了多种针对微服务的解决方案，如服务注册与发现、配置管理、服务网关、负载均衡、断路器、分布式事务等。SpringCloud的核心组件包括Eureka、Ribbon、Feign、Zuul、Hystrix等。

必要的开发环境配置

为了构建SpringCloud项目，你需要先安装并配置好必要的开发环境。以下是你需要的软件及其配置：

Java JDK：建议使用Java 8或更高版本。
Maven：用于构建Java项目的依赖管理工具。
IDE：推荐使用IntelliJ IDEA或Eclipse。
Git：版本控制系统。
Spring Boot：基于Spring的轻量级框架。

创建第一个SpringCloud项目

创建Spring Boot项目

打开你的IDE，创建一个新的Spring Boot项目。
选择Spring Initializr（Spring初始化器）。
在Project中选择Maven project（Maven项目）。
在Language中选择Java。
在Spring Boot版本中选择最新的稳定版本。
添加以下依赖：
- spring-boot-starter-web：用于创建Web应用程序。
- spring-cloud-starter-netflix-eureka-server：用于创建Eureka服务注册中心。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── eureka
│   │               ├── EurekaApplication.java
│   │               └── EurekaApplicationTests.java
│   └── resources
│       └── application.properties

编写Eureka服务注册中心代码

在EurekaApplication.java中，定义一个Spring Boot主类，启用Eureka服务注册中心。

package com.example.eureka;

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

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {

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

}

配置Eureka服务注册中心

在application.properties中，配置Eureka服务注册中心的相关参数。

spring.application.name=eureka-server
server.port=8761

eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

现在你可以启动你的Eureka服务注册中心，并通过浏览器访问http://localhost:8761，查看服务注册中心的状态。

服务发现与配置中心

服务注册与发现机制

服务注册与发现机制是微服务架构中非常重要的一个概念。在微服务架构中，每个微服务实例运行在不同的进程中，并且可以动态地启动或停止。服务注册与发现机制允许微服务实例注册到服务注册中心，并让其他微服务发现和调用它们。服务注册中心通常使用心跳机制来检测服务实例的状态，并在服务实例不可用时自动将它们从服务列表中移除。

使用Eureka构建服务注册中心

在前面的章节中，我们已经使用Spring Cloud创建了一个Eureka服务注册中心。接下来，我们将创建一个Spring Boot微服务，并将其注册到Eureka服务注册中心。

创建Spring Boot微服务

在IDE中，创建一个新的Spring Boot项目。
选择Spring Initializr。
在Project中选择Maven project。
在Language中选择Java。
在Spring Boot版本中选择最新的稳定版本。
添加以下依赖：
- spring-boot-starter-web：用于创建Web应用程序。
- spring-cloud-starter-netflix-eureka-client：用于注册微服务到Eureka服务注册中心。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── service
│   │               ├── ServiceApplication.java
│   │               ├── ServiceController.java
│   │               └── ServiceApplicationTests.java
│   └── resources
│       └── application.properties

编写微服务代码

在ServiceApplication.java中，定义一个Spring Boot主类，启用Eureka客户端。

package com.example.service;

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

@SpringBootApplication
@EnableEurekaClient
public class ServiceApplication {

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

}

在ServiceController.java中，定义一个简单的REST控制器。

package com.example.service;

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

@RestController
public class ServiceController {

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

}

配置微服务

在application.properties中，配置微服务的相关参数。

spring.application.name=service
server.port=8080

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

现在你可以启动你的微服务，并通过浏览器访问http://localhost:8761，查看服务注册中心的状态，确认微服务已经成功注册到服务注册中心。

使用Config Server构建配置中心

在微服务架构中，配置中心用于集中管理微服务的配置信息，如数据库连接字符串、应用程序上下文等。Spring Cloud Config可以让你以Git仓库或者其他存储方式来存储配置文件，这样可以方便地管理不同的环境配置。

创建Spring Boot Config Server

在IDE中，创建一个新的Spring Boot项目。
选择Spring Initializr。
在Project中选择Maven project。
在Language中选择Java。
在Spring Boot版本中选择最新的稳定版本。
添加以下依赖：
- spring-cloud-starter-netflix-eureka-client：用于注册Config Server到Eureka服务注册中心。
- spring-cloud-config-server：用于构建配置中心。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── configserver
│   │               ├── ConfigServerApplication.java
│   │               └── ConfigServerApplicationTests.java
│   └── resources
│       └── application.properties

编写Config Server代码

在ConfigServerApplication.java中，定义一个Spring Boot主类，启用Config Server。

package com.example.configserver;

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

@SpringBootApplication
@EnableConfigServer
@EnableEurekaClient
public class ConfigServerApplication {

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

}

配置Config Server

在application.properties中，配置Config Server的相关参数。

spring.application.name=config-server
server.port=8888

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
spring.cloud.config.server.git.uri=https://github.com/yourusername/config-repo

现在你可以启动你的Config Server，并通过浏览器访问http://localhost:8888/yourapp/default，获取配置文件内容。

路由与负载均衡

路由与负载均衡的重要性

在微服务架构中，服务之间通过HTTP等协议进行通信，而路由与负载均衡是实现这些通信的关键技术。路由可以将客户端请求导向合适的服务实例，而负载均衡可以将请求均匀地分发到多个服务实例，避免单个服务实例过载，提高系统的可用性和响应速度。

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

Ribbon是Netflix开源的一个客户端负载均衡器，它可以通过配置不同的负载均衡策略来实现服务的请求分发。

创建Spring Boot客户端项目

在IDE中，创建一个新的Spring Boot项目。
选择Spring Initializr。
在Project中选择Maven project。
在Language中选择Java。
在Spring Boot版本中选择最新的稳定版本。
添加以下依赖：
- spring-cloud-starter-netflix-eureka-client：用于注册客户端到Eureka服务注册中心。
- spring-cloud-starter-netflix-ribbon：用于实现客户端负载均衡。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── ribbon
│   │               ├── RibbonApplication.java
│   │               └── RibbonController.java
│   └── resources
│       └── application.properties

编写客户端代码

在RibbonApplication.java中，定义一个Spring Boot主类，启用Eureka客户端和Ribbon。

package com.example.ribbon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "service")
@EnableFeignClients
public class RibbonApplication {

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

}

在RibbonController.java中，定义一个简单的REST控制器，使用Ribbon调用服务。

package com.example.ribbon;

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

@RestController
public class RibbonController {

    @Autowired
    private ServiceClient serviceClient;

    @GetMapping("/ribbon")
    public String ribbon() {
        return serviceClient.hello();
    }

}

在ServiceClient.java中，定义一个Feign客户端，用于调用服务。

package com.example.ribbon;

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

@FeignClient(name = "service")
public interface ServiceClient {

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

}

配置客户端

在application.properties中，配置客户端的相关参数。

spring.application.name=ribbon-client
server.port=8081

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

现在你可以启动你的客户端，并通过浏览器访问http://localhost:8081/ribbon，查看客户端调用服务的结果。

使用Zuul实现API网关与路由

Zuul是Netflix开源的一个路由和过滤器系统，它可以用作微服务架构中的API网关，负责路由和过滤请求。

创建Spring Boot API网关项目

在IDE中，创建一个新的Spring Boot项目。
选择Spring Initializr。
在Project中选择Maven project。
在Language中选择Java。
在Spring Boot版本中选择最新的稳定版本。
添加以下依赖：
- spring-cloud-starter-netflix-eureka-client：用于注册API网关到Eureka服务注册中心。
- spring-cloud-starter-netflix-zuul：用于实现API网关。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── api
│   │               ├── ApiGatewayApplication.java
│   │               └── ApiGatewayApplicationTests.java
│   └── resources
│       └── application.properties

编写API网关代码

在ApiGatewayApplication.java中，定义一个Spring Boot主类，启用Eureka客户端和Zuul。

package com.example.api;

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

}

配置API网关

在application.properties中，配置API网关的相关参数。

spring.application.name=api-gateway
server.port=8082

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

zuul.routes.service.path=/service/**
zuul.routes.service.sensitive=true
zuul.routes.service.service-id=service

现在你可以启动你的API网关，并通过浏览器访问http://localhost:8082/service/hello，查看API网关调用服务的结果。

服务间通信与断路器

服务间通信的基本概念

服务间通信是指微服务之间通过网络协议进行数据交换和信息传递的过程。常见的服务间通信方式包括HTTP REST、RPC（远程过程调用）、gRPC等。HTTP REST是最常用的通信方式，也是微服务架构中最普遍的方式。

使用Feign简化服务间接口调用

Feign是一个声明式的Web服务客户端，它使得编写Web服务客户端变得更加简单。Feign允许开发者定义接口而不用编写实现，然后Feign在运行时会解析这些接口，并生成实现。Feign使用的是JAX-RS和Spring MVC的注解来解析HTTP请求。

创建Spring Boot客户端项目（继续使用Ribbon项目）

在ServiceClient.java中，定义一个Feign客户端，用于调用服务。

package com.example.ribbon;

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

@FeignClient(name = "service")
public interface ServiceClient {

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

}

配置客户端

在application.properties中，配置客户端的相关参数。

spring.application.name=ribbon-client
server.port=8081

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

现在你可以启动你的客户端，并通过浏览器访问http://localhost:8081/ribbon，查看客户端调用服务的结果。

使用Hystrix实现服务容错与断路器

Hystrix是Netflix开源的一个延迟和容错库，用于处理分布式系统中的故障。Hystrix通过在服务之间添加熔断器，防止服务之间的超时异常相互影响，从而避免导致整个系统崩溃。

创建Spring Boot客户端项目（继续使用Ribbon项目）

在RibbonController.java中，使用Hystrix实现服务容错。

package com.example.ribbon;

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

import java.util.concurrent.ExecutionException;

@RestController
public class RibbonController {

    @Autowired
    private ServiceClient serviceClient;

    @GetMapping("/ribbon")
    public String ribbon() {
        return serviceClient.hello();
    }

    @GetMapping("/hystrix")
    public String hystrix() throws ExecutionException, InterruptedException {
        return new HystrixCommand<String>(HystrixCommandGroupKey.Factory.asKey("Default")) {
            @Override
            protected String run() throws Exception {
                return serviceClient.hello();
            }
        }.execute();
    }

}

配置客户端

在application.properties中，配置客户端的相关参数。

spring.application.name=ribbon-client
server.port=8081

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

现在你可以启动你的客户端，并通过浏览器访问http://localhost:8081/hystrix，查看客户端调用服务的结果。

分布式事务管理

分布式事务的基本概念

分布式事务是指在分布式系统中，多个节点参与的事务处理过程。分布式事务保证了事务的ACID特性（原子性、一致性、隔离性、持久性），即使在系统中存在多个节点，也需要保证事务的一致性。

使用SpringCloud的Seata实现分布式事务管理

Seata是一个开源的分布式事务解决方案，它通过一个中心化的事务协调器（TransactionManager），来管理多个分支事务（即本地事务），并保证所有分支的事务最终能够正确地提交或回滚。

创建Spring Boot项目

在IDE中，创建一个新的Spring Boot项目。
选择Spring Initializr。
在Project中选择Maven project。
在Language中选择Java。
在Spring Boot版本中选择最新的稳定版本。
添加以下依赖：
- spring-boot-starter-jdbc：用于数据库连接。
- spring-boot-starter-web：用于创建Web应用程序。
- spring-cloud-starter-openfeign：用于服务间接口调用。
- seata-spring-boot-starter：用于分布式事务管理。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── seata
│   │               ├── SeataApplication.java
│   │               ├── SeataApplicationTests.java
│   │               └── SeataController.java
│   └── resources
│       └── application.properties

编写Seata代码

在SeataApplication.java中，定义一个Spring Boot主类，启用Seata。

package com.example.seata;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
public class SeataApplication {

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

}

在SeataController.java中，定义一个简单的REST控制器，使用Seata管理分布式事务。

package com.example.seata;

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

@RestController
public class SeataController {

    @Autowired
    private SeataService seataService;

    @GetMapping("/seata")
    public String seata() {
        return seataService.hello();
    }

}

在SeataService.java中，定义一个服务，使用Seata管理分布式事务。

package com.example.seata;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import seata.core.context.RootContext;

@Service
public class SeataService {

    @Autowired
    private SeataRepository seataRepository;

    @Transactional
    public String hello() {
        seataRepository.insert();
        RootContext.setId("123456"); // 设置全局事务ID
        return "Hello, Seata!";
    }

}

在SeataRepository.java中，定义一个数据访问对象，使用Seata管理分布式事务。

package com.example.seata;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class SeataRepository {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void insert() {
        jdbcTemplate.execute("INSERT INTO seata_table (name) VALUES ('Seata')");
    }

}

配置Seata

在application.properties中，配置Seata的相关参数。

spring.application.name=seata-client
server.port=8083

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

seata.service.vgroup-mapping.default=my_test_tx_group
seata.service.load-balance=ROUND_ROBIN
seata.service.enable-dbt=TRUE
seata.service.transport.type=sync
seata.service.transport.server=NIO
seata.service.transport.socket-nio.server-others=enableclientprefetch=true;threadpool=4
seata.service.transport.socket-nio.server=tcpport=8091;enableclientprefetch=true;threadpool=4
seata.service.transport.socket-nio.client=tcpSndBuf=1048576;tcpRcvBuf=1048576;enableclientprefetch=true
seata.service.registry.type=nacos
seata.service.registry.nacos.address=localhost:8848
seata.service.registry.nacos.namespace=default
seata.service.registry.nacos.username=nacos
seata.service.registry.nacos.password=nacos
seata.service.config.type=nacos
seata.service.config.nacos.address=localhost:8848
seata.service.config.nacos.namespace=default
seata.service.config.nacos.username=nacos
seata.service.config.nacos.password=nacos

现在你可以启动你的Seata客户端，并通过浏览器访问http://localhost:8083/seata，查看Seata管理分布式事务的结果。

实战案例：构建一个简单的微服务系统

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

我们将设计一个简单的微服务系统，包含以下组件：

Eureka服务注册中心：用于注册和发现微服务实例。
Config Server配置中心：用于集中管理微服务的配置文件。
API网关：用于路由和过滤请求，实现客户端与微服务之间的通信。
微服务：提供具体的业务逻辑。
客户端：通过API网关调用微服务。

实现并部署微服务系统

创建Eureka服务注册中心

使用前面创建的Eureka服务注册中心项目，并将其启动。

创建Config Server配置中心

使用前面创建的Config Server配置中心项目，并将其启动。

创建微服务

创建一个新的Spring Boot项目，使用spring-cloud-starter-netflix-eureka-client和spring-boot-starter-web依赖。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── service
│   │               ├── ServiceApplication.java
│   │               ├── ServiceController.java
│   │               └── ServiceApplicationTests.java
│   └── resources
│       └── application.properties

在ServiceApplication.java中，定义一个Spring Boot主类，启用Eureka客户端和Web。

package com.example.service;

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

@SpringBootApplication
@EnableEurekaClient
public class ServiceApplication {

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

}

在ServiceController.java中，定义一个简单的REST控制器。

package com.example.service;

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

@RestController
public class ServiceController {

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

}

在application.properties中，配置微服务的相关参数。

spring.application.name=service
server.port=8080

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

创建API网关

创建一个新的Spring Boot项目，使用spring-cloud-starter-netflix-eureka-client和spring-cloud-starter-netflix-zuul依赖。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── api
│   │               ├── ApiGatewayApplication.java
│   │               └── ApiGatewayApplicationTests.java
│   └── resources
│       └── application.properties

在ApiGatewayApplication.java中，定义一个Spring Boot主类，启用Eureka客户端和Zuul。

package com.example.api;

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

}

在application.properties中，配置API网关的相关参数。

spring.application.name=api-gateway
server.port=8082

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

zuul.routes.service.path=/service/**
zuul.routes.service.sensitive=true
zuul.routes.service.service-id=service

创建客户端

创建一个新的Spring Boot项目，使用spring-cloud-starter-netflix-eureka-client和spring-cloud-starter-netflix-ribbon依赖。

示例项目结构：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── ribbon
│   │               ├── RibbonApplication.java
│   │               └── RibbonController.java
│   └── resources
│       └── application.properties

在RibbonApplication.java中，定义一个Spring Boot主类，启用Eureka客户端和Ribbon。

package com.example.ribbon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "service")
@EnableFeignClients
public class RibbonApplication {

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

}

在RibbonController.java中，定义一个简单的REST控制器，使用Ribbon调用服务。

package com.example.ribbon;

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

@RestController
public class RibbonController {

    @Autowired
    private ServiceClient serviceClient;

    @GetMapping("/ribbon")
    public String ribbon() {
        return serviceClient.hello();
    }

}

在ServiceClient.java中，定义一个Feign客户端，用于调用服务。

package com.example.ribbon;

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

@FeignClient(name = "service")
public interface ServiceClient {

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

}

在application.properties中，配置客户端的相关参数。

spring.application.name=ribbon-client
server.port=8081

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

feign.client.config.default.connect-timeout=5000
feign.client.config.default.read-timeout=5000

测试与验证微服务系统

启动Eureka服务注册中心。
启动Config Server配置中心。
启动微服务。
启动API网关。
启动客户端。

通过浏览器访问http://localhost:8082/service/hello，查看API网关调用微服务的结果。

通过浏览器访问http://localhost:8081/ribbon，查看客户端调用微服务的结果。

通过浏览器访问http://localhost:8761，查看服务注册中心的状态，确认微服务已经成功注册到服务注册中心。

通过浏览器访问http://localhost:8888/myapp/default，查看Config Server配置中心的状态，确认配置文件已经成功加载。

通过上述步骤，我们成功地构建了一个简单的微服务系统。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕婉清6462132

手记
篇

粉丝

14

获赞与收藏

86

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6171 121

后端通用面试教程

41个小节 30809 345

网络编程入门教程

20个小节 12721 239

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

SpringCloud项目实战：入门到初级应用教程

SpringCloud是什么

必要的开发环境配置

创建第一个SpringCloud项目

创建Spring Boot项目

编写Eureka服务注册中心代码

配置Eureka服务注册中心

服务注册与发现机制

使用Eureka构建服务注册中心

创建Spring Boot微服务

编写微服务代码

配置微服务

使用Config Server构建配置中心

创建Spring Boot Config Server

编写Config Server代码

配置Config Server

路由与负载均衡的重要性

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

创建Spring Boot客户端项目

编写客户端代码

配置客户端

使用Zuul实现API网关与路由

创建Spring Boot API网关项目

编写API网关代码

配置API网关

服务间通信的基本概念

使用Feign简化服务间接口调用

创建Spring Boot客户端项目（继续使用Ribbon项目）

配置客户端

使用Hystrix实现服务容错与断路器

创建Spring Boot客户端项目（继续使用Ribbon项目）

配置客户端

分布式事务的基本概念

使用SpringCloud的Seata实现分布式事务管理

创建Spring Boot项目

编写Seata代码

配置Seata

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

实现并部署微服务系统

创建Eureka服务注册中心

创建Config Server配置中心

创建微服务

创建API网关

创建客户端

测试与验证微服务系统

阅读免费教程