手把手教你从零搭建SpringBoot项目：超详细图文教程

手把手教你从零搭建SpringBoot项目：超详细图文教程

前言

SpringBoot作为当前Java领域最流行的微服务框架之一，以其"约定大于配置"的理念和[快速开发]的特点，深受开发者喜爱。无论你是Java初学者，还是有一定经验的开发者，掌握SpringBoot都是必备技能。本文将带你从零开始，一步步搭建一个完整的SpringBoot项目，并深入讲解其中的原理和最佳实践。

一、SpringBoot简介与优势

1.1 什么是SpringBoot？

SpringBoot是基于Spring框架的"脚手架"工具，它简化了基于Spring的应用开发。通过自动配置和起步依赖，开发者可以快速创建独立运行、生产级别的Spring应用程序。

1.2 SpringBoot的核心优势

· 快速启动：内置Tomcat、Jetty等Web容器，无需部署WAR包
· 自动配置：根据classpath中的jar包自动配置Bean
· 起步依赖：通过starter简化Maven/Gradle配置
· 无代码生成：无需XML配置，开箱即用
· 生产就绪：提供监控、健康检查等生产级特性

二、环境准备与工具安装

2.1 JDK安装与配置

SpringBoot 2.x需要JDK 1.8或更高版本，SpringBoot 3.x需要JDK 17或更高版本。

安装步骤：

1. 访问Oracle官网或OpenJDK官网下载JDK
2. 安装JDK并配置环境变量
3. 验证安装：在命令行执行 java -version

# 验证JDK安装
java -version
javac -version

运行项目并下载源码bash
123

2.2 开发工具选择与配置

推荐IDE：

· IntelliJ IDEA（推荐使用Ultimate版）
· Eclipse with Spring Tools
· VS Code with Java扩展

2.3 Maven安装与配置

# 下载Maven并解压
# 配置环境变量 MAVEN_HOME 和 PATH
# 验证安装
mvn -version

运行项目并下载源码bash
1234

2.4 数据库准备（可选）

· MySQL 5.7+/8.0
· PostgreSQL
· 其他支持的数据库

三、使用Spring Initializr快速创建项目

3.1 在线创建项目

1. 访问 start.spring.io
2. 选择项目配置：
   · Project: Maven Project
   · Language: Java
   · Spring Boot: 选择稳定版本（如3.1.0）
   · Project Metadata: 填写Group、Artifact等信息
   · Dependencies: 添加需要的起步依赖

3.2 使用IDE创建

IntelliJ IDEA创建步骤：

1. File → New → Project
2. 选择Spring Initializr
3. 配置项目信息
4. 选择依赖（Web、JPA、MySQL等）
5. 完成创建

3.3 使用命令行创建

curl https://start.spring.io/starter.zip \
  -d dependencies=web,data-jpa,mysql \
  -d groupId=com.example \
  -d artifactId=demo \
  -o demo.zip
unzip demo.zip

运行项目并下载源码bash
123456

四、手动创建SpringBoot项目

虽然推荐使用Spring Initializr，但了解手动创建过程有助于理解项目结构。

4.1 创建Maven项目结构

my-springboot-project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   └── resources/
│   │       ├── application.properties
│   │       ├── static/
│   │       └── templates/
│   └── test/
│       └── java/
│           └── com/example/demo/
└── pom.xml

运行项目并下载源码
12345678910111213

4.2 配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <!-- Spring Boot父项目，提供依赖管理 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.0</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <!-- Web开发起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 测试起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 热部署依赖（开发时使用） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Spring Boot Maven插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

运行项目并下载源码xml
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960

4.3 创建主应用类

package com.example.demo;

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

/**
 * SpringBoot应用主类
 * @SpringBootApplication 注解标识这是一个SpringBoot应用
 */
@SpringBootApplication
public class DemoApplication {
    
    public static void main(String[] args) {
        // 启动SpringBoot应用
        SpringApplication.run(DemoApplication.class, args);
    }
}

运行项目并下载源码java
运行
1234567891011121314151617

五、项目结构深度解析

5.1 标准项目目录结构

src/
├── main/
│   ├── java/              # Java源代码
│   │   └── com/example/demo/
│   │       ├── controller/     # 控制器层
│   │       ├── service/        # 业务逻辑层
│   │       ├── repository/     # 数据访问层
│   │       ├── entity/         # 实体类
│   │       ├── config/         # 配置类
│   │       └── DemoApplication.java  # 主应用类
│   └── resources/         # 资源文件
│       ├── static/        # 静态资源(css,js,图片)
│       ├── templates/     # 模板文件(thymeleaf,freemarker)
│       ├── application.properties    # 主配置文件
│       └── application-dev.properties # 开发环境配置
└── test/                  # 测试代码
    └── java/
        └── com/example/demo/

