Spring Boot全面详解：从入门到实战开发

第1章 Spring Boot开发入门

1.1 学习目标

• 掌握Spring Boot核心概念和优势

• 能够独立创建Spring Boot项目

• 理解Spring Boot自动配置原理

• 熟悉项目启动执行流程

1.2 Spring Boot概述

核心价值：

• 简化配置：约定优于配置，零XML配置

• 快速启动：内嵌Web服务器，一键运行

• 生产就绪：提供健康检查、指标监控等

• 微服务基石：为云原生应用提供完美支持

版本演进：Spring Boot 2.x → 3.x，基于Spring Framework 6.x，要求JDK 17+

1.3 开发环境

必需环境：

2.2 全局配置文件

两种格式：

• JDK 17或更高版本

• Maven 3.6+ 或 Gradle 7.x

• IDE：IntelliJ IDEA（推荐）或 Eclipse STS

• 构建工具：Maven/Gradle
   

  环境验证：

  bash
  java -version
  mvn -v
   

  1.4 项目创建
  四种创建方式：

  Spring Initializr（推荐）

  bash
  # 访问 https://start.spring.io/
  # 选择：Maven、Java、Spring Boot 3.x
  # 依赖：Spring Web、Spring Data JPA、MySQL Driver等
  IDE集成创建

  IntelliJ：New Project → Spring Initializr

  Eclipse：New → Spring Starter Project

  命令行创建

  bash
  curl https://start.spring.io/starter.zip -d dependencies=web,jpa -d type=maven-project -o demo.zip
  手动创建

  创建Maven项目

  添加Spring Boot父依赖

  编写启动类
   

  标准项目结构：

  text
  src/
  ├── main/
  │   ├── java/com/example/demo/
  │   │   ├── DemoApplication.java
  │   │   ├── controller/
  │   │   ├── service/
  │   │   ├── repository/
  │   │   └── entity/
  │   └── resources/
  │       ├── static/
  │       ├── templates/
  │       ├── application.properties
  │       └── application-dev.properties
  └── test/
      └── java/com/example/demo/
  1.5 原理分析
  核心机制：

  起步依赖(Starter Dependencies)

  xml
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- 自动传递依赖：spring-mvc, tomcat, jackson等 -->
  自动配置(Auto-Configuration)

  基于@EnableAutoConfiguration注解

  通过spring.factories文件加载配置类

  使用条件注解控制配置生效

  条件注解详解：

  @ConditionalOnClass：类路径存在时生效

  @ConditionalOnMissingBean：不存在Bean时生效

  @ConditionalOnProperty：配置属性满足时生效

  @ConditionalOnWebApplication：Web应用时生效

  1.6 执行流程
  启动过程深度解析：

• 启动步骤：

  • 加载META-INF/spring.factories

  • 执行ApplicationContextInitializer

  • 创建ApplicationContext

  • 执行自动配置

  • 启动内嵌Web服务器

  • 发布ApplicationReadyEvent

• @SpringBootApplication分解：

  第2章 核心配置和注解

  2.1 学习目标

• 掌握全局配置文件的使用

• 理解属性值注入的多种方式

• 能够进行多环境配置

• application.properties
  

YAML优势：层次清晰、支持复杂数据结构、可读性强

2.3 属性值注入

三种注入方式：

第4-12章 高级特性

4. 版本控制（Git）

Git基础操作：

• @Value注解
• ​编辑
• ​编辑

