Spring Boot微服务实战：入门与初级应用指南-原创手记-慕课网

概述

Spring Boot微服务实战涵盖了从Spring Boot基础入门到微服务架构设计的全过程，包括快速搭建Spring Boot项目、服务拆分与通信、以及微服务部署与监控等关键环节。文章详细介绍了如何使用Spring Cloud进行服务发现与注册、构建服务网关，并提供了性能优化、安全性增强及测试调试的最佳实践。通过这些内容，开发者可以全面掌握Spring Boot微服务的实现与优化方法。

Spring Boot基础入门

Spring Boot简介

Spring Boot 是一个用于简化 Spring 应用配置的框架，其核心目标是简化开发者对 Spring 框架的使用，使开发者能够快速构建独立运行的、生产级别的基于 Spring 的应用。Spring Boot 自带了大量默认配置，开发者可以专注于业务逻辑的实现，而无需过多关注底层配置。

Spring Boot 提供了许多特性，包括：

自动配置：根据项目依赖自动配置 Spring，例如添加了 JDBC 依赖，Spring Boot 会自动配置数据库连接。
内嵌容器：内置了 Tomcat、Jetty 或 Undertow，允许直接运行 Spring 应用，无需部署到外部容器。
无需 XML 配置：大多数情况下，可以无需 XML 配置，使用注解配置。
依赖管理：提供了强大的依赖管理功能，简化了 Maven 和 Gradle 项目的依赖配置。
命令行运行：可以通过命令行执行应用，非常适合开发、原型创建和脚本任务。

快速搭建Spring Boot项目

搭建 Spring Boot 项目极为简单，可以通过多种方式创建项目，例如使用 Spring Initializr 网站、IDE 的插件或手动创建。

使用Spring Initializr网站创建项目

访问 Spring Initializr。
选择项目配置，例如 Maven 项目、Java 版本等。
添加项目依赖，例如 Web 依赖、Thymeleaf 模板引擎等。
点击 "Generate" 按钮，下载项目压缩包并解压。

使用IDE插件创建项目

如果使用 IntelliJ IDEA 或 Eclipse，可以通过插件直接创建 Spring Boot 项目。

在 IntelliJ IDEA 中：

打开 "File" -> "New" -> "Project"。
选择 "Spring Initializr"，点击 "Next"。
选择项目依赖，例如 Web 依赖、Thymeleaf。
填写项目信息，例如项目名称、语言等。
点击 "Finish"，IDE 会自动下载依赖并创建项目。

手动创建项目

如果手动创建项目，需要先创建目录结构，再导入依赖。

mkdir spring-boot-example
cd spring-boot-example
mkdir src/main/java
mkdir src/main/resources
mkdir src/test/java

在项目根目录添加 pom.xml 文件，用于 Maven 依赖管理。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>spring-boot-example</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

在 src/main/java 目录下创建主类。

package com.example.demo;

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

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

完成以上步骤，一个简单的 Spring Boot 项目就搭建好了。

Maven与Gradle依赖管理

Spring Boot 通过 Maven 和 Gradle 两种构建工具来管理依赖。Maven 和 Gradle 都支持自动配置和依赖管理，但 Gradle 提供了更灵活的依赖管理功能。

Maven配置

在 pom.xml 文件中，可以定义项目的依赖、属性等信息。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
   .
    .
    .
</project>

例如，若项目需要支持数据库访问功能，可以添加 spring-boot-starter-jdbc 依赖：

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

Gradle配置

在 build.gradle 文件中，可以定义项目的依赖和属性信息。

plugins {
    id 'org.springframework.boot' version '2.5.4'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '1.0.0'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

例如，若项目需要支持数据库访问功能，可以添加 spring-boot-starter-jdbc 依赖：

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
}

配置文件详解

Spring Boot 使用 application.properties 或 application.yml 文件来配置应用的各种参数。这两个文件位于 src/main/resources 目录中。

application.properties

# 应用默认端口
server.port=8080

# 数据库连接配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 日志配置
logging.level.root=INFO
logging.file.name=app.log

例如，若需要设置数据库连接池的初始连接数和最大连接数，可以添加如下配置：

spring.datasource.initial-size=5
spring.datasource.max-size=50

application.yml

server:
  port: 8080

spring:
  datasource:
  url: jdbc:mysql://localhost:3306/mydb
  username: root
  password: root
  driver-class-name: com.mysql.cj.jdbc.Driver

logging:
  level:
    root: INFO
  file:
    name: app.log

例如，若需要设置数据库连接池的初始连接数和最大连接数，可以添加如下配置：

spring:
  datasource:
  initial-size: 5
  max-size: 50

微服务概念与架构

微服务理念概述

微服务是一种架构风格，将单体应用拆分成一系列小型、独立的服务，这些服务通过 API 进行通信。每个微服务专注于单一功能，可以独立部署、扩展和重新部署。微服务架构的主要目标是提高开发效率、提高代码质量、提高系统的可靠性和可维护性，以及提高系统的灵活性和可伸缩性。

