深入浅出SpringBoot框架

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

3.2.2 Gradle 配置

plugins {
    id 'org.springframework.boot' version '2.5.4'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

3.3 运行Spring Boot应用

通过 @SpringBootApplication 注解启动应用，运行内嵌的 Tomcat 服务器，访问默认的 localhost:8080 端口。

@SpringBootApplication
@Configuration
public class Application {

    public static void main(String[] args) {
        TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
        SpringApplication application = new SpringApplication(AdminApplication.class);
        application.run(args);
    }
}

4. 核心特性详解

4.1 自动配置 (Auto Configuration)

4.1.1 自动配置原理

Spring Boot 提供了大量的 @Conditional 注解，用来根据不同的条件加载所需的配置。例如，当项目中存在某个特定的类时，会自动为该类配置所需的 Bean。

4.1.2 自定义自动配置

在某些情况下，Spring Boot 的默认配置不能满足需求，这时可以通过 @Configuration 注解定义自己的配置类。

4.2 Spring Boot Starter

Starter 是 Spring Boot 提供的一组开箱即用的依赖包，用户可以通过 Maven 或 Gradle 轻松引入常见的功能模块。

4.2.1 常用Starter介绍

spring-boot-starter-web：用于构建 Web 应用
spring-boot-starter-data-jpa：用于与数据库交互
spring-boot-starter-security：集成了 Spring Security 安全框架

4.2.2 自定义 Starter

如果企业内部有一些常见的依赖模块，可以创建自己的 Starter。

4.3 嵌入式服务器

Spring Boot 支持内嵌服务器，包括 Tomcat、Jetty 和 Undertow，免去了传统应用部署到外部容器的步骤。

4.3.1 更换嵌入式服务器

通过修改依赖，可以将 Tomcat 替换为 Jetty 或 Undertow。

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

4.4 配置管理

Spring Boot 提供了多种方式来管理配置，包括 application.properties 和 application.yml 文件。

4.4.1 外部化配置

通过命令行参数、环境变量或者外部配置文件来覆盖默认配置。

4.4.2 Profile 配置

不同环境下（如开发、测试、生产）可以使用不同的配置，通过 application-{profile}.properties 实现。

4.5 日志管理

Spring Boot 默认使用 SLF4J 和 Logback 来管理日志。用户可以自定义日志级别和输出格式。

logging.level.org.springframework=DEBUG
logging.file.name=logs/app.log

5. Web 开发中的Spring Boot

5.1 RESTful API 开发

通过 @RestController 注解和 @RequestMapping 注解快速开发 RESTful 接口。

@RestController
@RequestMapping("/api")
public class MyController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }
}

5.2 参数校验与异常处理

通过 @Valid 注解结合 BindingResult 处理参数校验。

@PostMapping("/user")
public ResponseEntity<String> addUser(@Valid @RequestBody User user, BindingResult result) {
    if (result.hasErrors()) {
        return new ResponseEntity<>(result.getAllErrors().get(0).getDefaultMessage(), HttpStatus.BAD_REQUEST);
    }
    return new ResponseEntity<>("User added successfully", HttpStatus.OK);
}

5.3 Spring Boot与Thymeleaf集成

Thymeleaf 是一种流行的 Java 模板引擎，可以通过 spring-boot-starter-thymeleaf 进行集成，生成动态 HTML 页面。

6. 数据持久化

在 Spring Boot 的开发中，数据持久化是核心部分之一，它负责将应用程序中的数据存储在持久化存储中，如关系型数据库（MySQL、PostgreSQL 等）或 NoSQL 数据库（如 MongoDB、Redis 等）。Spring Boot 提供了多种简化数据持久化开发的工具和框架，如 Spring Data JPA、Spring Data MongoDB、Spring Data Redis 等，帮助开发者快速高效地实现数据层的功能。本文将详细介绍数据持久化的相关内容，并补充不同数据库的集成方法。

6.1 Spring Data 概述

Spring Data 是 Spring 提供的一个统一的数据访问框架，旨在简化对数据库的访问。它通过一套标准化的接口和实现，支持多种数据库技术，包括关系型数据库（JPA、JDBC）、NoSQL 数据库（MongoDB、Cassandra、Redis）等。Spring Data 的核心理念是通过最少的代码实现最常见的数据操作。

主要的 Spring Data 模块包括：

