首页手记微服务入门教程：轻松掌握微服务架构

微服务入门教程：轻松掌握微服务架构

标签：

微服务

概述

微服务是一种将应用程序拆分为多个小型独立服务的架构风格，每个服务专注于单一功能且可以独立部署和扩展。这种架构提高了应用程序的可维护性、可扩展性和灵活性。本文详细介绍了微服务的基本概念、架构优势以及与传统单体应用的区别，并探讨了微服务的开发实践、监控维护和安全性等问题。

微服务简介

微服务是一种将应用程序构建为多个小型、独立且模块化服务的架构风格。每个微服务都专注于单一功能，并且可以独立部署、升级和扩展。这种架构风格有助于提高应用程序的可维护性、可扩展性和灵活性。

微服务的基本概念

微服务架构将一个应用程序分解为多个独立的服务。每个服务运行在自己的进程中，并且拥有自己的数据存储。这些服务通过轻量级的通信机制（如HTTP REST API、消息队列等）来彼此协作。这种架构使得开发和维护整个应用程序变得更加简单，因为每个服务都可以独立部署和更新，而不会影响到其他的服务。

微服务与传统单体应用的区别

传统单体应用通常是一个大型的、单一的代码库，所有功能都在同一个进程中运行。相比之下，微服务架构将应用程序拆分为多个独立的服务，每个服务都专注于完成一个特定的功能。以下是两者之间的一些主要区别：

代码库和部署：
- 单体应用：在一个大型的代码库中，所有功能都紧密集成在一起。这种应用通常部署为一个单一的可执行文件。
- 微服务：每个服务都有自己的代码库和部署流程。每个服务可以独立部署，如图1-1所示。
可扩展性和灵活性：
- 单体应用：扩展一个单体应用可能需要重新部署整个应用程序。
- 微服务：可以独立扩展每个服务，这使得应用程序更加灵活和可扩展。
团队协作：
- 单体应用：通常由一个团队维护，团队成员需要熟悉整个应用程序。
- 微服务：可以将服务分配给不同的团队，每个团队专注于特定的服务。这使得团队能够更专注于特定功能，提高了团队成员的专注度。

微服务架构的优势

独立部署：

每个微服务都可以独立开发和部署，这使得开发和维护过程更加高效。例如，一个服务出现问题时，其他服务可以不受影响。

示例代码：假设有一个用户服务和订单服务。

// 用户服务
@SpringBootApplication
public class UserServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(UserServiceApplication.class, args);
 }
}

// 订单服务
@SpringBootApplication
public class OrderServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(OrderServiceApplication.class, args);
 }
}

可扩展性：
- 微服务可以独立扩展，例如可以根据需要为每个服务添加更多的服务器资源。
- 示例代码：使用Spring Boot配置为每个微服务添加更多的服务器资源。
```
# 用户服务配置
server:
port: 8081
max-http-header-size: 16KB
max-threads: 200

# 订单服务配置
server:
port: 8082
max-http-header-size: 16KB
max-threads: 200
```

灵活性：

微服务架构使得团队能够快速迭代和开发新的功能，因为每个服务可以独立部署。

示例代码：假设用户服务和订单服务分别有不同的团队来开发和维护。

// 用户服务团队
public class UserServiceTeam {
 public void developFeature(String feature) {
     // 开发新功能
 }
}

// 订单服务团队
public class OrderServiceTeam {
 public void developFeature(String feature) {
     // 开发新功能
 }
}

可维护性：

独立的服务可以更容易地进行维护和调试，因为开发人员不需要理解整个应用程序的复杂性。

示例代码：假设需要为用户服务添加一个新的功能。

// 用户服务中添加新功能
@RestController
public class UserController {
 @PostMapping("/users/new-feature")
 public ResponseEntity<String> newUserFeature(@RequestBody UserRequest request) {
     // 处理请求
     return new ResponseEntity<>("Feature Added", HttpStatus.CREATED);
 }
}