微服务的特点

小：每个服务只负责一个功能，服务规模小，易于维护和扩展。
独立部署：每个服务可以独立部署、独立运行。
通信：服务之间通过 HTTP REST API 或消息队列进行通信。
自动化：自动化测试、构建、部署。
服务发现：服务之间通过服务发现机制找到对方。
数据库独立：每个服务有独立的数据库，避免了数据共享带来的复杂性。

Spring Boot微服务架构设计

Spring Boot 微服务架构设计主要包含以下内容：

服务拆分：将应用拆分成多个小型、独立的服务。
服务通信：使用 REST API 或消息队列实现服务之间的通信。
服务发现：使用服务发现机制，自动发现其他服务。
配置管理：使用集中配置管理工具，如 Spring Cloud Config。
API 网关：使用 Spring Cloud Gateway 或 Zuul 作为 API 网关，统一入口，负责路由、认证、限流等。
容错处理：使用 Spring Cloud 的 Circuit Breaker 机制处理服务调用失败。
监控与日志：使用 Spring Boot Actuator、Prometheus、ELK 等工具监控应用和日志。

服务拆分示例

假设有一个电商平台，可以将应用拆分成多个微服务：

用户服务：负责用户信息管理。
商品服务：负责商品信息管理。
订单服务：负责订单信息管理。

每个服务都可以独立部署，相互之间通过 REST API 进行通信。

服务通信示例

// 用户服务
@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        // 查询用户信息
        return userService.getUserById(id);
    }
}

// 商品服务
@RestController
@RequestMapping("/products")
public class ProductController {
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        // 查询商品信息
        return productService.getProductById(id);
    }
}

// 订单服务调用商品服务
@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;

    public void createOrder(Long productId) {
        // 调用商品服务获取商品信息
        Product product = restTemplate.getForObject("http://product-service/products/{id}", Product.class, productId);
        // 处理订单逻辑
    }
}

服务发现与注册中心代码示例

使用 Spring Cloud Eureka 作为注册中心

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

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

spring.application.name=eureka-server
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

使用 Spring Cloud Eureka 客户端

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

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

spring.application.name=microservice
server.port=8081
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

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

单体应用

架构复杂：单体应用通常包含全部业务逻辑，架构复杂，难以维护。
部署不便：单体应用部署时需要停机，影响业务。
扩展困难：单体应用扩展时需要重新部署整个项目。
技术栈单一：单体应用使用统一的技术栈和框架。
容错能力差：单体应用一旦故障，可能导致整个系统不可用。

微服务应用

架构清晰：每个服务专注于单一功能，架构清晰，易于维护。
独立部署：服务可以独立部署，不影响其他服务。
灵活扩展：每个服务可以根据需要独立扩展。
技术多样：可以选择最适合的技术栈和框架。
高可用性：服务挂掉不会影响其他服务，提高了系统的可用性。
服务自治：服务可以独立部署、扩展和重新部署，自治性强。

Spring Boot微服务开发实践

创建RESTful服务

创建RESTful服务示例

创建 Spring Boot 项目。
添加 Spring Web 依赖。
创建 RESTful 控制器。

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