运行项目并下载源码
123456789101112131415161718

5.2 配置文件详解

application.properties:

# 应用配置
spring.application.name=demo

# 服务器配置
server.port=8080
server.servlet.context-path=/demo

# 日志配置
logging.level.com.example.demo=DEBUG
logging.file.name=logs/demo.log

# 开发环境配置
spring.profiles.active=dev

运行项目并下载源码properties
12345678910111213

application-dev.properties:

# 开发环境数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/demo_dev
spring.datasource.username=dev_user
spring.datasource.password=dev_password

# H2内存数据库（开发测试用）
# spring.datasource.url=jdbc:h2:mem:testdb
# spring.datasource.driverClassName=org.h2.Driver
# spring.datasource.username=sa
# spring.datasource.password=password

# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

运行项目并下载源码properties
123456789101112131415

六、编写第一个RESTful API

6.1 创建实体类

package com.example.demo.entity;

import java.time.LocalDateTime;

public class User {
    private Long id;
    private String username;
    private String email;
    private LocalDateTime createTime;
    
    // 构造方法
    public User() {}
    
    public User(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
        this.createTime = LocalDateTime.now();
    }
    
    // Getter和Setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    public LocalDateTime getCreateTime() { return createTime; }
    public void setCreateTime(LocalDateTime createTime) { this.createTime = createTime; }
}

运行项目并下载源码java
运行
123456789101112131415161718192021222324252627282930313233

6.2 创建控制器

package com.example.demo.controller;

import com.example.demo.entity.User;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 用户管理控制器
 * @RestController 组合了@Controller和@ResponseBody
 */
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final List<User> users = new ArrayList<>();
    private final AtomicLong counter = new AtomicLong();
    
    // 初始化一些测试数据
    public UserController() {
        users.add(new User(counter.incrementAndGet(), "张三", "zhangsan@example.com"));
        users.add(new User(counter.incrementAndGet(), "李四", "lisi@example.com"));
    }
    
    /**
     * 获取所有用户
     * GET /api/users
     */
    @GetMapping
    public List<User> getAllUsers() {
        return users;
    }
    
    /**
     * 根据ID获取用户
     * GET /api/users/{id}
     */
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return users.stream()
                .filter(user -> user.getId().equals(id))
                .findFirst()
                .orElse(null);
    }
    
    /**
     * 创建新用户
     * POST /api/users
     */
    @PostMapping
    public User createUser(@RequestBody User user) {
        user.setId(counter.incrementAndGet());
        users.add(user);
        return user;
    }
    
    /**
     * 更新用户信息
     * PUT /api/users/{id}
     */
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        User user = getUserById(id);
        if (user != null) {
            user.setUsername(userDetails.getUsername());
            user.setEmail(userDetails.getEmail());
        }
        return user;
    }
    
    /**
     * 删除用户
     * DELETE /api/users/{id}
     */
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id) {
        users.removeIf(user -> user.getId().equals(id));
        return "用户删除成功";
    }
}

运行项目并下载源码java
运行
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182

6.3 创建服务层

package com.example.demo.service;

import com.example.demo.entity.User;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

/**
 * 用户服务层
 * @Service 标识这是一个Spring服务组件
 */
@Service
public class UserService {
    
    /**
     * 模拟数据库操作 - 获取所有用户
     */
    public List<User> findAllUsers() {
        // 实际项目中这里会调用Repository
        return List.of(
            new User(1L, "张三", "zhangsan@example.com"),
            new User(2L, "李四", "lisi@example.com")
        );
    }
    
    /**
     * 根据ID查找用户
     */
    public Optional<User> findUserById(Long id) {
        // 模拟数据库查询
        return findAllUsers().stream()
                .filter(user -> user.getId().equals(id))
                .findFirst();
    }
    
    /**
     * 创建用户
     */
    public User createUser(User user) {
        // 模拟保存到数据库
        return user;
    }
}

运行项目并下载源码java
运行
1234567891011121314151617181920212223242526272829303132333435363738394041424344

6.4 更新控制器使用服务层

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/v2/users")
public class UserControllerV2 {
    
    private final UserService userService;
    
