Spring Boot微服务教程：入门与实践指南-原创手记-慕课网

概述

本文提供了Spring Boot微服务教程的全面指南，涵盖了从入门到实践的各项内容。首先介绍了Spring Boot的基本概念和优势，接着详细讲解了如何快速搭建Spring Boot项目。文章还深入探讨了微服务的基础概念及其与传统单体应用的区别，并通过实战案例展示了如何构建完整的Spring Boot微服务系统。

Spring Boot 微服务教程：入门与实践指南

Spring Boot 简介

Spring Boot 是什么

Spring Boot 是一个基于 Spring 框架的开源微服务框架，旨在简化 Spring 应用的初始搭建以及配置过程。通过约定优于配置的原则，Spring Boot 可以帮助开发者快速搭建独立运行的应用程序，它包含了大量的自动配置功能，使得开发者可以专注于业务逻辑的实现，而不需要过多关注底层的配置细节。

Spring Boot 的优势

Spring Boot 的主要优势如下：

简化配置：Spring Boot 提供了大量默认配置，使得开发者不必手动编写大量的配置代码。
快速启动：Spring Boot 允许应用快速启动，减少了编写和配置代码的时间。
自动配置：Spring Boot 可以自动配置许多常见的库和框架，如数据库连接、Web 服务器等。
内置Web服务器：Spring Boot 内置了 Tomcat、Jetty 或 Undertow 作为 Web 服务器，无需手动部署到外部容器。
支持嵌入式Servlet容器：可以将 Servlet 容器嵌入到应用中，使得应用更加独立。
丰富的起步依赖：提供了大量的起步依赖（Starters），方便开发者快速集成各种功能。
无代码生成：Spring Boot 不会生成任何配置文件，所有配置都可以通过代码或属性文件实现。

快速搭建 Spring Boot 项目

以下是使用 Spring Initializr 快速搭建一个新的 Spring Boot 项目的基本步骤：

访问 Spring Initializr 网站：https://start.spring.io/
选择项目依赖：选择需要的依赖，例如 Web、JPA、Thymeleaf 等。
生成项目：填写项目元数据，如项目名、语言、Spring Boot 版本等，然后生成项目。
导入项目：下载生成的项目文件，并导入到开发工具中（如 IntelliJ IDEA 或 Eclipse）。

以下是一个简单的 Spring Boot 应用示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

以上代码展示了如何创建一个简单的 Spring Boot 应用，其中 @SpringBootApplication 注解用于标记主类，SpringApplication.run() 方法用来启动应用。

微服务基础概念

什么是微服务

微服务是一种架构风格，它将一个大型的单体应用拆分成多个小型服务，每个服务运行在独立的进程中，具有明确的边界，并且能够被独立地部署、扩展和升级。

微服务架构的优势和挑战

优势：

独立部署：每个服务可以独立部署和扩展，不会影响其他服务。
服务解耦：服务之间通过 API 调用，解耦合程度高，便于维护和开发。
灵活扩展：根据服务的负载情况，可以灵活地扩展某个服务的实例数量。
故障隔离：由于服务边界明确，一个服务的故障不会轻易蔓延到其他服务。

挑战：

复杂性增加：微服务架构增加了系统的复杂性，需要更多的工具和服务来管理和协调。
运维成本：相比单体应用，微服务架构需要更多的运维工作，包括监控、日志管理等。
集成测试：服务之间的集成测试变得复杂，需要更多的测试策略和工具。

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

在传统单体应用中，所有的功能都集成在一个单一的代码库中，这导致了代码库庞大、维护复杂。而微服务架构则将应用拆分成多个独立服务，每个服务都有明确的职责范围，可以独立开发、部署和维护。

创建第一个 Spring Boot 微服务应用

项目初始化与依赖管理

本节将展示如何创建一个简单的 Spring Boot 项目，并实现一个基本的 RESTful API。

创建项目：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

添加依赖：
在 pom.xml 文件中，可以根据需要添加相应的依赖，例如 Web 支持：

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

创建 RESTful API：
创建一个简单的用户服务，实现增删查改（CRUD）操作：
```
import org.springframework.web.bind.annotation.*;
```

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
public class UserController {
private Map<Integer, User> users = new HashMap<>();
private int id = 0;

@PostMapping("/users")
public User createUser(@RequestBody User user) {
    id++;
    user.setId(id);
    users.put(id, user);
    return user;
}

@GetMapping("/users")
public List<User> getAllUsers() {
    return new ArrayList<>(users.values());
}

@GetMapping("/users/{id}")
public User getUserById(@PathVariable int id) {
    return users.get(id);
}

@PutMapping("/users/{id}")
public User updateUser(@PathVariable int id, @RequestBody User user) {
    User existingUser = users.get(id);
    if (existingUser != null) {
        existingUser.setName(user.getName());
        existingUser.setAge(user.getAge());
    }
    return existingUser;
}

@DeleteMapping("/users/{id}")
public Map<String, String> deleteUser(@PathVariable int id) {
    users.remove(id);
    return Map.of("status", "success");
}

}

class User {
private int id;
private String name;
private int age;

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

}


### 使用 Spring Boot Actuator 监控应用
Spring Boot Actuator 提供了丰富的生产就绪特性，可以帮助开发者监控应用的健康状态、日志、线程等信息。

