Springboot微服务学习：从入门到初级实战

概述

Spring Boot 微服务学习涵盖了从 Spring Boot 框架的基础介绍到快速搭建项目、常用注解详解以及与常见技术的整合，帮助开发者快速入门并掌握微服务开发的基本技能。文章还详细介绍了微服务的基础概念和服务间通信的实现方法，提供了故障处理和日志记录的最佳实践。

Spring Boot 微服务学习：从入门到初级实战

Spring Boot 简介

Spring Boot 的定义和特点

Spring Boot 是由 Pivotal 团队提供的一个用于简化 Spring 应用初始搭建及开发过程的框架。它能够快速构建独立的、生产级别的 Spring 应用程序。Spring Boot 的主要特点包括：

1. 无需配置文件：大多数情况下，Spring Boot 应用程序不需要任何外部配置文件（如 XML 或 Java）。
2. 自动配置：Spring Boot 会自动配置应用程序的大多数方面，如数据库连接、WEB 服务器、日志记录等。
3. 嵌入式服务器：Spring Boot 可以直接嵌入 Tomcat、Jetty 或 Undertow 服务器，提供“一次打包，随处运行”的功能。
4. 起步依赖：通过单一的“起步依赖”（如 spring-boot-starter-web），可以引入一系列常用的依赖项。
5. 命令行界面：Spring Boot 提供了一个命令行界面，可以运行和调试 Spring Boot 应用程序。

Spring Boot 的核心优势

1. 简化配置：通过约定优于配置的原则，Spring Boot 大大减少了配置文件的数量和复杂度。
2. 快速开发：Spring Boot 通过自动配置、起步依赖等特性，可以快速搭建起一个完整的应用。
3. 独立运行：Spring Boot 可以打包为独立的可执行 JAR 文件，无需外部容器即可运行。
4. 社区支持：Spring Boot 有一个强大的社区支持，有大量的文档和教程可以参考。

Spring Boot 与传统 Spring 的区别

1. 配置简化：Spring Boot 通过约定优于配置的原则，减少了 XML 配置文件的使用，简化了配置过程。
2. 自动配置：Spring Boot 提供了大量的自动配置支持，而传统 Spring 需要手动配置几乎所有的依赖。
3. 起步依赖：Spring Boot 引入了起步依赖的概念，简化了依赖管理。
4. 独立运行：Spring Boot 应用可以打包为独立的 JAR 文件，直接通过命令行运行，而传统 Spring 应用通常需要部署到外部容器中。

快速搭建 Spring Boot 项目

使用 IDE 创建 Spring Boot 项目

1. 下载并安装 IDE：推荐使用 IntelliJ IDEA 或 Eclipse，这两个 IDE 都有很好的 Spring Boot 支持。

2. 创建新项目：

   • 在 IntelliJ IDEA 中，选择 File -> New -> Project，然后选择 Spring Initializr。
   • 在 Eclipse 中，选择 File -> New -> Other -> Spring -> Spring Starter Project。
3. 填写项目信息：
   • 输入项目名称、包名等信息。
   • 选择 Java 版本，一般选择默认的最新版本。
   • 选择 Spring Boot 版本。
   • 选择项目模块和依赖项。

// 例如，选择 Spring Web 依赖
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

1. 创建完成后，IDE 会自动下载并导入所需的依赖。

配置项目的基本设置

1. 设置应用主类：通常会在 src/main/java 目录下创建一个主类，该类使用 @SpringBootApplication 注解标记。
2. 配置 application.properties：该文件位于 src/main/resources 目录下，用于配置应用的属性，如端口号、数据库连接等。

# application.properties
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

1. 配置 pom.xml 或 build.gradle：根据使用的构建工具，配置依赖和插件。

<!-- pom.xml -->
<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>

运行第一个 Spring Boot 应用

1. 创建控制器：在 src/main/java 目录下创建一个控制器类，使用 @RestController 注解标记。

// src/main/java/com/example/demo/DemoApplication.java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {

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

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