容错性：
- 由于每个服务都是独立运行的，因此一个服务的故障不会影响到其他服务，提高了整个系统的容错能力。
- 示例代码：使用Spring Boot配置服务的容错性。
```
# 用户服务容错配置
spring:
application:
 name: user-service
sleuth:
 sampler:
   probability: 1.0
```

技术支持多样性：

由于每个服务可以独立选择技术栈，因此可以使用最适合特定功能的技术。例如，某些服务可能使用Java，而其他服务可能使用JavaScript或Go语言。

示例代码：使用不同的编程语言和技术栈构建不同的服务。

// 用户服务（Java）
@SpringBootApplication
public class UserServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(UserServiceApplication.class, args);
 }
}

// 订单服务（JavaScript）
// 使用Node.js
const express = require('express');
const app = express();
app.post('/orders', (req, res) => {
 // 处理订单请求
 res.send('Order Processed');
});
app.listen(3000, () => {
 console.log('Order service running on port 3000');
});

微服务设计原则

微服务架构需要遵循一些设计原则，以确保服务的独立性和可管理性。这些原则包括如何进行合理的服务拆分、服务之间的通信方式、服务治理的基本概念等。

如何进行合理的服务拆分

合理的服务拆分是微服务架构成功的关键。拆分服务时需要考虑以下几个方面：

业务功能模块化：

将应用程序拆分为独立的业务功能模块。例如，电子商务网站可以拆分为用户管理、订单处理、库存管理等服务。

示例代码：拆分电子商务网站为不同的服务。

// 用户管理服务
@SpringBootApplication
public class UserServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(UserServiceApplication.class, args);
 }
}

// 订单处理服务
@SpringBootApplication
public class OrderServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(OrderServiceApplication.class, args);
 }
}

// 库存管理服务
@SpringBootApplication
public class InventoryServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(InventoryServiceApplication.class, args);
 }
}

独立性：
- 每个服务都应独立运行，且应具有独立的数据存储。例如，用户服务的数据可以存储在MySQL数据库中，而订单服务的数据可以存储在MongoDB数据库中。
- 示例代码：配置用户服务和订单服务使用不同的数据库。
```
# 用户服务配置
spring:
datasource:
 url: jdbc:mysql://localhost:3306/userdb
 username: root
 password: root

# 订单服务配置
spring:
datasource:
 url: jdbc:mysql://localhost:3306/orderdb
 username: root
 password: root
```

服务的粒度：

服务应该足够小，以便能够独立部署和扩展，但又足够大，以避免服务的数量过多。通常，每个服务都应该包含一个或几个相关的业务功能。

示例代码：配置服务的粒度。

// 用户服务
@SpringBootApplication
public class UserServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(UserServiceApplication.class, args);
 }
}

// 订单服务
@SpringBootApplication
public class OrderServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(OrderServiceApplication.class, args);
 }
}

服务之间的通信方式

在微服务架构中，服务之间的通信通常使用HTTP REST API或消息队列。这两种通信方式都有其优缺点。

HTTP REST API：
- 优点：易于实现，使用广泛，支持多种编程语言。
- 缺点：对于长链路和高延迟的场景支持较差，因为每个请求都需要等待响应。
- 示例代码：使用Spring Boot实现一个简单的REST API。
```
@RestController
public class UserController {
 @GetMapping("/users")
 public List<User> getUsers() {
     // 获取用户列表
     return userService.getUsers();
 }
}
```

消息队列：

优点：可以在服务之间异步传递消息，支持高并发和高可用性。
缺点：实现复杂，需要考虑消息的顺序、持久化和重试机制。

示例代码：使用RabbitMQ实现异步消息传递。

@Configuration
public class RabbitMQConfig {
 @Bean
 public Queue orderQueue() {
     return new Queue("orderQueue", true);
 }

 @Bean
 public TopicExchange orderExchange() {
     return new TopicExchange("orderExchange");
 }

 @Bean
 public Binding orderBinding(Queue orderQueue, TopicExchange orderExchange) {
     return BindingBuilder.bind(orderQueue).to(orderExchange).with("order.*");
 }
}

@Component
public class OrderProducer {
 @Autowired
 private RabbitTemplate rabbitTemplate;