    /**
     * 构造器注入 - 推荐方式
     */
    @Autowired
    public UserControllerV2(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAllUsers();
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        Optional<User> user = userService.findUserById(id);
        return user.map(ResponseEntity::ok)
                  .orElse(ResponseEntity.notFound().build());
    }
    
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

运行项目并下载源码java
运行
123456789101112131415161718192021222324252627282930313233343536373839404142

七、数据库集成与JPA使用

7.1 添加数据库依赖

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

<!-- MySQL驱动 -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

<!-- H2数据库（测试用） -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

运行项目并下载源码xml
12345678910111213141516171819

7.2 配置数据源

# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/demo?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456

# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

# H2控制台（开发时使用）
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

运行项目并下载源码properties
12345678910111213

7.3 创建JPA实体

package com.example.demo.entity;

import jakarta.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true, length = 50)
    private String username;
    
    @Column(nullable = false, unique = true, length = 100)
    private String email;
    
    @Column(name = "create_time")
    private LocalDateTime createTime;
    
    // 构造方法
    public User() {
        this.createTime = LocalDateTime.now();
    }
    
    public User(String username, String email) {
        this();
        this.username = username;
        this.email = email;
    }
    
    // Getter和Setter
    // ... 省略getter/setter
}

运行项目并下载源码java
运行
123456789101112131415161718192021222324252627282930313233343536

7.4 创建Repository接口

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    // 根据用户名查找用户
    Optional<User> findByUsername(String username);
    
    // 根据邮箱查找用户
    Optional<User> findByEmail(String email);
    
    // 自定义查询：查找创建时间在指定时间之后的用户
    @Query("SELECT u FROM User u WHERE u.createTime > :createTime")
    List<User> findUsersAfterCreateTime(@Param("createTime") LocalDateTime createTime);
    
    // 检查用户名是否存在
    boolean existsByUsername(String username);
    
    // 检查邮箱是否存在
    boolean existsByEmail(String email);
}

运行项目并下载源码java
运行
123456789101112131415161718192021222324252627282930

7.5 更新服务层使用Repository

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class UserService {
    
    private final UserRepository userRepository;
    
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public List<User> findAllUsers() {
        return userRepository.findAll();
    }
    
    public Optional<User> findUserById(Long id) {
        return userRepository.findById(id);
    }
    
    public User saveUser(User user) {
        return userRepository.save(user);
    }
    
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
    
    public boolean existsByUsername(String username) {
        return userRepository.existsByUsername(username);
    }
    
    public boolean existsByEmail(String email) {
        return userRepository.existsByEmail(email);
    }
}

运行项目并下载源码java
运行
1234567891011121314151617181920212223242526272829303132333435363738394041424344

八、异常处理与统一响应

8.1 创建自定义异常

package com.example.demo.exception;

public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

public class BusinessException extends RuntimeException {
    public BusinessException(String message) {
        super(message);
    }
}

运行项目并下载源码java
运行
12345678910111213

8.2 创建统一响应对象

package com.example.demo.dto;

public class ApiResponse<T> {
    private boolean success;
    private String message;
    private T data;
    private String errorCode;
    
    // 成功响应
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(true, "操作成功", data, null);
    }
    
    public static <T> ApiResponse<T> success(String message, T data) {
        return new ApiResponse<>(true, message, data, null);
    }
    
    // 失败响应
    public static <T> ApiResponse<T> error(String message) {
        return new ApiResponse<>(false, message, null, null);
    }
    
    public static <T> ApiResponse<T> error(String message, String errorCode) {
        return new ApiResponse<>(false, message, null, errorCode);
    }
    
    // 构造方法、getter、setter
    public ApiResponse(boolean success, String message, T data, String errorCode) {
        this.success = success;
        this.message = message;
        this.data = data;
        this.errorCode = errorCode;
    }
    
    // ... 省略getter/setter
}

运行项目并下载源码java
运行
123456789101112131415161718192021222324252627282930313233343536

8.3 创建全局异常处理器

package com.example.demo.handler;

import com.example.demo.dto.ApiResponse;
import com.example.demo.exception.ResourceNotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