Spring Data JPA：支持关系型数据库的访问，基于 JPA（Java Persistence API）标准。
Spring Data JDBC：为关系型数据库提供更轻量级的访问方式。
Spring Data MongoDB：提供对 MongoDB（NoSQL）的支持。
Spring Data Redis：对 Redis 数据库的集成。

6.2 JDBC (Java Database Connectivity)

JDBC 是 Java 原生的数据库连接技术，Spring Boot 提供了 Spring Data JDBC 作为简化的替代方案。与 JPA 不同，JDBC 不依赖于 ORM（对象关系映射）框架，而是直接操作数据库，具有更好的性能和灵活性。

6.2.1 Spring Data JDBC 配置

Spring Data JDBC 是一种轻量级的持久化解决方案，适合简单的关系型数据库操作。首先，添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

6.2.2 实体类和Repository定义

Spring Data JDBC 中的实体类和 Repository 设计与 JPA 类似：

@Table("user")
public class User {
    @Id
    private Long id;
    private String name;
    private String email;
    // getter and setter methods
}

public interface UserRepository extends CrudRepository<User, Long> {
    List<User> findByName(String name);
}

通过 CrudRepository，我们可以轻松实现数据库的基本增删改查操作。

6.2.3 数据库配置

数据库连接和 JPA 类似，通过 application.properties 文件配置：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=12345
spring.jdbc.template.query-timeout=30

6.3 JPA（Java Persistence API）

JPA 是 Java EE 平台的标准数据持久化 API，用于管理 Java 对象与关系型数据库之间的映射。Spring Data JPA 是基于 JPA 的一个实现，提供了自动生成查询、简化 CRUD 操作等功能，开发者可以通过最少的代码完成复杂的数据库操作。

6.3.1 Spring Data JPA 配置

要使用 Spring Data JPA 进行数据持久化，需要添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

6.3.2 实体类定义

在使用 JPA 时，每一个表都对应一个 Java 类，称为“实体类”。实体类中的属性映射到数据库表中的列。

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
    // getter and setter methods
}

6.3.3 Repository接口

Spring Data JPA 通过继承 JpaRepository 接口提供了对实体类的基本 CRUD 操作。

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
}

通过该接口，开发者可以直接调用基本的增删改查方法，以及根据方法命名规则自动生成查询语句。

6.3.4 数据库配置

在 application.properties 或 application.yml 中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=12345
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

6.4 MongoDB 持久化

MongoDB 是一种 NoSQL 数据库，适合存储大规模的非结构化数据。Spring Data MongoDB 提供了对 MongoDB 的集成，使得开发者可以像操作关系型数据库一样，轻松地操作 MongoDB。

6.4.1 Spring Data MongoDB 配置

首先，需要添加 MongoDB 依赖：

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

6.4.2 MongoDB 实体类定义

在 Spring Data MongoDB 中，实体类使用 @Document 注解来指定与 MongoDB 集合的映射：

@Document(collection = "users")
public class User {
    @Id
    private String id;
    private String name;
    private String email;
    // getter and setter methods
}

6.4.3 Repository接口

与 JPA 类似，MongoDB 的 Repository 也可以通过继承 MongoRepository 实现 CRUD 操作：

public interface UserRepository extends MongoRepository<User, String> {
    List<User> findByName(String name);
}

6.4.4 MongoDB 配置

在 application.properties 文件中配置 MongoDB 连接：

spring.data.mongodb.uri=mongodb://localhost:27017/mydb
spring.data.mongodb.option.socket-keep-alive=true
spring.data.mongodb.option.max-connection-idle-time=120000
spring.data.mongodb.option.min-connection-per-host=10
spring.data.mongodb.option.connect-timeout=72000

6.4.5 MongoDB 常用操作

6.4.5.1 `MongoRepository` 操作

通过 MongoRepository 接口，我们可以直接调用常见的增删改查方法：

@Autowired
private UserRepository userRepository;

public void createUser(User user) {
    userRepository.save(user);
}

public List<User> findUsersByName(String name) {
    return userRepository.findByName(name);
}

public void deleteUserById(String id) {
    userRepository.deleteById(id);
}

此外，除了 MongoRepository，Spring Data MongoDB 还提供了更为灵活的 MongoTemplate，适用于复杂查询和自定义操作。MongoTemplate 是一个底层的数据访问模板，允许开发者以更细粒度的控制方式操作 MongoDB。

6.4.5.2 `MongoTemplate操作`