 public void sendOrderMessage(String message) {
     rabbitTemplate.convertAndSend("orderExchange", "order.create", message);
 }
}

@Component
public class OrderConsumer {
 @RabbitListener(queues = "orderQueue")
 public void consumeOrderMessage(String message) {
     // 处理订单消息
 }
}

服务治理的基本概念

服务治理是微服务架构中非常重要的一部分。服务治理包括服务注册、服务发现、负载均衡、容错处理等功能。

服务注册与发现：
- 服务注册：每个服务启动时需要向服务注册中心注册自己的信息，例如服务名称、IP地址、端口号等。
- 服务发现：其他服务需要通过服务注册中心来查找注册的服务信息，以便能够与之通信。
- 示例代码：使用Spring Cloud的Eureka实现服务注册与发现。
```
// 开启Eureka服务
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
 public static void main(String[] args) {
     SpringApplication.run(UserServiceApplication.class, args);
 }
}

// 配置Eureka服务注册中心
eureka:
client:
 service-url:
   defaultZone: http://localhost:8761/eureka/
```

负载均衡：

通过负载均衡器将请求分发到多个服务实例，以提高系统的可用性和性能。

示例代码：使用Spring Cloud的Ribbon实现负载均衡。

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

@Autowired
private RestTemplate restTemplate;

public void callUserService() {
 String result = restTemplate.getForObject("http://USER-SERVICE/users", String.class);
 // 处理返回结果
}

容错处理：

当服务不可用时，需要进行容错处理，例如超时重试、降级处理等。

示例代码：使用Spring Cloud的Hystrix实现服务熔断。

@HystrixCommand(fallbackMethod = "fallback")
public String callUserService() {
 // 调用用户服务
 return restTemplate.getForObject("http://USER-SERVICE/users", String.class);
}

public String fallback() {
 // 降级处理
 return "User Service is down";
}

微服务开发实践

在微服务开发实践中，通常使用Docker容器化部署微服务，使用Spring Boot快速搭建微服务应用，并实现持续集成与持续部署(CI/CD)。

使用Docker容器化部署微服务

Docker是实现微服务部署的一种非常流行的方式。它能够将应用程序及其依赖关系打包到一个轻量级的容器中，从而确保在不同环境中的一致性。

Docker镜像构建：

使用Dockerfile定义镜像的构建过程。

示例代码：构建一个简单的Docker镜像。

# 使用基础镜像
FROM openjdk:8-jdk-alpine

# 设置容器的工作目录
WORKDIR /app

# 复制JAR文件到容器中
COPY target/my-service.jar /app/my-service.jar

# 暴露端口
EXPOSE 8080

# 运行应用程序
ENTRYPOINT ["java", "-jar", "my-service.jar"]

Docker容器启动：
- 使用docker run命令启动容器。
- 示例代码：启动上面构建的Docker镜像。
```
docker run -p 8080:8080 -t my-service:latest
```
容器化部署的优点：
- 提高了应用程序的一致性和可移植性。
- 简化了部署和管理过程。
- 提高了资源利用率。

使用Spring Boot快速搭建微服务应用

Spring Boot是一个流行的Java应用程序框架，它简化了Java应用程序的开发和部署过程。通过Spring Boot，可以快速搭建微服务应用。

创建Spring Boot项目：
- 使用Spring Initializr创建一个新的Spring Boot项目。
- 示例代码：创建一个简单的Spring Boot项目。
```
mvn archetype:generate -DgroupId=com.example -DartifactId=my-service -DarchetypeArtifactId=spring-boot-starter-web -DinteractiveMode=false
```
配置应用：
- 在application.properties或application.yml文件中配置应用程序的属性。
- 示例代码：配置服务的端口和数据源。
```
server:
port: 8080

spring:
datasource:
 url: jdbc:mysql://localhost:3306/myservice
 username: root
 password: root
```

开发微服务功能：

开发具体的业务逻辑和服务接口。

示例代码：创建一个简单的用户服务。

@RestController
public class UserController {
 @Autowired
 private UserService userService;

 @GetMapping("/users")
 public List<User> getUsers() {
     return userService.getAllUsers();
 }
}