@RestController
@RequestMapping("/api")
public class UserController {
    @Autowired
    private UserService userService;

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

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

用户认证与授权

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/users/**").authenticated()
            .and()
            .httpBasic();
    }
}

使用Spring Boot构建API接口

创建API接口示例

创建 RESTful 控制器。
实现业务逻辑。

@RestController
@RequestMapping("/api")
public class ProductController {
    @Autowired
    private ProductService productService;

    @GetMapping("/products/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productService.getProductById(id);
    }

    @PostMapping("/products")
    public Product createProduct(@RequestBody Product product) {
        return productService.createProduct(product);
    }
}

实战案例：用户管理系统

用户管理系统需求

用户管理系统需要实现以下功能：

用户注册：新增用户。
用户登录：验证用户身份。
用户信息查询：查询用户信息。
用户信息修改：更新用户信息。
用户信息删除：删除用户信息。

用户管理系统实现

创建用户实体类。

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;

    // Getter and Setter
}

创建用户服务接口和实现类。

public interface UserService {
    User getUserById(Long id);
    User createUser(User user);
    User updateUser(User user);
    void deleteUser(Long id);
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @Override
    public User createUser(User user) {
        return userRepository.save(user);
    }

    @Override
    public User updateUser(User user) {
        return userRepository.save(user);
    }

    @Override
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

创建 RESTful 控制器。

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping("/")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/")
    public User updateUser(@RequestBody User user) {
        return userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

创建持久层接口和实现类。

public interface UserRepository extends JpaRepository<User, Long> {
}

完成以上步骤，一个简单的用户管理系统就实现了。

微服务部署与监控

Docker容器化部署

使用Docker部署Spring Boot应用

创建 Dockerfile。

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

构建 Docker 镜像。

docker build -t my-spring-boot-app .

运行 Docker 容器。

docker run -p 8080:8080 my-spring-boot-app

使用 Docker Compose 进行多服务部署

version: '3'
services:
  app:
    build: .
    ports:
      - "8080:8080"

使用Spring Boot Actuator进行监控

使用Actuator监控应用

Spring Boot Actuator 提供了一系列监控端点，可以监控应用的运行状态，例如：

/actuator/health：监控应用的健康状态。
/actuator/metrics：监控应用的性能指标。
/actuator/env：查看应用的环境配置信息。
/actuator/beans：查看应用的所有 Spring Bean。

在 application.properties 中启用 Actuator 端点。

management.endpoints.web.exposure.include=*

使用Prometheus监控应用

Prometheus 是一个开源的监控系统，可以与 Spring Boot Actuator 集成，实现应用的监控。

添加依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

配置 Prometheus 监控。

management.endpoints.web.exposure.include=*
management.metrics.web.server.auto-time-requests=true
management.metrics.web.client.auto-time-requests=true
management.endpoints.web.exposure.include=prometheus

启动 Prometheus，配置抓取地址。

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'spring-boot-app'
    static_configs:
      - targets: ['localhost:8080']

日志管理与异常处理

日志配置

Spring Boot 使用 Logback 作为默认的日志实现。可以通过 logging.* 属性配置日志。

logging.level.root=INFO
logging.file.name=app.log

logging:
  level:
  root: INFO
  file:
  name: app.log

异常处理

Spring Boot 提供了 @ControllerAdvice 和 @ExceptionHandler 注解来统一异常处理。

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, Object>> handleException(Exception ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 500);
        result.put("message", ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
    }
}

微服务通信与集成

服务发现与注册中心

使用Spring Cloud Eureka作为注册中心

添加依赖。

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

启动 Eureka 服务。

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

配置 Eureka 服务。

spring.application.name=eureka-server
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

使用 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>

启动微服务应用。

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

配置服务发现。

spring.application.name=microservice
server.port=8081
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

使用 Ribbon 进行负载均衡。

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

使用Spring Cloud构建服务网关

使用Spring Cloud Gateway构建服务网关

添加依赖。

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

配置路由。

spring:
  cloud:
  gateway:
    routes:
    - id: user-service
      uri: http://localhost:8081
      predicates:
      - Path=/users/**
    - id: product-service
      uri: http://localhost:8082
      predicates:
      - Path=/products/**

实战案例：服务间通信

假设有两个微服务：用户服务和商品服务。用户服务调用商品服务获取商品信息。

用户服务。

@Service
public class UserService {
    @Autowired
    private RestTemplate restTemplate;

    public Product getProductById(Long productId) {
        return restTemplate.getForObject("http://product-service/products/{id}", Product.class, productId);
    }
}

商品服务。

@RestController
@RequestMapping("/products")
public class ProductController {
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        // 查询商品信息
        return productService.getProductById(id);
    }
}

以上代码实现了用户服务调用商品服务获取商品信息的功能。

Spring Boot微服务优化

性能优化技巧

代码优化

减少数据库查询：避免在循环中执行数据库查询。
使用缓存：使用 Redis 缓存频繁访问的数据。
优化线程池配置：合理配置线程池参数，避免线程池资源浪费。
减少内存占用：使用合适的数据结构，避免内存泄漏。

代码示例：使用Redis缓存

@Autowired
private RedisTemplate<String, String> redisTemplate;

public String getProductInfo(Long productId) {
    String cachedProduct = redisTemplate.opsForValue().get("product:" + productId);
    if (cachedProduct != null) {
        return cachedProduct;
    }
    Product product = productService.getProductById(productId);
    String productInfo = product.toString();
    redisTemplate.opsForValue().set("product:" + productId, productInfo);
    return productInfo;
}

安全性增强

用户认证与授权

使用 Spring Security 实现用户认证和授权。

添加依赖。

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

配置 Spring Security。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/users/**").authenticated()
            .and()
            .httpBasic();
    }
}

代码示例：配置Spring Security

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/users/**").authenticated()
            .and()
            .httpBasic();
    }
}

测试与调试最佳实践

单元测试

使用 JUnit 和 Mockito 进行单元测试。

添加依赖。

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

编写单元测试。

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @MockBean
    private UserRepository userRepository;

    @Test
    public void testGetUserById() {
        User user = new User();
        user.setId(1L);
        when(userRepository.findById(1L)).thenReturn(Optional.of(user));
        User result = userService.getUserById(1L);
        assertEquals(user, result);
    }
}

集成测试

使用 Spring Boot 提供的 @SpringBootTest 注解进行集成测试。

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserControllerTest {
    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testGetUserById() {
        User user = restTemplate.getForObject("/api/users/1", User.class);
        assertNotNull(user);
    }
}

通过以上内容，详细介绍了 Spring Boot 微服务的入门与初级应用指南，包括快速搭建项目、微服务架构设计、微服务开发实践、微服务部署与监控，以及微服务通信与集成等内容。希望对开发者在开发 Spring Boot 微服务过程中有所帮助。