在使用 MongoTemplate 前，首先需要在配置类中定义它。Spring Boot 会根据 application.properties 中的 MongoDB 配置信息自动配置 MongoTemplate，但如果需要自定义配置，可以手动创建：

@Configuration
public class MongoConfig {
    @Bean
    public MongoTemplate mongoTemplate(MongoClient mongoClient) {
        return new MongoTemplate(mongoClient, "mydb");
    }
}

注意：mongoClient 是 MongoDB 的客户端实例，Spring Boot 会根据 spring.data.mongodb.uri 自动生成。

通过 MongoTemplate 可以实现增删改查操作：

@Autowired
private MongoTemplate mongoTemplate;
// 单个插入
public void saveUser(User user) {
    mongoTemplate.insert(user);
}
// 批量插入
public void saveUsers(List<User> users) {
    mongoTemplate.insertAll(users);
}
// 条件查询
public List<User> findUsersByName(String name) {
    Query query = new Query();
    query.addCriteria(Criteria.where("name").is(name));
    return mongoTemplate.find(query, User.class);
}
// 主键查询
public User findUserById(String id) {
    return mongoTemplate.findById(id, User.class);
}
// 更新
public void updateUserEmail(String id, String newEmail) {
    Query query = new Query(Criteria.where("_id").is(id));
    Update update = new Update().set("email", newEmail);
    // 仅更新一个
    mongoTemplate.updateFirst(query, update, User.class);
    // 更新多个
    mongoTemplate.updateMulti(query, update, User.class);
}
// 删除
public void deleteUserById(String id) {
    Query query = new Query(Criteria.where("_id").is(id));
    mongoTemplate.remove(query, User.class);
}
// 聚合查询
public List<AggregationResults> getUserCountByAgeGroup() {
    Aggregation agg = Aggregation.newAggregation(
        Aggregation.group("age").count().as("userCount")
    );
    return mongoTemplate.aggregate(agg, "users", AggregationResults.class);
}

6.4.5.3 `MongoTemplate` 与 `MongoRepository` 的区别

特性	MongoTemplate	MongoRepository
操作方式	更加底层、灵活	基于接口的简化操作
适用场景	复杂查询、聚合操作等复杂数据访问需求	简单 CRUD 操作
查询语法	使用 `Query`、`Criteria` 构建条件	通过方法命名生成查询

推荐使用场景：如果只是进行简单的 CRUD 操作，建议使用 MongoRepository。如果需要处理复杂查询、批量更新或者聚合操作，MongoTemplate 会提供更强的灵活性。

通过 MongoTemplate，开发者可以更灵活地操作 MongoDB，同时能够处理复杂的查询和聚合操作。

6.5 Redis 持久化

Redis 是一种高性能的内存型键值存储数据库，适用于缓存、消息队列等场景。Spring Data Redis 提供了对 Redis 的简便集成。

6.5.1 Spring Data Redis 配置

首先添加 Redis 相关依赖：

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

6.5.2 Redis 配置

在 application.properties 文件中添加 Redis 服务器配置：

spring.redis.host=localhost
spring.redis.port=6379

6.5.3 RedisTemplate使用

Spring Data Redis 提供了 RedisTemplate 来执行 Redis 的常见操作：

@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void saveValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public String getValue(String key) {
        return (String) redisTemplate.opsForValue().get(key);
    }
}

6.6 数据源配置与事务管理

无论使用哪种数据库，数据源配置和事务管理都是关键部分。Spring Boot 提供了自动配置的能力，但在某些情况下，开发者可能需要对数据源和事务进行自定义配置。

6.6.1 数据源配置

通过 DataSource 配置连接池，可以管理应用程序与数据库的连接：

@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
    return DataSourceBuilder.create().build();
}

6.6.2 事务管理

Spring 提供了声明式事务管理，通过 @Transactional 注解可以指定某个方法或类的事务范围：

@Service
public class UserService {
    
    @Transactional
    public void createUser(User user) {
        userRepository.save(user);
    }
}

还可以在 application.properties 中配置事务管理策略：

spring.transaction.default-timeout=30s
spring.transaction.rollback-on-commit-f

7. Spring Boot 安全机制

在 Spring Boot 开发过程中，安全机制是非常重要的组成部分。无论是单体应用，还是分布式微服务架构，安全性都是首要考虑的因素之一。Spring Boot 提供了与 Spring Security 的无缝集成，简化了身份认证和权限控制等复杂的安全操作。下面详细探讨 Spring Boot 安全机制的各个方面，包括基本的安全配置、常见的认证和授权方案、加密技术，以及在实际开发中的应用。