打包和部署：
- 使用Maven或Gradle打包应用程序。
- 示例代码：使用Maven打包应用程序。
```
mvn clean package
```
- 将打包后的JAR文件复制到Docker容器中，然后启动容器。
- 示例代码：启动Docker容器。
```
docker run -p 8080:8080 -t my-service:latest
```

微服务的持续集成与持续部署(CI/CD)

持续集成和持续部署（CI/CD）是微服务开发和部署中不可或缺的一部分，它能够自动化测试、构建和部署流程，从而加速开发迭代速度。

CI/CD流程设计：

设计一个自动化流程，包括源代码管理、构建、测试和部署。

示例代码：使用Jenkins实现自动化构建和部署。

pipeline {
 agent any
 stages {
     stage('Build') {
         steps {
             sh 'mvn clean package'
         }
     }
     stage('Test') {
         steps {
             sh 'mvn test'
         }
     }
     stage('Deploy') {
         steps {
             sh 'docker build -t my-service:latest .'
             sh 'docker run -p 8080:8080 -t my-service:latest'
         }
     }
 }
}

源代码管理：
- 使用版本控制系统，如Git，管理项目源代码。
- 示例代码：将项目代码推送到Git仓库。
```
git add .
git commit -m "Initial commit"
git push origin main
```
构建和测试：
- 自动化构建和测试流程，确保每次提交都经过自动化测试。
- 示例代码：使用Maven进行自动化构建和测试。
```
mvn clean install
```

部署到生产环境：

自动化部署流程，将构建好的应用程序部署到生产环境。

示例代码：使用Kubernetes部署微服务。

apiVersion: apps/v1
kind: Deployment
metadata:
name: my-service
spec:
replicas: 3
selector:
 matchLabels:
   app: my-service
template:
 metadata:
   labels:
     app: my-service
 spec:
   containers:
   - name: my-service
     image: my-service:latest
     ports:
     - containerPort: 8080

微服务监控与维护

微服务架构需要强大的监控和维护工具来确保系统的稳定性和性能。常见的微服务监控工具包括Prometheus、Grafana等。定位和解决微服务中的问题也需要特定的方法。

常用的微服务监控工具

Prometheus：
- 一个开源的监控系统和时间序列数据库。
- 示例代码：配置Prometheus监控微服务。
```
scrape_configs:
- job_name: 'my-service'
static_configs:
- targets: ['localhost:8080']
```

Grafana：

一个开源的数据可视化和分析工具，可以与Prometheus等监控工具集成。

示例代码：配置Grafana显示Prometheus的数据。

{
"type": "prometheus",
"uid": "Pm9ZrW8ze",
"access": "proxy",
"isDefault": false,
"name": "Prometheus",
"url": "http://localhost:9090",
"basicAuth": false,
"jsonData": {},
"timeShift": "",
"orgId": 1,
"version": 1
}

如何定位和解决微服务中的问题

日志分析：
- 使用日志来诊断系统中的问题。
- 示例代码：配置日志输出。
```
logging:
level:
 root: INFO
 org.springframework.web: DEBUG
```
性能分析：
- 使用性能分析工具来识别系统中的瓶颈。
- 示例代码：使用Java的JMX进行性能监控。
```
ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
```

故障排查：

使用故障排查工具来定位和解决服务中的问题。

示例代码：配置服务熔断和降级。

@HystrixCommand(fallbackMethod = "fallback")
public String callUserService() {
 // 调用用户服务
 return restTemplate.getForObject("http://USER-SERVICE/users", String.class);
}

public String fallback() {
 // 降级处理
 return "User Service is down";
}

系统容错与高可用性设计

服务容错：

使用服务熔断、重试等机制来提高系统的容错能力。

示例代码：使用Spring Cloud的Hystrix实现服务熔断。

@HystrixCommand(fallbackMethod = "fallback")
public String callUserService() {
 // 调用用户服务
 return restTemplate.getForObject("http://USER-SERVICE/users", String.class);
}

public String fallback() {
 // 降级处理
 return "User Service is down";
}

服务高可用性：