• Profile激活方式：

  配置文件：spring.profiles.active=dev

  命令行：java -jar app.jar --spring.profiles.active=prod

  系统环境变量：SPRING_PROFILES_ACTIVE=prod

  2.5 项目分层（新版最佳实践）
  现代分层架构：

  text
  com.example.app
  ├── Application.java              # 启动类
  ├── config/                      # 配置类
  ├── controller/                  # 控制层
  ├── service/                     # 业务层
  ├── repository/                  # 数据访问层  
  ├── entity/                      # 实体类
  ├── dto/                         # 数据传输对象
  ├── vo/                          # 视图对象
  └── util/                        # 工具类
  分层职责：

  Controller：接收请求，参数校验，返回响应

  Service：业务逻辑处理，事务控制

  Repository：数据持久化操作

  Entity：数据表映射对象

  2.6 测验和小结
  配置优先级（从高到低）：

  命令行参数

  Java系统属性

  操作系统环境变量

  项目外部的配置文件

  项目内部的配置文件

  第3章 数据访问
  3.1 学习目标
  掌握Spring Boot数据访问的多种方式

  能够整合JDBC、MyBatis、JPA等ORM框架

  理解事务管理机制

  能够完成实际业务的数据操作

  3.2 基础知识
  数据访问技术栈：

  JDBC：Java数据库连接标准

  JdbcTemplate：Spring对JDBC的轻量封装

  MyBatis：半自动ORM框架，SQL灵活可控

  JPA：Java持久化API标准规范

  Spring Data JPA：基于JPA的Repository抽象

  3.3 JDBC读取和写入数据
  配置数据源：

  3.5 Spring Data JPA数据持久化
  JPA核心概念：

  Entity：实体类，映射数据库表

  Repository：数据访问接口

  EntityManager：实体管理器

  实体类示例：
  @Entity
  @Table(name = "users")
  @Data
  public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      
      @Column(name = "user_name", length = 50, nullable = false)
      private String userName;
      
      private String email;
      
      @CreationTimestamp
      private LocalDateTime createTime;
      
      @UpdateTimestamp  
      private LocalDateTime updateTime;
  }
   

  Repository接口：

  java
  public interface UserRepository extends JpaRepository<User, Long> {
      
      // 方法名自动推导查询
      List<User> findByUserName(String userName);
      
      List<User> findByEmailContaining(String email);
      
      @Query("SELECT u FROM User u WHERE u.createTime > :startDate")
      List<User> findRecentUsers(@Param("startDate") LocalDateTime startDate);
      
      @Modifying
      @Query("UPDATE User u SET u.email = :email WHERE u.id = :id")
      int updateEmail(@Param("id") Long id, @Param("email") String email);
  }
   

  3.6 Redis整合
  Redis配置：

  yaml
  spring:
    redis:
      host: localhost
      port: 6379
      password: 
      database: 0
      lettuce:
        pool:
          max-active: 8
          max-wait: -1ms
          max-idle: 8
          min-idle: 0
  使用RedisTemplate：

  java
  @Service
  public class RedisService {
      
      @Autowired
      private RedisTemplate<String, Object> redisTemplate;
      
      public void set(String key, Object value, long timeout) {
          redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
      }
      
      public Object get(String key) {
          return redisTemplate.opsForValue().get(key);
      }
      
      public void delete(String key) {
          redisTemplate.delete(key);
      }
  }
  3.7-3.12 实战任务详解
  任务3.1：角色管理（JdbcTemplate）

  java
  @Service
  public class RoleService {
      
      @Autowired
      private JdbcTemplate jdbcTemplate;
      
      public List<Role> findAllRoles() {
          String sql = "SELECT * FROM roles WHERE status = 1";
          return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Role.class));
      }
      
      public void addRole(Role role) {
          String sql = "INSERT INTO roles(role_name, description) VALUES(?, ?)";
          jdbcTemplate.update(sql, role.getRoleName(), role.getDescription());
      }
  }
  任务3.2：部门管理（MyBatis/MyBatis-Plus）
  MyBatis-Plus配置：

  java
  @Configuration
  @MapperScan("com.example.mapper")
  public class MybatisPlusConfig {
      
      @Bean
      public MybatisPlusInterceptor mybatisPlusInterceptor() {
          MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
          interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
          return interceptor;
      }
  }
  部门Mapper接口：

  java
  public interface DepartmentMapper extends BaseMapper<Department> {
      // 继承BaseMapper即拥有基本CRUD方法
      List<Department> selectByParentId(Long parentId);
  }
  任务3.3：资产类型管理（JPA）

  java
  @Entity
  @Table(name = "asset_type")
  @Data
  public class AssetType {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      
      private String typeName;
      private String description;
      
      @OneToMany(mappedBy = "assetType", cascade = CascadeType.ALL)
      private List<Asset> assets;
  }

  public interface AssetTypeRepository extends JpaRepository<AssetType, Long> {
      List<AssetType> findByTypeNameContaining(String typeName);
  }
  任务3.4：权限管理（事务管理）
  声明式事务：

  java
  @Service
  @Transactional
  public class PermissionService {
      
      @Autowired
      private PermissionRepository permissionRepository;
      
      @Autowired
      private RolePermissionRepository rolePermissionRepository;
      
      @Transactional(rollbackFor = Exception.class)
      public void updatePermissions(Long roleId, List<Long> permissionIds) {
          // 删除原有权限
          rolePermissionRepository.deleteByRoleId(roleId);
          
          // 添加新权限
          for (Long permissionId : permissionIds) {
              RolePermission rolePermission = new RolePermission();
              rolePermission.setRoleId(roleId);
              rolePermission.setPermissionId(permissionId);
              rolePermissionRepository.save(rolePermission);
          }
      }
  }
   

  事务传播行为：

