# Spring Boot 3.x - 生产就绪的 Java 框架 ## 概述 Spring Boot 是一个固执己见的 Java 框架，用于以最少的配置构建生产就绪的应用程序。它提供自动配置、嵌入式服务器以及运行状况检查和指标等生产就绪功能。 **主要特点**： * 自动配置（合理的默认值） * 嵌入式服务器（Tomcat、Jetty、Undertow） * 使用@Autowired进行依赖注入 * Spring Data JPA用于数据库访问 * Spring Security 用于身份验证/授权 * 用于生产监控的执行器 * 内置测试支持 **要求**： * Java 17+（Spring Boot 3.x 至少需要 Java 17） * Maven 或 Gradle **快速入门**： # 从 Spring Initializr 创建项目卷曲 https://start.spring.io/starter.zip \ -d 类型=maven-项目 \ -d 语言=java \ -d bootVersion=3.2.0 \ -d 依赖项=web、data-jpa、postgresql、lombok、执行器 \ -d 名称=myapp \ -o myapp.zip && 解压缩 myapp.zip # 运行应用程序 cd myapp ./mvnw spring-boot:运行 ## 项目结构源代码/ ├── 主/ │ ├── java/com/example/myapp/ │ │ ├── MyappApplication.java # 主类 │ │ ├── config/ # @Configuration 类 │ │ ├── 控制器/ # @RestController 类 │ │ ├── service/ # @Service 类 │ │ ├──repository/ # @Repository 接口 │ │ ├── model/ # 实体类 │ │ ├── dto/ # 数据传输对象 │ │ └── 异常/ # 异常处理程序 │ └── 资源/ │ ├── application.yml # 配置 │ └── application-{profile}.yml # 配置文件特定的配置 └── 测试/ └── java/com/example/myapp/ # 测试类 ## 核心注解 ### 应用程序设置 // 主应用程序类 @SpringBootApplication // 组合@Configuration、@EnableAutoConfiguration、@ComponentScan 公共类 MyappApplication { 公共静态无效主（字符串[] args）{ SpringApplication.run(MyappApplication.class, args); } } ### 依赖注入 // 构造函数注入（推荐） @服务公共类用户服务{ 私有最终 UserRepository userRepository; 私人最终密码编码器密码编码器； // @Autowired 在单个构造函数上是可选的（Spring 4.3+）公共 UserService（UserRepository userRepository，PasswordEncoder 密码Encoder）{ this.userRepository = userRepository; this.passwordEncoder = 密码编码器； } } // 与龙目岛 @服务 @RequiredArgsConstructor // 为最终字段生成构造函数公共类用户服务{ 私有最终 UserRepository userRepository; 私人最终密码编码器密码编码器； } // 字段注入（避免在生产代码中） @服务公共类用户服务{ @Autowired 私有 UserRepository 用户存储库； // 更难测试 } ### 组件刻板印象 @Component // 通用组件 @Service // 业务逻辑层 @Repository // 数据访问层（启用异常转换） @Controller // MVC 控制器（返回视图） @RestController // REST API控制器（返回JSON） @Configuration // 带有@Bean方法的配置类 ## REST 控制器 ### 基本控制器 @RestController @RequestMapping("/api/v1/users") @RequiredArgsConstructor 公共类用户控制器{ 私有最终 UserService userService； // 获取 /api/v1/用户 @GetMapping 公共 ResponseEntity> getAllUsers() { 返回 ResponseEntity.ok(userService.findAll()); } // 获取 /api/v1/users/{id} @GetMapping("/{id}") 公共 ResponseEntity getUserById(@PathVariable Long id) { 返回 userService.findById(id) .map(ResponseEntity::ok) .orElse(ResponseEntity.notFound().build()); } // POST /api/v1/用户 @PostMapping 公共 ResponseEntity createUser(@Valid @RequestBody CreateUserRequest 请求) { UserDto 创建 = userService.create(request); URI 位置 = ServletUriComponentsBuilder .fromCurrentRequest() .path("/{id}") .buildAndExpand(创建的.getId()) .toUri(); 返回 ResponseEntity.created(location).body(created); } // PUT /api/v1/users/{id} @PutMapping("/{id}") 公共 ResponseEntity updateUser( @PathVariable长id， @Valid @RequestBody UpdateUserRequest 请求）{ 返回 ResponseEntity.ok(userService.update(id, request)); } // 删除 /api/v1/users/{id} @DeleteMapping("/{id}") 公共 ResponseEntity deleteUser(@PathVariable Long id) { userService.delete(id); 返回 ResponseEntity.noContent().build(); } // 获取 /api/v1/users/search?email=test@example.com @GetMapping("/搜索") 公共 ResponseEntity> searchUsers( @RequestParam(required = false) 字符串电子邮件， @RequestParam(defaultValue = "0") int 页， @RequestParam(defaultValue = "20") int size) { 返回 ResponseEntity.ok(userService.search(电子邮件、页面、大小)); } } ### 请求/响应 DTO // 请求 DTO 并进行验证 @数据公共类CreateUserRequest { @NotBlank(message = "电子邮件为必填项") @Email(message = "电子邮件格式无效") 私人字符串电子邮件； @NotBlank(message = "姓名为必填项") @Size(min = 2, max = 100, message = "名称必须为 2-100 个字符") 私有字符串名称； @NotBlank(message = "需要密码") @Size(min = 8, message = "密码必须至少为 8 个字符") 私有字符串密码； } // 响应DTO @数据 @Builder 公共类 UserDto { 私人长ID；私人字符串电子邮件；私有字符串名称；私有 LocalDateTime 创建于；私有 LocalDateTime 更新时间；公共静态UserDto fromEntity（用户用户）{ 返回 UserDto.builder() .id(用户.getId()) .email(用户.getEmail()) .name(用户名.getName()) .createdAt(user.getCreatedAt()) .updatedAt(user.getUpdatedAt()) .build(); } } ## 服务层 @服务 @RequiredArgsConstructor @Transactional(readOnly = true) // 默认为只读事务公共类用户服务{ 私有最终 UserRepository userRepository; 私人最终密码编码器密码编码器；公共列表 findAll() { 返回 userRepository.findAll().stream() .map(UserDto::fromEntity) .collect(Collectors.toList()); } 公共可选 findById（长id）{ 返回 userRepository.findById(id) .map(UserDto::fromEntity); } @Transactional // 读写事务公共 UserD 创建（CreateUserRequest 请求）{ if (userRepository.existsByEmail(request.getEmail())) { 抛出新的 EmailAlreadyExistsException(request.getEmail()); } 用户 user = User.builder() .email(请求.getEmail()) .name(请求.getName()) .passwordHash(passwordEncoder.encode(request.getPassword())) .build(); 返回 UserDto.fromEntity(userRepository.save(user)); } @事务性公共 UserDto 更新（长 ID，UpdateUserRequest 请求）{ 用户 user = userRepository.findById(id) .orElseThrow(() -> new UserNotFoundException(id)); if (request.getName() != null) { user.setName(request.getName()); } if (request.getEmail() != null) { user.setEmail(request.getEmail()); } 返回 UserDto.fromEntity(userRepository.save(user)); } @事务性公共无效删除（长ID）{ if (!userRepository.existsById(id)) { 抛出新的 UserNotFoundException(id); } userRepository.deleteById(id); } public List search(String email, int page, int size) { 可分页 pageable = PageRequest.of(page, size, Sort.by("createdAt").descending()); 页面<用户> 用户 = 电子邮件 != null ？ userRepository.findByEmailContainingIgnoreCase（电子邮件，可分页） : userRepository.findAll(可分页); 返回 users.stream() .map(UserDto::fromEntity) .collect(Collectors.toList()); } } ## 存储库层（Spring Data JPA） ### 基本存储库 @存储库公共接口 UserRepository 扩展 JpaRepository { // 派生查询方法可选<用户> findByEmail(字符串电子邮件); 布尔值existsByEmail（字符串电子邮件）； List<用户> findByNameContainingIgnoreCase(字符串名称); // 分页查询 Page<用户> findByEmailContainingIgnoreCase(String email, Pageable pageable); // 自定义 JPQL 查询 @Query("从用户 u WHERE u.createdAt > :date AND u.active = true 中选择 u") List findActiveUsersCreatedAfter(@Param("date") LocalDateTime date); // 原生 SQL 查询 @Query(value = "SELECT * FROM users WHERE email ILIKE %:email%", nativeQuery = true) List<用户> searchByEmail(@Param("email") String email); // 修改查询 @修改 @Query("更新用户 u SET u.active = false WHERE u.lastLoginAt < :date") int deactivateInactiveUsers(@Param("date") LocalDateTime date); } ### 实体类 @实体 @Table(名称=“用户”) @数据 @Builder @NoArgs构造函数 @AllArgsConstructor 公共类用户{ @Id @GenerateValue(策略 = GenerationType.IDENTITY) 私人长ID； @Column(nullable = false, unique = true) 私人字符串电子邮件； @Column(可为空 = false) 私有字符串名称； @Column(name = "password_hash", nullable = false) 私有字符串密码哈希； @Column(可为空 = false) @Builder.Default 私有布尔活动= true； @Column(name = "created_at", nullable = false, updateable = false) @CreationTimestamp 私有 LocalDateTime 创建于； @Column(name = "updated_at", nullable = false) @更新时间戳私有 LocalDateTime 更新时间； // 关系 @OneToMany（mappedBy =“用户”，级联= CascadeType.ALL，orphanRemoval = true） @Builder.Default private List posts = new ArrayList<>(); @ManyToMany(fetch = FetchType.LAZY) @JoinTable( 名称=“用户角色”， joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "role_id") ） @Builder.Default 私有 Set 角色 = new HashSet<>(); } ## 配置 ### application.yml 春天：应用：名称： myapp 数据源：网址：jdbc:postgresql://localhost:5432/mydb 用户名：${DB_USERNAME:postgres} 密码：${DB_PASSWORD:密码} 光：最大池大小：10 最小空闲：5 连接超时：30000 杰帕：休眠： ddl-auto: 验证 # 无、验证、更新、创建、创建-删除显示 sql: false 属性：休眠： format_sql: true 默认架构：公共简介：活动：${SPRING_PROFILES_ACTIVE:dev} 服务器：端口：${PORT:8080} 小服务程序：上下文路径：/api # 执行器端点管理：端点：网址：曝光：包括：健康、信息、指标、普罗米修斯端点：健康状况：显示详细信息：when_authorized # 自定义属性应用程序：智威汤逊：秘密：${JWT_SECRET:你的秘密密钥} 过期毫秒：86400000 ### 配置文件特定配置 # 应用程序-dev.yml 春天：杰帕：显示 sql: true 小时2：控制台：启用：真记录：级别： com.example.myapp：调试 org.springframework.web：调试 --- # 应用程序-prod.yml 春天：杰帕：显示 sql: false 属性：休眠：生成统计：假记录：级别： com.example.myapp：信息 org.springframework.web：警告 ### 配置属性类 @配置 @ConfigurationProperties（前缀=“app.jwt”） @数据公共类 JwtProperties { 私有字符串秘密；私人长期限女士； } // 用法 @服务 @RequiredArgsConstructor 公共类 JwtService { 私有最终 JwtProperties jwtProperties；公共字符串generateToken（用户用户）{ 返回 Jwts.builder() .setSubject(user.getEmail()) .setIssuedAt(新日期()) .setExpiration(new Date(System.currentTimeMillis() + jwtProperties.getExpirationMs())) .signWith(Keys.hmacShaKeyFor(jwtProperties.getSecret().getBytes())) .compact(); } } ## 异常处理 ### 全局异常处理程序 @RestControllerAdvice @Slf4j 公共类 GlobalExceptionHandler { // 处理验证错误 @ExceptionHandler(MethodArgumentNotValidException.class) 公共 ResponseEntity handleValidationErrors(MethodArgumentNotValidException ex) { List 错误 = ex.getBindingResult() .getFieldErrors() .stream() .map(错误 -> error.getField() + ": " + error.getDefaultMessage()) .collect(Collectors.toList()); ErrorResponse 响应 = ErrorResponse.builder() .status(HttpStatus.BAD_REQUEST.value()) .message("验证失败") .错误（错误） .timestamp(LocalDateTime.now()) .build(); 返回 ResponseEntity.badRequest().body(响应); } // 处理未找到的异常 @ExceptionHandler(ResourceNotFoundException.class) 公共 ResponseEntity handleNotFound(ResourceNotFoundException ex) { ErrorResponse 响应 = ErrorResponse.builder() .status(HttpStatus.NOT_FOUND.value()) .message(例如.getMessage()) .timestamp(LocalDateTime.now()) .build(); 返回 ResponseEntity.status(HttpStatus.NOT_FOUND).body(response); } // 处理业务逻辑异常 @ExceptionHandler(BusinessException.class) 公共 ResponseEntity handleBusinessException(BusinessException ex) { ErrorResponse 响应 = ErrorResponse.builder() .status(HttpStatus.CONFLICT.value()) .message(例如.getMessage()) .timestamp(LocalDateTime.now()) .build(); 返回 ResponseEntity.status(HttpStatus.CONFLICT).body(response); } // 捕获所有处理程序 @ExceptionHandler(Exception.class) 公共 ResponseEntity handleAllExceptions(Exception ex) { log.error("发生意外错误", ex); ErrorResponse 响应 = ErrorResponse.builder() .status(HttpStatus.INTERNAL_SERVER_ERROR.value()) .message("发生意外错误") .timestamp(LocalDateTime.now()) .build(); 返回 ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response); } } // 错误响应DTO @数据 @Builder 公共类错误响应{ 私有 int 状态；私有字符串消息；私有列表错误；私有 LocalDateTime 时间戳； } // 自定义异常公共类 ResourceNotFoundException 扩展 RuntimeException { 公共ResourceNotFoundException（字符串资源，长ID）{ super(String.format("%s 未找到 id: %d", 资源, id)); } } 公共类 UserNotFoundException 扩展 ResourceNotFoundException { 公共 UserNotFoundException（长 ID）{ 超级（“用户”，id）； } } ## 春季安全 ### 安全配置（Spring Security 6.x） @配置 @EnableWebSecurity @EnableMethodSecurity @RequiredArgsConstructor 公共类安全配置{ 私有最终 JwtAuthenticationFilter jwtAuthFilter; 私人最终 UserDetailsService userDetailsService; @豆子公共SecurityFilterChain securityFilterChain（HttpSecurity http）抛出异常{ http .csrf(csrf -> csrf.disable()) .sessionManagement(会话->会话 .sessionCreationPolicy(SessionCreationPolicy.STATELESS)) .authorizeHttpRequests(身份验证->身份验证 .requestMatchers("/api/v1/auth/**").permitAll() .requestMatchers("/actuator/health").permitAll() .requestMatchers("/api/v1/admin/**").hasRole("ADMIN") .anyRequest().authenticated()) .authenticationProvider(authenticationProvider()) .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class); 返回 http.build(); } @豆子公共 AuthenticationProvider 身份验证提供商() { DaoAuthenticationProvider 提供者 = new DaoAuthenticationProvider(); 提供者.setUserDetailsService(userDetailsService); 提供者.setPasswordEncoder(passwordEncoder()); 退货提供商； } @豆子公共密码编码器密码编码器（）{ 返回新的 BCryptPasswordEncoder(); } @豆子公共 AuthenticationManager 身份验证管理器（AuthenticationConfiguration config）抛出异常{ 返回 config.getAuthenticationManager(); } } ### JWT 过滤器 @组件 @RequiredArgsConstructor 公共类 JwtAuthenticationFilter 扩展 OncePerRequestFilter { 私有最终 JwtService jwtService; 私人最终 UserDetailsService userDetailsService; @覆盖受保护的无效 doFilterInternal( HttpServletRequest 请求， HttpServletResponse 响应， FilterChain filterChain) 抛出 ServletException, IOException { 最终 String authHeader = request.getHeader("授权"); if (authHeader == null || !authHeader.startsWith("Bearer")) { filterChain.doFilter(请求，响应); 返回; } 最终字符串 jwt = authHeader.substring(7); 最终字符串 userEmail = jwtService.extractUsername(jwt); if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) { UserDetails userDetails = userDetailsService.loadUserByUsername(userEmail); if (jwtService.isTokenValid(jwt, userDetails)) { 用户名密码验证令牌 authToken = 新的用户名密码验证令牌（用户详细信息，空， userDetails.getAuthorities()); authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); SecurityContextHolder.getContext().setAuthentication(authToken); } } filterChain.doFilter(请求，响应); } } ## 执行器端点 # 内置端点管理：端点：网址：曝光：包括：健康、信息、指标、普罗米修斯、env 基本路径：/actuator 端点：健康状况：显示详细信息：when_authorized 探头： enabled: true # Kubernetes 活跃/就绪探针信息：环境：启用：真 # 应用信息信息：应用程序：名称：${spring.application.name} 版本：'@project.version@' 爪哇：版本：${java.version} **常见执行器端点**： * `GET /actuator/health` \- 应用程序运行状况 * `GET /actuator/health/liveness` \- Kubernetes 活跃度探针 * `GET /actuator/health/readiness` \- Kubernetes 就绪探针 * `GET /actuator/info` \- 应用程序信息 * `GET /actuator/metrics` \- 指标列表 * `GET /actuator/metrics/{name}` \- 具体指标 * `GET /actuator/prometheus` \- Prometheus 格式指标 ## 测试 ### 单元测试控制器 @WebMvcTest(UserController.class) 类 UserControllerTest { @Autowired 私人 MockMvc 模拟Mvc； @MockBean 私有 UserService 用户服务； @Autowired 私有 ObjectMapper 对象映射器； @测试 void shouldReturnUserById() 抛出异常 { UserDto 用户 = UserDto.builder() .id(1L) .email("test@example.com") .name("测试用户") .build(); when(userService.findById(1L)).thenReturn(Optional.of(user)); mockMvc.perform(get("/api/v1/users/1")) .andExpect(status().isOk()) .andExpect(jsonPath("$.id").value(1)) .andExpect(jsonPath("$.email").value("test@example.com")); } @测试 void shouldReturn404WhenUserNotFound() 抛出异常 { when(userService.findById(999L)).thenReturn(Optional.empty()); mockMvc.perform(get("/api/v1/users/999")) .andExpect(status().isNotFound()); } @测试 void shouldCreateUser() 抛出异常 { CreateUserRequest 请求 = new CreateUserRequest(); request.setEmail("new@example.com"); request.setName("新用户"); request.setPassword("密码123"); 创建的 UserDto = UserDto.builder() .id(1L) .email("new@example.com") .name("新用户") .build(); when(userService.create(any())).thenReturn(创建); mockMvc.perform(post("/api/v1/users") .contentType(MediaType.APPLICATION_JSON) .content(objectMapper.writeValueAsString(请求))) .andExpect(status().isCreated()) .andExpect(jsonPath("$.email").value("new@example.com")); } } ### 集成测试 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) @AutoConfigureTestDatabase（替换= AutoConfigureTestDatabase.Replace.ANY） @事务性类用户集成测试{ @Autowired 私有 TestRestTemplate 休息模板； @Autowired 私有 UserRepository 用户存储库； @测试无效shouldCreateAndRetrieveUser() { CreateUserRequest 请求 = new CreateUserRequest(); request.setEmail("integration@test.com"); request.setName("集成测试"); request.setPassword("密码123"); ResponseEntity createResponse =restTemplate.postForEntity( “/api/v1/users”，请求，UserDto.class）； assertThat(createResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED); assertThat(createResponse.getBody()).isNotNull(); assertThat(createResponse.getBody().getEmail()).isEqualTo("integration@test.com"); Long userId = createResponse.getBody().getId(); ResponseEntity getResponse =restTemplate.getForEntity( "/api/v1/users/" + userId, UserDto.class); assertThat(getResponse.getStatusCode()).isEqualTo(HttpStatus.OK); assertThat(getResponse.getBody().getName()).isEqualTo("集成测试"); } } ### 存储库测试 @DataJpaTest 类 UserRepositoryTest { @Autowired 私有 UserRepository 用户存储库； @Autowired 私有 TestEntityManager 实体管理器； @测试无效应该FindByEmail（）{ 用户 user = User.builder() .email("test@example.com") .name("测试") .passwordHash("哈希") .build(); EntityManager.persistAndFlush(用户); 可选<用户>找到= userRepository.findByEmail(“test@example.com”); assertThat(找到).isPresent(); assertThat(found.get().getName()).isEqualTo("测试"); } } ## 最佳实践 ### 1\.使用构造函数注入 // 更喜欢使用 Final 字段进行构造函数注入 @服务 @RequiredArgsConstructor 公共类用户服务{ 私有最终 UserRepository userRepository; // 最终 = 不可变 } ### 2\.层分离 // 控制器 -> 服务 -> 存储库 // API层的DTO，持久层的实体 // 切勿直接在 REST 响应中公开实体 ### 3\.交易管理 @服务 @Transactional(readOnly = true) // 默认只读公共类用户服务{ @Transactional // 写事务公共无效更新用户（）{} } ### 4\.配置外化 # 使用环境变量作为秘密春天：数据源：密码: ${DB_PASSWORD} # 来自环境 ### 5\.错误处理 // 使用@RestControllerAdvice进行全局异常处理 // 返回一致的错误响应 // 切勿在生产中暴露内部细节 ## 资源 * **Spring Boot 文档** : * **Spring Data JPA**： * **Spring Security**： * **Spring初始化**： * **Baeldung 教程** : ## 相关技能使用 Spring Boot 时，请考虑以下补充技能： * **mongodb** ：NoSQL 数据库与 Spring Data MongoDB 集成 * **docker** ：容器化 Spring Boot 应用程序 * **kubernetes** ：部署 Spring Boot 微服务 * **postgresql** ：使用 JPA 的关系数据库模式

春季启动

包含技能