使用负载均衡和多实例部署来提高服务的可用性。

示例代码：使用Spring Cloud的Ribbon实现负载均衡。

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

@Autowired
private RestTemplate restTemplate;

public void callUserService() {
 String result = restTemplate.getForObject("http://USER-SERVICE/users", String.class);
 // 处理返回结果
}

微服务安全性

安全性是微服务架构中必不可少的一部分，包括认证与授权、网络安全防护措施、数据安全与隐私保护等。

微服务中的认证与授权

OAuth2：

一种常见的身份认证协议。

示例代码：配置Spring Boot使用OAuth2进行认证。

spring:
security:
 oauth2:
   client:
     registration:
       github:
         clientId: your-client-id
         clientSecret: your-client-secret
         scope: read:user
     provider:
       github:
         authorizationUri: https://github.com/login/oauth/authorize
         tokenUri: https://github.com/login/oauth/access_token
         userInfoUri: https://api.github.com/user
         userAuthoritiesUri: https://api.github.com/user
         defaultScopes:
           - read:user
           - user:email

JWT（JSON Web Token）：

一种基于JSON的开放标准，用于在各方之间安全地传输信息。

示例代码：使用Spring Boot实现JWT认证。

@Component
public class JwtAuthFilter extends OncePerRequestFilter {
 @Override
 protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
     String token = request.getHeader("Authorization");
     if (token != null) {
         try {
             Claims claims = Jwts.parser()
                         .setSigningKey("secret")
                         .parseClaimsJws(token)
                         .getBody();
             request.setAttribute("userId", claims.getSubject());
         } catch (JwtException e) {
             response.setStatus(HttpStatus.UNAUTHORIZED.value());
             return;
         }
     }
     chain.doFilter(request, response);
 }
}

网络安全防护措施

HTTPS：

使用HTTPS协议来保证数据的安全传输。

示例代码：配置Spring Boot使用HTTPS。

server:
port: 8443
ssl:
 enabled: true
 key-store: classpath:keystore.jks
 key-store-password: password
 keyStoreType: JKS
 keyAlias: tomcat
 keyPassword: password

防火墙：
- 使用防火墙来限制对特定服务的访问。
- 示例代码：配置防火墙规则。
```
sudo ufw allow 8080/tcp
sudo ufw enable
```

数据安全与隐私保护

数据加密：

使用加密技术来保护存储在服务中的数据。

示例代码：使用Spring Boot加密敏感数据。

@Component
public class DataEncryptionService {
 private static final String SECRET = "mySecretKey";
 private static final String IV = "AES/GCM/NoPadding";

 public String encrypt(String data) throws Exception {
     Cipher cipher = Cipher.getInstance(IV);
     byte[] iv = new byte[12];
     new SecureRandom().nextBytes(iv);
     AlgorithmParameters params = AlgorithmParameters.getInstance("AES");
     params.init(new IvParameterSpec(iv));
     cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(SECRET.getBytes(), "AES"), params);
     byte[] encrypted = cipher.doFinal(data.getBytes());
     return Base64.getEncoder().encodeToString(iv) + ":" + Base64.getEncoder().encodeToString(encrypted);
 }

 public String decrypt(String encryptedData) throws Exception {
     String[] parts = encryptedData.split(":");
     byte[] iv = Base64.getDecoder().decode(parts[0]);
     byte[] encrypted = Base64.getDecoder().decode(parts[1]);
     Cipher cipher = Cipher.getInstance(IV);
     cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(SECRET.getBytes(), "AES"), new IvParameterSpec(iv));
     return new String(cipher.doFinal(encrypted));
 }
}

数据备份与恢复：
- 定期备份数据，并确保能够快速恢复。
- 示例代码：使用Rsync备份数据。
```
rsync -avz --delete /data/backupuser/ /backup/backupuser/
```

微服务案例分享

微服务架构在实际项目中有着广泛的应用，通过实际项目可以更好地理解和掌握微服务的关键技术和最佳实践。对于初学者来说，从简单的小项目开始，逐渐深入到复杂的系统，是一个很好的学习路径。

微服务架构在实际项目中的应用