/**
 * 全局异常处理
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    /**
     * 处理资源不存在异常
     */
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ApiResponse<Object>> handleResourceNotFound(ResourceNotFoundException ex) {
        ApiResponse<Object> response = ApiResponse.error(ex.getMessage());
        return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
    }
    
    /**
     * 处理参数验证异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiResponse<Map<String, String>>> handleValidationExceptions(
            MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getAllErrors().forEach((error) -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.put(fieldName, errorMessage);
        });
        
        ApiResponse<Map<String, String>> response = ApiResponse.error("参数验证失败", "VALIDATION_ERROR");
        response.setData(errors);
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }
    
    /**
     * 处理其他所有异常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Object>> handleGlobalException(Exception ex) {
        ApiResponse<Object> response = ApiResponse.error("服务器内部错误");
        return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

运行项目并下载源码java
运行
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556

九、运行与测试

9.1 启动应用程序

方式一：使用IDE运行

· 直接运行主类的main方法

方式二：使用Maven命令

mvn spring-boot:run

运行项目并下载源码bash
1

方式三：打包后运行

mvn clean package
java -jar target/demo-1.0.0.jar

运行项目并下载源码bash
12

9.2 测试API接口

使用Postman或curl测试创建的API：

# 获取所有用户
curl -X GET http://localhost:8080/api/users

# 根据ID获取用户
curl -X GET http://localhost:8080/api/users/1

# 创建新用户
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"username":"王五","email":"wangwu@example.com"}'

# 更新用户
curl -X PUT http://localhost:8080/api/users/1 \
  -H "Content-Type: application/json" \
  -d '{"username":"张三丰","email":"zhangsanfeng@example.com"}'

# 删除用户
curl -X DELETE http://localhost:8080/api/users/1

运行项目并下载源码bash
123456789101112131415161718

9.3 编写单元测试

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import java.util.Arrays;
import java.util.Optional;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(UserControllerV2.class)
public class UserControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Test
    public void testGetAllUsers() throws Exception {
        User user1 = new User(1L, "user1", "user1@test.com");
        User user2 = new User(2L, "user2", "user2@test.com");
        
        when(userService.findAllUsers()).thenReturn(Arrays.asList(user1, user2));
        
        mockMvc.perform(get("/api/v2/users"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$[0].username").value("user1"))
                .andExpect(jsonPath("$[1].username").value("user2"));
    }
    
    @Test
    public void testGetUserById() throws Exception {
        User user = new User(1L, "testuser", "test@test.com");
        
        when(userService.findUserById(1L)).thenReturn(Optional.of(user));
        
        mockMvc.perform(get("/api/v2/users/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.username").value("testuser"));
    }
    
    @Test
    public void testCreateUser() throws Exception {
        User user = new User("newuser", "newuser@test.com");
        User savedUser = new User(1L, "newuser", "newuser@test.com");
        
        when(userService.saveUser(any(User.class))).thenReturn(savedUser);
        
        mockMvc.perform(post("/api/v2/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(user)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(1L));
    }
}

运行项目并下载源码java
运行
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

十、项目优化与最佳实践

10.1 配置文件优化

使用YAML格式配置：

# application.yml
spring:
  application:
    name: demo
  datasource:
    url: jdbc:mysql://localhost:3306/demo
    username: root
    password: 123456
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        format_sql: true

server:
  port: 8080
  servlet:
    context-path: /demo

logging:
  level:
    com.example.demo: DEBUG
  file:
    name: logs/demo.log

运行项目并下载源码yaml
123456789101112131415161718192021222324252627

10.2 多环境配置

# application-dev.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo_dev
    username: dev_user
    password: dev_password
  jpa:
    show-sql: true

---
# application-prod.yml
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/demo_prod
    username: prod_user
    password: ${DB_PASSWORD}
  jpa:
    show-sql: false

logging:
  level:
    com.example.demo: INFO

运行项目并下载源码yaml
12345678910111213141516171819202122

10.3 添加Swagger API文档

<!-- 添加依赖 -->
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.1.0</version>
</dependency>

运行项目并下载源码xml
123456

// 配置类
@Configuration
public class OpenApiConfig {
    
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("Demo API")
                        .version("1.0")
                        .description("SpringBoot Demo项目API文档")
                        .contact(new Contact().name("开发者").email("dev@example.com")));
    }
}

运行项目并下载源码java
运行
1234567891011121314

访问：http://localhost:8080/swagger-ui.html

十一、常见问题与解决方案

11.1 端口被占用

# 修改端口
server.port=8081

运行项目并下载源码properties
12

11.2 数据库连接失败

· 检查数据库服务是否启动
· 验证连接URL、用户名、密码
· 检查网络连接

11.3 依赖冲突

使用Maven依赖树分析：

mvn dependency:tree

运行项目并下载源码bash
1

11.4 热部署配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

运行项目并下载源码xml
123456

在IDE中开启自动编译。

十二、总结

通过本文的详细讲解，你应该已经掌握了：

1. SpringBoot项目创建：多种创建方式及其适用场景
2. 项目结构理解：标准的Maven目录结构和SpringBoot约定
3. 核心组件开发：Controller、Service、Repository的分层架构
4. 数据库集成：使用Spring Data JPA进行数据持久化
5. RESTful API设计：遵循REST原则设计清晰的API接口
6. 异常处理：统一的异常处理和响应格式
7. 测试策略：单元测试和集成测试的编写
8. 项目优化：配置文件管理、多环境配置等最佳实践

SpringBoot的强大之处在于它的"约定大于配置"理念和丰富的starter生态。掌握这些基础后，你可以继续深入学习SpringBoot的高级特性，如安全认证、消息队列、缓存、监控等，构建更加复杂和强大的应用程序。