• REQUIRED（默认）：当前有事务则加入，没有则新建

• REQUIRES_NEW：新建事务，挂起当前事务

• NESTED：嵌套事务

• SUPPORTS：有事务则加入，没有则以非事务运行

• 5. 单元测试
  Spring Boot测试：

  

  6. 视图技术（Thymeleaf）
  Thymeleaf配置：
  yaml
  spring:
    thymeleaf:
      prefix: classpath:/templates/
      suffix: .html
      mode: HTML
      encoding: UTF-8
      cache: false # 开发时关闭缓存

基本语法：

html
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title th:text="${pageTitle}">默认标题</title>
</head>
<body>
    <div th:each="user : ${users}">
        <span th:text="${user.userName}">用户名</span>
        <span th:text="${user.email}">邮箱</span>
    </div>
    
    <form th:action="@{/users}" method="post">
        <input type="text" th:name="userName" />
        <button type="submit">提交</button>
    </form>
</body>
</html>
 

7. Web应用开发
RESTful API开发：

java
@RestController
@RequestMapping("/api/users")
@Validated
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping
    public ResponseEntity<List<User>> listUsers(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        Page<User> users = userService.getUsers(page, size);
        return ResponseEntity.ok(users.getContent());
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
        User savedUser = userService.createUser(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, 
                                         @Valid @RequestBody User user) {
        User updatedUser = userService.updateUser(id, user);
        return ResponseEntity.ok(updatedUser);
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}
 

文件上传下载：

java
@RestController
public class FileController {
    
    @PostMapping("/upload")
    public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return ResponseEntity.badRequest().body("文件为空");
        }
        
        try {
            String fileName = file.getOriginalFilename();
            Path path = Paths.get("uploads/" + fileName);
            Files.createDirectories(path.getParent());
            Files.write(path, file.getBytes());
            return ResponseEntity.ok("文件上传成功: " + fileName);
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("文件上传失败");
        }
    }
    
    @GetMapping("/download/{filename:.+}")
    public ResponseEntity<Resource> downloadFile(@PathVariable String filename) {
        try {
            Path path = Paths.get("uploads/" + filename);
            Resource resource = new UrlResource(path.toUri());
            
            return ResponseEntity.ok()
                    .header(HttpHeaders.CONTENT_DISPOSITION, 
                           "attachment; filename=\"" + filename + "\"")
                    .body(resource);
        } catch (Exception e) {
            return ResponseEntity.notFound().build();
        }
    }
}
 

8. 缓存管理

Spring Cache抽象：

9. Spring Security安全管理
安全配置：

java
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/public/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/dashboard")
                .permitAll()
            )
            .logout(logout -> logout
                .logoutSuccessUrl("/login?logout")
                .permitAll()
            )
            .rememberMe(remember -> remember
                .tokenValiditySeconds(7 * 24 * 60 * 60) // 7天
            );
        
        return http.build();
    }
    
    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.withUsername("user")
                .password(passwordEncoder().encode("password"))
                .roles("USER")
                .build();
        
        UserDetails admin = User.withUsername("admin")
                .password(passwordEncoder().encode("admin"))
                .roles("ADMIN")
                .build();
        
        return new InMemoryUserDetailsManager(user, admin);
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
 

自定义用户认证：

java
@Service
public class CustomUserDetailsService implements UserDetailsService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("用户不存在: " + username));
        
        return org.springframework.security.core.userdetails.User.builder()
                .username(user.getUsername())
                .password(user.getPassword())
                .authorities(getAuthorities(user.getRoles()))
                .accountExpired(false)
                .accountLocked(false)
                .credentialsExpired(false)
                .disabled(!user.isEnabled())
                .build();
    }
    
    private Collection<? extends GrantedAuthority> getAuthorities(Collection<Role> roles) {
        return roles.stream()
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role.getName()))
                .collect(Collectors.toList());
    }
}
10. 附录A：Spring Boot注解大全
核心注解：