电子商务平台：
- 使用微服务架构将电商平台拆分为用户管理、商品管理、订单处理等多个独立的服务。
- 示例代码：配置一个简单的电子商务平台微服务架构。
```
# 用户服务
server:
port: 8081

# 商品服务
server:
port: 8082

# 订单服务
server:
port: 8083
```
社交媒体应用：
- 使用微服务架构将社交媒体应用拆分为用户管理、帖子发布、评论处理等服务。
- 示例代码：配置一个简单的社交媒体应用微服务架构。
```
# 用户服务
server:
port: 8081

# 帖子服务
server:
port: 8082

# 评论服务
server:
port: 8083
```

初学者如何通过实际项目学习微服务

从小项目开始：

从简单的微服务项目开始，逐步深入到复杂的系统。

示例代码：创建一个简单的购物车服务。

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

@RestController
public class ShoppingCartController {
 @Autowired
 private ShoppingCartService shoppingCartService;

 @PostMapping("/cart")
 public ShoppingCart addItemToCart(@RequestBody CartItem item) {
     return shoppingCartService.addItem(item);
 }
}

学习微服务框架：

学习Spring Boot、Spring Cloud等微服务框架。

示例代码：配置Spring Boot项目。

server:
port: 8080

spring:
datasource:
 url: jdbc:mysql://localhost:3306/shoppingcart
 username: root
 password: root

参与开源项目：

参与开源微服务项目，了解实际的应用场景和最佳实践。

示例代码：贡献到一个Spring Cloud项目。

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

常见的微服务架构设计误区及解决方法

服务拆分过于粗粒度：
- 服务拆分过于粗粒度会导致服务难以维护和扩展。
- 解决方法：合理拆分服务，确保每个服务都有明确的职责。
- 示例代码：将服务拆分为更细粒度的服务。
```
# 用户服务
server:
port: 8081

# 订单服务
server:
port: 8082

# 库存服务
server:
port: 8083
```
过度依赖特定技术栈：
- 过度依赖特定技术栈会限制系统的灵活性和扩展性。
- 解决方法：使用标准的接口和服务协议，确保服务的互操作性。
- 示例代码：使用标准的HTTP REST API。
```
@RestController
public class UserController {
 @GetMapping("/users")
 public List<User> getUsers() {
     // 获取用户列表
     return userService.getUsers();
 }
}
```
忽视服务治理：
- 忽视服务治理会导致系统难以维护和扩展。
- 解决方法：使用服务注册与发现、负载均衡、容错处理等机制。
- 示例代码：配置服务注册与发现。
```
eureka:
client:
 service-url:
   defaultZone: http://localhost:8761/eureka/
```

缺乏安全措施：

缺乏安全措施会导致系统的安全性问题。
解决方法：确保系统有足够的安全防护措施，如认证、授权、数据加密等。

示例代码：配置OAuth2认证。

spring:
security:
 oauth2:
   client:
     registration:
       github:
         clientId: your-client-id
         clientSecret: your-client-secret
         scope: read:user
     provider:
       github:
         authorizationUri: https://github.com/login/oauth/authorize
         tokenUri: https://github.com/login/oauth/access_token
         userInfoUri: https://api.github.com/user
         userAuthoritiesUri: https://api.github.com/user
         defaultScopes:
           - read:user
           - user:email

总结

微服务架构是一种将应用程序拆分为多个小型、独立服务的架构风格，通过这种方式提高了应用程序的可维护性、可扩展性和灵活性。微服务设计原则包括合理的服务拆分、服务之间的通信方式和服务治理等。微服务开发实践包括使用Docker容器化部署、Spring Boot快速搭建应用以及实现持续集成与持续部署等。微服务监控与维护需要使用监控工具、容错处理和高可用性设计等技术。微服务的安全性包括认证与授权、网络安全防护和数据安全等。通过实际项目可以更好地理解和掌握微服务的关键技术和最佳实践。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

四季花海

手记
篇

粉丝

42

获赞与收藏

161

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30585 343

网络编程入门教程

20个小节 12562 237

Pandas 入门教程

25个小节 18499 337

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空