1. 运行应用：在 IDE 中，右键点击主类并选择 Run，或者使用命令行 mvn spring-boot:run 或 gradle bootRun。

2. 访问服务：打开浏览器，访问 http://localhost:8080/，应可以看到输出 Hello, World!。

Spring Boot 常用注解详解

@SpringBootApplication

@SpringBootApplication 是一个组合注解，包含 @Configuration、@EnableAutoConfiguration 和 @ComponentScan。

• @Configuration：定义配置类，可以使用 @Bean 为应用注册配置类。
• @EnableAutoConfiguration：启用自动配置。
• @ComponentScan：扫描并注册应用中的组件，如控制器、服务类等。

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

@RestController

@RestController 是 @Controller 和 @ResponseBody 的组合注解，用于定义 REST 控制器。

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

@Service

@Service 用于标记业务逻辑服务类，通常用于实现应用的核心业务逻辑。

@Service
public class UserService {
    // 业务逻辑实现
}

@Repository

@Repository 用于标记数据访问层的组件，如数据库操作类。

@Repository
public class UserRepository {
    // 数据库操作方法
}

@Component

@Component 是一个泛型的注解，用于标记 Spring 容器中的任意组件，如工具类、枚举类等。

@Component
public class LoggingService {
    // 日志服务方法
}

Spring Boot 整合常见技术

整合 Spring Data JPA

Spring Data JPA 是一个用于简化数据库访问的框架，提供了统一的数据操作接口。

1. 添加依赖：在 pom.xml 或 build.gradle 中添加 spring-boot-starter-data-jpa 依赖。

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

1. 配置数据库：在 application.properties 中配置数据库连接信息。

# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

1. 创建实体类：使用 @Entity 注解标记为实体类。

// 实体类
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // getter 和 setter 方法
}

1. 创建仓库接口：继承 JpaRepository，定义数据访问方法。

// 仓库接口
public interface UserRepository extends JpaRepository<User, Long> {
}

1. 使用仓库接口：在服务类中注入仓库接口，使用仓库方法进行数据操作。

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

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

整合 Spring Security

Spring Security 是一个强大的认证和授权框架，用于保护应用的安全性。

1. 添加依赖：在 pom.xml 或 build.gradle 中添加 spring-boot-starter-security 依赖。

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

1. 配置安全策略：在 SecurityConfig 类中配置安全策略。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().permitAll()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("password").roles("USER")
            .and()
            .withUser("admin").password("password").roles("ADMIN");
    }
}

1. 使用登录页面：创建一个简单的登录页面。

<!-- login.html -->
<form action="/login" method="post">
    <label for="username">Username:</label>
    <input type="text" id="username" name="username">
    <label for="password">Password:</label>
    <input type="password" id="password" name="password">
    <input type="submit" value="Login">
</form>

1. 访问受保护资源：访问 /admin 资源时，需要进行用户认证和授权。

整合 MyBatis

MyBatis 是一个优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。

1. 添加依赖：在 pom.xml 或 build.gradle 中添加 mybatis-spring-boot-starter 依赖。

<!-- pom.xml -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>

1. 配置数据库：在 application.properties 中配置数据库连接信息。

# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

1. 创建实体类：使用 @Data 注解标记为实体类。

// 实体类
@Data
public class User {
    private Long id;
    private String name;
}

1. 创建 Mapper 接口：定义 SQL 语句。

// Mapper 接口
public interface UserMapper {
    @Select("SELECT * FROM user WHERE id = #{id}")
    User getUserById(Long id);
}

1. 使用 Mapper 接口：在服务类中注入 Mapper 接口，使用 Mapper 方法进行数据操作。

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.getUserById(id);
    }
}

微服务基础概念

微服务架构介绍

微服务架构是一种软件架构风格，将一个应用拆分为多个小型、独立的服务。每个服务可以独立开发、部署和扩展，提供特定的业务功能。