@SpringBootApplication：主启动类注解

@RestController：RESTful控制器

@Service：业务层组件

@Repository：数据访问层组件

@Component：通用组件

配置相关：

@Configuration：配置类

@Bean：声明Bean

@Value：属性注入

@ConfigurationProperties：批量属性绑定

Web相关：

@RequestMapping：请求映射

@GetMapping/@PostMapping等：特定请求映射

@RequestParam：请求参数

@PathVariable：路径变量

@RequestBody：请求体

@ResponseBody：响应体

数据相关：

@Entity：JPA实体

@Table：表映射

@Id：主键

@GeneratedValue：主键生成策略

@Column：列映射

@Transactional：事务管理

测试相关：

@SpringBootTest：Spring Boot测试

@Test：测试方法

@MockBean：Mock Bean

11. 附录B：Git基础
常用命令：

bash
# 仓库操作
git init
git clone <url>

# 基础操作
git status
git add <file>
git commit -m "message"
git log

# 分支操作
git branch
git checkout <branch>
git merge <branch>

# 远程操作
git remote add origin <url>
git push -u origin main
git pull

总结

Spring Boot通过其强大的自动配置、起步依赖和约定优于配置的理念，极大地简化了Spring应用的开发和部署。本文从入门到实战，全面覆盖了：

---

• 核心机制：自动配置、起步依赖、外部化配置

• 数据访问：JdbcTemplate、MyBatis、JPA、Redis等多种方案

• Web开发：RESTful API、文件上传、异常处理

• 高级特性：缓存、安全、测试、视图技术

• 生产就绪：监控、部署、多环境配置
  我的Spring Boot学习心路
   

  回想起最初学习传统SSH、SSM框架的日子，仿佛陷入了一场无尽的“配置战争”。各种XML配置文件错综复杂，依赖冲突让人头疼不已，一个简单的Web项目启动就要耗费大量时间在环境搭建上。

  而Spring Boot的出现，对我而言不仅仅是一个新框架，更是一种开发理念的革新。

  1. “懒人”的智慧：约定优于配置
  Spring Boot最深得我心的就是“约定优于配置”的理念。它并不是鼓励程序员偷懒，而是通过智能的默认值，让我们从重复劳动的苦役中解放出来，专注于真正的业务逻辑。记得第一次使用spring-boot-starter-web时，我只是引入了一个依赖，整个Web环境就自动配好了，那种惊喜感至今难忘。

  2. 站在巨人的肩膀上：起步依赖的哲学
  起步依赖(Starter)体现了软件工程中“复用”的最高境界。Spring Boot团队已经为我们精心挑选并测试了各个组件的最佳组合，我们无需再担心版本兼容性问题。这让我明白，优秀的开发者不仅要会写代码，更要懂得利用现有的优秀轮子。

  3. 渐进式复杂：从简单到复杂的光滑曲线
  Spring Boot的学习曲线非常平缓。你可以从一个最简单的@RestController开始，几分钟内就写出一个可运行的API。随着需求的复杂，再逐步引入数据库、缓存、安全等组件。这种“渐进式”的体验让学习过程充满了正反馈，而不是一开始就被复杂度吓退。

  4. 面向未来的设计：云原生时代的基石
  在学习微服务、容器化的过程中，我越发体会到Spring Boot设计的前瞻性。内嵌服务器、外部化配置、Actuator监控等功能，简直就是为云原生时代量身定制的。这让我意识到，学习Spring Boot不仅仅是掌握一个框架，更是为适应现代软件开发范式打下基础。

  总结感悟：
  Spring Boot教会我的不只是一个技术框架的使用，更重要的是一种工程化的思维方式：

  效率至上：自动化一切可以自动化的重复劳动

  用户体验：即使是开发者工具，良好的使用体验也至关重要

  生态思维：构建一个繁荣的生态系统比单个技术的强大更有价值

  务实主义：理论上的完美不如实际中的可用

  从最初的“这怎么可能”到现在的“这本来就该这样”，Spring Boot彻底改变了我对Java企业级开发的认知。它让Java在快速迭代的互联网时代重新焕发了活力，也让我们的开发工作变得更加愉悦和高效。