7.1 Spring Security 集成

Spring Security 是一个功能强大且高度可配置的安全框架，广泛应用于 Java 企业级应用。Spring Boot 与 Spring Security 的集成，使得开发者能够通过少量配置实现用户认证和权限控制。

7.1.1 引入依赖

要在 Spring Boot 项目中启用 Spring Security，首先需要添加相应的依赖：

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

7.1.2 Spring Security 默认行为

引入依赖后，Spring Security 会自动为应用程序启用一些基本的安全措施，例如：

所有 HTTP 端点默认都会被保护，必须通过认证后才能访问。
默认启用了基于表单的登录界面，并且提供一个默认的登录页面。
提供了基于 HTTP Basic 的认证机制。

默认用户名是 "user"，密码在应用启动时会在控制台日志中生成并打印。

7.1.3 禁用安全保护（开发环境下）

在开发阶段，可能希望禁用 Spring Security 的默认安全机制。可以通过自定义 WebSecurityConfigurerAdapter 来实现：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/").permitAll().and().csrf().disable();
    }
}

7.2 认证与授权

Spring Security 提供了灵活的认证与授权机制。认证负责验证用户的身份，授权决定用户可以访问哪些资源。

7.2.1 用户认证

Spring Security 支持多种用户认证方式，包括：

基于内存的用户认证：适用于小型应用或简单的开发测试场景。
基于数据库的用户认证：通过 Spring Data JPA 等技术从数据库加载用户信息。
第三方认证：例如 OAuth2、LDAP 等认证方式。

7.2.1.1 基于内存的用户认证

可以通过 Spring Security 提供的 InMemoryUserDetailsManager 简单配置用户和角色：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("admin").password(passwordEncoder().encode("admin123")).roles("ADMIN")
            .and()
            .withUser("user").password(passwordEncoder().encode("user123")).roles("USER");
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

7.2.1.2 基于数据库的用户认证

在企业应用中，通常用户信息存储在数据库中。Spring Security 提供了 JdbcUserDetailsManager 来从数据库加载用户信息。我们可以使用 Spring Data JPA 实现基于数据库的用户认证。

假设我们有如下的数据库表结构：

CREATE TABLE users (
    username VARCHAR(50) PRIMARY KEY,
    password VARCHAR(100),
    enabled BOOLEAN
);

CREATE TABLE authorities (
    username VARCHAR(50),
    authority VARCHAR(50),
    FOREIGN KEY (username) REFERENCES users(username)
);

可以通过以下代码从数据库加载用户信息：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private DataSource dataSource;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.jdbcAuthentication().dataSource(dataSource)
            .usersByUsernameQuery("SELECT username, password, enabled FROM users WHERE username = ?")
            .authoritiesByUsernameQuery("SELECT username, authority FROM authorities WHERE username = ?");
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

7.2.2 授权

授权是基于用户角色或权限对资源进行访问控制。Spring Security 允许基于 URL、方法或表达式进行访问控制。

7.2.2.1 基于URL的访问控制

通过 HttpSecurity 配置，可以实现基于 URL 的访问控制：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
            .anyRequest().authenticated()
            .and()
            .formLogin().permitAll()
            .and()
            .logout().permitAll();
    }
}

7.2.2.2 基于方法的访问控制

Spring Security 提供了 @PreAuthorize 和 @PostAuthorize 注解，用于在方法级别进行授权控制：

@Service
public class UserService {
    
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(String username) {
        // 只有 ADMIN 用户才能删除用户
    }
}

可以通过 @EnableGlobalMethodSecurity 启用方法级别的安全控制：

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
}

7.3 加密与密码管理

安全性中一个重要的环节是密码的加密和解密。Spring Security 提供了 PasswordEncoder 接口来处理密码的加密与校验。默认推荐使用 BCryptPasswordEncoder，它提供了较好的安全性和性能。

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

在用户注册或修改密码时，密码会被加密后存储在数据库中：

public void registerUser(UserDto userDto) {
    String encodedPassword = passwordEncoder.encode(userDto.getPassword());
    // 存储加密后的密码
    userRepository.save(new User(userDto.getUsername(), encodedPassword));
}

7.4 Spring Security中的会话管理

对于基于会话的应用，Spring Security 提供了全面的会话管理功能。可以限制同一用户的并发登录次数、管理会话超时以及防止会话固定攻击（Session Fixation Attack）。