1. 服务独立性：每个微服务拥有独立的代码库、数据存储和部署单元。
2. 轻量级通信：服务之间通过 REST API 或消息队列进行通信。
3. 可伸缩性：可以通过增加机器数量或调整资源来快速扩展服务。
4. 容错性：单个服务的故障不会影响整个应用的运行。

服务发现与注册

服务发现是指微服务之间自动发现彼此位置并进行通信的过程。注册中心负责维护服务列表并提供服务发现功能。

1. 注册中心：常见的注册中心有 Eureka、Consul 和 Zookeeper。
2. 服务注册：服务启动时向注册中心注册自己的地址信息。
3. 服务发现：服务在调用其他服务时，向注册中心查询目标服务的地址信息。

示例：使用 Eureka 进行服务注册与发现

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

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

1. 配置 Eureka 服务器：在 application.properties 中配置 Eureka 服务器地址。

# application.properties
spring.cloud.config.discovery.enabled=true
spring.cloud.discovery.enabled=true
spring.application.name=service-name
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

1. 创建服务：在服务中启用 Eureka 客户端。

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

负载均衡与容错处理

负载均衡用于将请求分发到多个服务实例上，确保请求能够均匀分布，提高系统可用性和性能。

1. 负载均衡器：常见的负载均衡器有 Nginx 和 Apache。
2. 容错处理：通过心跳检测、超时重试等机制，确保服务间的通信可靠。

示例：使用 Nginx 进行负载均衡

1. 安装并配置 Nginx：安装并配置 Nginx，使其能够接收 HTTP 请求并将其分发到多个服务实例。

# nginx.conf
http {
    upstream backend {
        server 192.168.1.1:8080;
        server 192.168.1.2:8080;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}

1. 配置容错处理：在服务中实现心跳检测和超时重试。

@Service
public class UserService {
    private static final int MAX_RETRY_COUNT = 3;
    private static final int TIMEOUT = 5000;

    public User getUserById(Long id) {
        int retryCount = 0;
        while (retryCount < MAX_RETRY_COUNT) {
            try {
                return restTemplate.getForObject("http://localhost:8080/user/{id}", User.class, id);
            } catch (Exception e) {
                retryCount++;
                if (retryCount >= MAX_RETRY_COUNT) {
                    throw new RuntimeException("Failed to fetch user");
                }
            }
        }
        return null;
    }
}

使用 Spring Boot 构建简单的微服务

创建微服务项目

1. 创建服务项目：使用 Spring Initializr 创建一个新的 Spring Boot 项目。
2. 配置项目信息：设置项目名称、包名、Spring Boot 版本等信息。
3. 添加依赖：选择需要的起步依赖，如 spring-boot-starter-web。

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

实现服务间通信

1. 创建服务接口：定义服务接口，如用户服务接口。

// 用户服务接口
public interface UserService {
    User getUserById(Long id);
    User saveUser(User user);
}

1. 实现服务接口：在服务实现类中实现服务接口。

@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 saveUser(User user) {
        return userRepository.save(user);
    }
}

1. 调用服务接口：在其他服务中注入服务接口并调用服务方法。

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

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

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

故障处理与日志记录

1. 添加日志配置：在 application.properties 中配置日志配置。

# application.properties
logging.level.root=INFO
logging.file.name=spring-boot.log

1. 记录日志：在服务实现类中使用 @Slf4j 注解记录日志。

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

    @Override
    public User getUserById(Long id) {
        log.info("Getting user with id: {}", id);
        return userRepository.findById(id).orElse(null);
    }

    @Override
    public User saveUser(User user) {
        log.info("Saving user: {}", user);
        return userRepository.save(user);
    }
}

1. 异常处理：在控制器中添加全局异常处理器。

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(value = Exception.class)
    public ResponseEntity<String> handleException(Exception ex) {
        log.error("Exception occurred: ", ex);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("An error occurred");
    }
}
``

通过以上步骤，我们就可以使用 Spring Boot 构建一个简单的微服务应用，实现服务间通信、故障处理和日志记录等功能。