1. 添加依赖：
```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

配置 Actuator：
在 application.properties 文件中，可以配置 Actuator 的端点启用情况：
```
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always
```
访问 Actuator 端点：
启动应用后，可以通过访问 http://localhost:8080/actuator 来查看所有可用的端点信息。

微服务部署与运行

使用 Docker 打包 Spring Boot 应用

Docker 是一个开源的应用容器引擎，可以用来打包、发布和运行任意的应用。将 Spring Boot 应用打包成 Docker 镜像，可以方便地在不同的环境中部署。

在项目根目录下创建 Dockerfile 文件：

FROM openjdk:11-jre-slim
COPY target/myapp.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

构建 Docker 镜像：
```
docker build -t myapp:latest .
```

运行 Docker 容器：

docker run -d -p 8080:8080 --name myapp myapp:latest

在本地和云环境中部署应用

在本地环境中部署 Spring Boot 应用，可以使用 IDE 或命令行工具直接运行应用。在云环境中部署，可以通过云服务提供商（如 AWS、阿里云）提供的服务来部署 Docker 镜像。

使用云服务提供商的控制台上传并部署 Docker 镜像。
配置域名和 HTTPS 证书，确保应用可以通过公网访问。

应用的启动与停止

启动 Spring Boot 应用可以通过 IDE 的运行功能，或使用命令行工具运行主类：

java -jar target/myapp.jar

停止应用可以通过杀死对应的进程：

kill -9 <进程id>

微服务间的通信

微服务间的通信通常通过 RESTful API 或消息队列实现。在 Spring Boot 中，可以使用 Spring Cloud 来简化服务发现和负载均衡的实现。

RESTful API 调用

在微服务架构中，服务间的通信通常通过 RESTful API 实现。以下是一个简单的客户端调用示例：

客户端代码：


import org.springframework.web.client.RestTemplate;

public class Client {
public static void main(String[] args) {
RestTemplate restTemplate = new RestTemplate();
User user = restTemplate.getForObject("http://localhost:8080/users/1", User.class);
System.out.println(user);
}
}


2. 服务端代码：
```java
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

@RestController
public class UserController {
    private Map<Integer, User> users = new HashMap<>();
    private int id = 0;

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable int id) {
        // 模拟数据库查询
        return users.get(id);
    }
}

class User {
    private int id;
    private String name;
    private int age;

    // Getter 和 Setter 方法
}

使用 Spring Cloud 进行服务发现和负载均衡

Spring Cloud 提供了服务发现（如 Eureka）和负载均衡（如 Ribbon）的实现，可以帮助开发者更加轻松地管理微服务间的通信。

添加依赖：

<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-ribbon</artifactId>
</dependency>

配置服务注册和发现：
在 application.properties 文件中配置服务注册和发现的地址：
```
spring.application.name=my-service
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/
```

使用 @RibbonClient 注解：


import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@RestController
@RibbonClient(name = "other-service", configuration = CustomRibbonConfiguration.class)
public class MyController {
@GetMapping("/callOtherService")
public String callOtherService() {
// 调用其他服务
return restTemplate.getForObject("http://other-service/api", String.class);
}
}


## 实战案例：构建完整的 Spring Boot 微服务系统
在这一节中，我们将通过一个实际的案例来构建一个完整的 Spring Boot 微服务系统。案例包括业务需求分析、架构设计以及具体实现与测试。

### 分析业务需求
假设我们要构建一个简单的电商系统，包括商品管理和服务订单管理两个微服务。商品管理服务提供商品的创建、查询、修改和删除功能，订单管理服务管理订单的创建和查询。

### 设计微服务架构
我们需要设计两个微服务：
1. 商品管理服务 `product-service`：
   - 创建商品
   - 查询商品
   - 修改商品
   - 删除商品

2. 订单管理服务 `order-service`：
   - 创建订单
   - 查询订单

每个服务都有独立的数据库，并通过 RESTful API 实现服务间的通信。

### 实现并测试微服务系统
#### 商品管理服务实现
1. 添加依赖：
```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

数据库配置：

spring.datasource.url=jdbc:mysql://localhost:3306/product-db
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

创建实体类：

@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private double price;

// Getter 和 Setter 方法
}

创建仓库接口：


import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}


5. 创建控制器：
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/products")
public class ProductController {
    @Autowired
    private ProductRepository repository;

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return repository.save(product);
    }

    @GetMapping
    public List<Product> getAllProducts() {
        return repository.findAll();
    }

    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        product.setId(id);
        return repository.save(product);
    }

    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable Long id) {
        repository.deleteById(id);
    }
}

订单管理服务实现

添加依赖：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

数据库配置：

spring.datasource.url=jdbc:mysql://localhost:3306/order-db
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

创建实体类：

@Entity
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String productName;
private double price;

// Getter 和 Setter 方法
}

创建仓库接口：


import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {
}


5. 创建控制器：
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/orders")
public class OrderController {
    @Autowired
    private OrderRepository repository;

    @PostMapping
    public Order createOrder(@RequestBody Order order) {
        return repository.save(order);
    }

    @GetMapping
    public List<Order> getAllOrders() {
        return repository.findAll();
    }
}

测试微服务系统

启动两个服务：
- 商品管理服务
- 订单管理服务

调用 API 测试：

创建商品：

curl -X POST http://localhost:8080/products -H "Content-Type: application/json" -d '{"name": "iPhone", "price": 999}'

查询商品：

curl -X GET http://localhost:8080/products

创建订单：

curl -X POST http://localhost:8081/orders -H "Content-Type: application/json" -d '{"productName": "iPhone", "price": 999}'

查询订单：

curl -X GET http://localhost:8081/orders

通过以上步骤，我们成功构建了一个简单的 Spring Boot 微服务系统，并实现了基本的业务功能。