7.4.1 限制并发会话

可以通过配置 maximumSessions 限制同一用户的并发会话数：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.sessionManagement()
            .maximumSessions(1)
            .maxSessionsPreventsLogin(true);  // 阻止用户超过最大会话数登录
    }
}

7.4.2 防止会话固定攻击

Spring Security 默认提供了防止会话固定攻击的保护措施，每次用户认证成功后，系统会创建一个新的会话 ID，避免旧会话被恶意利用：

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.sessionManagement().sessionFixation().newSession();
}

7.5 OAuth2 与 JWT 实现认证

在分布式微服务架构或移动应用开发中，OAuth2 和 JWT（JSON Web Token）成为了实现身份认证和授权的主要方式。Spring Boot 提供了对 OAuth2 和 JWT 的内置支持，使开发者能够方便地实现基于令牌的认证和授权。

7.5.1 OAuth2 集成

Spring Security 通过 spring-boot-starter-oauth2-client 依赖，可以快速集成 OAuth2 认证机制。例如，集成 Google OAuth2 实现登录：

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

在 application.properties 文件中配置 OAuth2 客户端信息：

spring.security.oauth2.client.registration.google.client-id=your-client-id
spring.security.oauth2.client.registration.google.client-secret=your-client-secret
spring.security.oauth2.client.registration.google.scope=openid,profile,email
spring.security.oauth2.client.provider.google.authorization-uri=https://accounts.google.com/o/oauth2/auth
spring.security.oauth2.client.provider.google.token-uri=https://oauth2.googleapis.com/token

通过 @EnableOAuth2Client 注解启用 OAuth2 客户端功能。

7.5.2 使用 JWT 实现分布式认证

JWT 是一种轻量级的、安全的、基于令牌的认证机制，广泛应用于无状态的 REST API 中。Spring Security 可以与 JWT 结合使用，实现分布式系统中的认证

8. 进阶：Spring Boot 的监控与运维

Spring Boot 提供了丰富的监控与运维工具，尤其是通过 Spring Boot Actuator 和集成其他第三方监控工具（如 Prometheus、Grafana、ELK Stack 等）来实现这些功能。Spring Boot 应用的稳定运行和高效运维至关重要。为了确保系统的健壮性和可靠性，监控与运维工具能够帮助开发者了解应用的运行状态，识别潜在问题，并在出现问题时迅速定位和解决。

8.1 Spring Boot Actuator

Spring Boot Actuator 是 Spring Boot 提供的一个内置模块，旨在帮助开发者对应用进行监控和运维。它提供了大量的端点（endpoints），通过这些端点可以轻松获取应用的健康状态、配置信息、日志等。

8.1.1 Actuator 配置

要启用 Actuator，只需在 pom.xml 文件中添加如下依赖：

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

8.1.2 常见端点

Actuator 提供了多个用于监控和管理的端点。以下是一些常见的端点及其用途：

/actuator/health：显示应用的健康状态，可以扩展以提供自定义的健康检查。
/actuator/info：显示应用的基本信息，如版本、描述等。
/actuator/metrics：提供应用的各种度量信息，如内存使用情况、GC 状况、请求次数等。
/actuator/env：查看应用的环境属性及配置信息。
/actuator/loggers：动态查看和更改应用的日志级别。
/actuator/httptrace：显示最近的 HTTP 请求追踪记录。
/actuator/threaddump：获取线程 dump 信息，用于分析应用的线程状态。

这些端点默认对外是关闭的，开发者可以在 application.properties 文件中进行配置。例如，启用 /health 和 /metrics 端点：

management.endpoints.web.exposure.include=health,metrics

8.1.3 自定义健康检查

Spring Boot Actuator 支持自定义健康检查逻辑。例如，检查应用与数据库的连接状态：

@Component
public class DatabaseHealthIndicator extends AbstractHealthIndicator {

    @Autowired
    private DataSource dataSource;

    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        try (Connection conn = dataSource.getConnection()) {
            if (conn.isValid(1000)) {
                builder.up().withDetail("Database", "Up and running");
            } else {
                builder.down().withDetail("Database", "Connection issue");
            }
        } catch (Exception e) {
            builder.down(e);
        }
    }
}

这样，当访问 /actuator/health 端点时，应用的健康状态会包含数据库连接状态的信息。

8.1.4 安全配置

Actuator 提供的端点包含敏感信息，因此在生产环境中，需要对这些端点进行访问控制。可以通过 Spring Security 保护这些端点，只允许授权用户访问：

management.endpoints.web.exposure.include=health,metrics
management.endpoint.health.probes.enabled=true
management.endpoints.web.base-path=/manage
spring.security.user.name=admin
spring.security.user.password=secret

8.2 集成 Prometheus 和 Grafana

Prometheus 是一个开源的监控和报警系统，它可以通过 metrics 端点收集应用的度量数据。Grafana 是一个可视化工具，通常与 Prometheus 配合使用，以提供图形化的监控数据展示。

8.2.1 配置 Prometheus

首先，确保 Actuator 的 metrics 端点可用，并且可以被 Prometheus 访问。在 application.properties 文件中配置：

management.endpoints.web.exposure.include=metrics
management.metrics.export.prometheus.enabled=true

然后，在 Prometheus 的配置文件中添加 Spring Boot 应用的地址：

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

8.2.2 使用 Grafana 可视化

安装和启动 Grafana 后，可以通过添加 Prometheus 数据源来创建仪表盘，以展示来自 Spring Boot 应用的度量数据。Grafana 提供了许多现成的仪表盘模板，方便快速展示 CPU 使用率、内存占用、请求速率等指标。

8.3 ELK Stack 日志监控

ELK Stack 是 Elasticsearch、Logstash 和 Kibana 的组合，常用于日志监控和分析。通过将 Spring Boot 的日志输出到 ELK Stack，可以实时监控应用的日志并进行复杂的日志查询。

8.3.1 配置 Logstash

首先，在 Spring Boot 中配置 logback，将日志输出到 Logstash。编辑 logback-spring.xml 文件：

<appender name="logstash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
    <destination>localhost:5000</destination>
    <encoder class="net.logstash.logback.encoder.LogstashEncoder" />
</appender>

<root level="INFO">
    <appender-ref ref="logstash" />
</root>

然后配置 Logstash 接收来自 Spring Boot 应用的日志：

input {
    tcp {
        port => 5000
        codec => json_lines
    }
}

output {
    elasticsearch {
        hosts => ["http://localhost:9200"]
        index => "spring-boot-logs-%{+YYYY.MM.dd}"
    }
    stdout { codec => rubydebug }
}

8.3.2 使用 Kibana 可视化

启动 Elasticsearch、Logstash 和 Kibana 后，可以通过 Kibana 的界面来查看和搜索日志。在 Kibana 中创建索引模式 spring-boot-logs-*，即可开始分析日志数据。

8.4 分布式跟踪

在分布式系统中，追踪一个请求如何在多个微服务之间流动非常重要。Spring Boot 提供了与分布式跟踪工具（如 Zipkin、Jaeger）的集成。

8.4.1 使用 Spring Cloud Sleuth 和 Zipkin

Spring Cloud Sleuth 为应用添加唯一的追踪 ID，自动记录每个服务间请求的传播情况，Zipkin 则用来收集和展示这些追踪数据。

在 Spring Boot 项目中添加 Sleuth 和 Zipkin 依赖：

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

在 application.properties 中启用 Zipkin：

spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.probability=1.0

启动 Zipkin 服务器后，可以通过其 Web 界面查看每个请求在不同微服务间的传播情况，从而有效定位性能瓶颈或错误。

8.5 远程管理和调试

8.5.1 JMX 监控

Java Management Extensions (JMX) 是用于监控和管理 Java 应用的标准 API。Spring Boot 可以通过 JMX 暴露其内部状态，允许远程监控。

在 application.properties 中启用 JMX：

spring.jmx.enabled=true

然后，可以使用 JConsole 或 VisualVM 等工具远程连接到应用，查看内存使用情况、线程状态等信息。

8.5.2 远程调试

Spring Boot 支持通过 JVM 的远程调试功能对应用进行调试。在应用启动时添加 JVM 参数：

java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar myapp.jar

这样，可以通过 IDE（如 IntelliJ IDEA 或 Eclipse）远程连接到运行中的 Spring Boot 应用进行调试。

9. Spring Boot 微服务架构

9.1 Spring Cloud 简介

Spring Cloud 是基于 Spring Boot 的微服务框架，提供了微服务架构下的基础设施支持，如服务注册与发现、负载均衡、配置中心等。

9.2 服务注册与发现

通过 Spring Cloud Netflix 实现服务注册与发现，使用 Eureka 作为注册中心。

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

微服务篇，之后会单独写一篇文章，这里仅做简单介绍