创建 SpringBoot 应用

demo/
├── pom.xml                          # Maven 配置文件
├── src/
│   ├── main/
│   │   ├── java/                    # Java 源代码
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── demo/
│   │   │               ├── DemoApplication.java    # 启动类
│   │   │               ├── config/                 # 配置类
│   │   │               ├── controller/             # 控制器
│   │   │               ├── service/                # 服务层
│   │   │               │   └── impl/               # 服务实现
│   │   │               ├── repository/             # 数据访问层
│   │   │               ├── entity/                 # 实体类
│   │   │               ├── dto/                    # 数据传输对象
│   │   │               ├── vo/                     # 视图对象
│   │   │               ├── exception/              # 自定义异常
│   │   │               ├── util/                   # 工具类
│   │   │               └── common/                 # 公共类
│   │   └── resources/               # 资源文件
│   │       ├── application.yml      # 主配置文件
│   │       ├── application-dev.yml  # 开发环境配置
│   │       ├── application-prod.yml # 生产环境配置
│   │       ├── static/              # 静态资源(js,css,images)
│   │       ├── templates/           # 模板文件(Thymeleaf等)
│   │       ├── mapper/              # MyBatis XML 映射文件
│   │       └── logback-spring.xml   # 日志配置
│   └── test/
│       └── java/                    # 测试代码
│           └── com/
│               └── example/
│                   └── demo/
│                       └── DemoApplicationTests.java
└── target/                          # 编译输出目录

com.example.demo/
├── user/                    # 用户模块
│   ├── controller/
│   │   └── UserController.java
│   ├── service/
│   │   ├── UserService.java
│   │   └── impl/
│   │       └── UserServiceImpl.java
│   ├── repository/
│   │   └── UserMapper.java
│   ├── entity/
│   │   └── User.java
│   ├── dto/
│   │   └── UserDTO.java
│   └── vo/
│       └── UserVO.java
├── order/                   # 订单模块
│   ├── controller/
│   ├── service/
│   ├── repository/
│   ├── entity/
│   ├── dto/
│   └── vo/
├── config/                  # 公共配置
├── exception/               # 公共异常
├── util/                    # 公共工具
└── common/                  # 公共类

com.example.demo/
├── config/                  # 所有配置类
├── controller/              # 所有控制器
│   ├── UserController.java
│   └── OrderController.java
├── service/                 # 所有服务类
│   ├── UserService.java
│   ├── OrderService.java
│   └── impl/
│       ├── UserServiceImpl.java
│       └── OrderServiceImpl.java
├── repository/              # 所有数据访问类
│   ├── UserMapper.java
│   └── OrderMapper.java
├── entity/                  # 所有实体类
│   ├── User.java
│   └── Order.java
├── dto/                     # 所有DTO
├── vo/                      # 所有VO
├── exception/               # 所有异常
├── util/                    # 所有工具类
└── common/                  # 所有公共类

package com.example.demo;

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

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

@SpringBootApplication
↓ 等价于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

@SpringBootConfiguration
public class DemoApplication {
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

@Configuration
@ConditionalOnClass(DataSource.class)
public class DataSourceAutoConfiguration {
    // 数据源自动配置
}

com.example.demo/
├── DemoApplication.java        # 启动类
├── controller/                 # 被扫描
│   └── UserController.java
├── service/                    # 被扫描
│   └── UserService.java
└── config/                     # 被扫描
    └── WebConfig.java

@SpringBootApplication(scanBasePackages = "com.example")
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

main()
  ↓
SpringApplication.run()
  ↓
new SpringApplication()
  - 推断应用类型
  - 加载初始化器
  - 加载监听器
  ↓
run()
  - 准备环境
  - 打印 Banner
  - 创建 ApplicationContext
  - 准备上下文
  - 刷新上下文
    - 执行 BeanFactoryPostProcessor
    - 注册 BeanPostProcessor
    - 初始化单例 Bean
  - 刷新后处理
  - 发布启动完成事件
  ↓
应用启动完成

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v3.5.0)

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(DemoApplication.class);
        
        // 添加监听器
        app.addListeners((ApplicationListener<ApplicationStartedEvent>) event -> {
            System.out.println("应用启动中...");
        });
        
        app.run(args);
    }
}

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(DemoApplication.class);
        
        // 设置 Banner 模式
        app.setBannerMode(Banner.Mode.OFF);
        
        // 设置日志级别
        app.setLogStartupInfo(false);
        
        app.run(args);
    }
}

com.example.demo/
└── DemoApplication.java        # 启动类在根包下

com.example/
├── config/
│   └── DemoApplication.java    # 启动类不在根包
├── controller/
│   └── UserController.java     # 不会被扫描
└── service/
    └── UserService.java        # 不会被扫描

@SpringBootApplication(scanBasePackages = "com.example")
public class DemoApplication {
    // ...
}

# 键值对
server:
  port: 8080

# 嵌套对象
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

# 数组/列表
spring:
  profiles:
    active:
      - dev
      - test

# 数组简写
my:
  servers:
    - server1
    - server2
    - server3

server:
  port: 8080                    # 端口号
  servlet:
    context-path: /api          # 上下文路径
  tomcat:
    uri-encoding: UTF-8         # URI 编码
    threads:
      max: 200                  # 最大线程数
    accept-count: 100           # 等待队列长度

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource    # 数据源类型
    hikari:
      minimum-idle: 5            # 最小空闲连接数
      maximum-pool-size: 20      # 最大连接池大小
      connection-timeout: 30000  # 连接超时时间(毫秒)
      idle-timeout: 600000       # 空闲连接超时时间(毫秒)
      max-lifetime: 1800000      # 连接最大生命周期(毫秒)

spring:
  jpa:
    database: mysql
    # Hibernate 6(Boot 3.x)可自动探测方言；如显式指定应使用 MySQLDialect（MySQL8Dialect 已移除）
    database-platform: org.hibernate.dialect.MySQLDialect
    show-sql: true               # 显示 SQL
    hibernate:
      ddl-auto: update           # 自动建表策略
    properties:
      hibernate:
        format_sql: true         # 格式化 SQL
        use_sql_comments: true   # 显示 SQL 注释

mybatis:
  mapper-locations: classpath:mapper/*.xml    # Mapper XML 文件位置
  type-aliases-package: com.example.demo.entity    # 实体类别名包
  configuration:
    map-underscore-to-camel-case: true       # 驼峰命名转换
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl    # 日志实现

logging:
  level:
    root: INFO                   # 根日志级别
    com.example.demo: DEBUG      # 指定包日志级别
  file:
    name: logs/application.log   # 日志文件名
  logback:
    rollingpolicy:
      max-file-size: 10MB        # 单个文件最大大小
      max-history: 30            # 保留的历史归档数（按天滚动时即天数）
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

# Boot 3.x 起属性前缀迁移为 spring.data.redis.*（2.x 为 spring.redis.*）
spring:
  data:
    redis:
      host: localhost              # Redis 服务器地址
      port: 6379                   # Redis 服务器端口
      password:                    # Redis 密码
      database: 0                  # 数据库索引
      timeout: 5000                # 连接超时时间(毫秒)
      lettuce:
        pool:
          max-active: 8            # 连接池最大连接数
          max-wait: -1             # 连接池最大阻塞等待时间
          max-idle: 8              # 连接池最大空闲连接数
          min-idle: 0              # 连接池最小空闲连接数

spring:
  servlet:
    multipart:
      enabled: true              # 启用文件上传
      max-file-size: 10MB        # 单个文件最大大小
      max-request-size: 100MB    # 总文件最大大小
      file-size-threshold: 0     # 文件大小阈值

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo

server:
  port: 8081                    # 覆盖主配置

spring:
  datasource:
    username: dev               # 合并到主配置

server:
  port: 8081                    # 被覆盖

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo    # 来自主配置
    username: dev               # 来自 dev 配置

spring:
  profiles:
    active: dev

java -jar demo.jar --spring.profiles.active=prod

export SPRING_PROFILES_ACTIVE=prod
java -jar demo.jar

# 公共配置
spring:
  application:
    name: demo

---
# 开发环境
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:mysql://localhost:3306/demo_dev
    username: root
    password: 123456

---
# 生产环境
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://prod-server:3306/demo_prod
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

@RestController
public class UserController {
    
    @Value("${server.port}")
    private Integer port;
    
    @Value("${spring.datasource.url}")
    private String datasourceUrl;
    
    @GetMapping("/port")
    public String getPort() {
        return "Server port: " + port;
    }
}

@Component
@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
    private String name;
    private Integer timeout;
    private Security security;
    
    @Data
    public static class Security {
        private String username;
        private String password;
        private List<String> allowedOrigins;
    }
}

app:
  name: My Application
  timeout: 5000
  security:
    username: admin
    password: secret
    allowed-origins:
      - http://localhost:3000
      - https://example.com

@RestController
@RequiredArgsConstructor
public class UserController {
    
    private final AppProperties appProperties;
    
    @GetMapping("/app-name")
    public String getAppName() {
        return appProperties.getName();
    }
}

app:
  user-name: admin        # kebab-case(推荐)
  # user_name: admin      # 下划线
  # userName: admin       # camelCase

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String userName;    // 都可以绑定
}

@Component
@ConfigurationProperties(prefix = "app")
@Validated
@Data
public class AppProperties {
    @NotBlank(message = "应用名称不能为空")
    private String name;
    
    @Min(value = 1000, message = "超时时间不能小于1000毫秒")
    @Max(value = 60000, message = "超时时间不能大于60000毫秒")
    private Integer timeout;
    
    @Valid
    @NotNull
    private Security security;
    
    @Data
    public static class Security {
        @NotBlank(message = "用户名不能为空")
        private String username;
        
        @NotBlank(message = "密码不能为空")
        private String password;
    }
}

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

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

spring:
  devtools:
    restart:
      enabled: true                    # 启用热重启
      additional-paths: src/main/java  # 监控路径
      exclude: static/**,public/**     # 排除路径

user-management/
├── src/main/java/com/example/user/
│   ├── UserManagementApplication.java    # 启动类
│   ├── config/
│   │   └── WebConfig.java                # Web 配置
│   ├── controller/
│   │   └── UserController.java           # 用户控制器
│   ├── service/
│   │   ├── UserService.java              # 用户服务接口
│   │   └── impl/
│   │       └── UserServiceImpl.java      # 用户服务实现
│   ├── repository/
│   │   └── UserMapper.java               # 用户 Mapper
│   ├── entity/
│   │   └── User.java                     # 用户实体
│   ├── dto/
│   │   └── UserDTO.java                  # 用户 DTO
│   ├── vo/
│   │   └── UserVO.java                   # 用户 VO
│   ├── exception/
│   │   └── BusinessException.java        # 业务异常
│   └── common/
│       ├── Result.java                   # 统一返回结果
│       └── ErrorCode.java                # 错误码
├── src/main/resources/
│   ├── application.yml                   # 主配置
│   ├── application-dev.yml               # 开发配置
│   ├── mapper/
│   │   └── UserMapper.xml                # MyBatis XML
│   └── logback-spring.xml                # 日志配置
└── pom.xml

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

spring:
  application:
    name: user-management
  profiles:
    active: dev

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.user.entity
  configuration:
    map-underscore-to-camel-case: true

logging:
  level:
    com.example.user: DEBUG

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/user_management?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

package com.example.user.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class User {
    private Long id;
    private String username;
    private String password;
    private String email;
    private String phone;
    private Integer status;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

package com.example.user.repository;

import com.example.user.entity.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

@Mapper
public interface UserMapper {
    List<User> findAll();
    User findById(Long id);
    int insert(User user);
    int update(User user);
    int deleteById(Long id);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.user.repository.UserMapper">
    
    <resultMap id="BaseResultMap" type="com.example.user.entity.User">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="email" property="email"/>
        <result column="phone" property="phone"/>
        <result column="status" property="status"/>
        <result column="create_time" property="createTime"/>
        <result column="update_time" property="updateTime"/>
    </resultMap>
    
    <select id="findAll" resultMap="BaseResultMap">
        SELECT * FROM user
    </select>
    
    <select id="findById" resultMap="BaseResultMap">
        SELECT * FROM user WHERE id = #{id}
    </select>
    
    <insert id="insert" parameterType="com.example.user.entity.User">
        INSERT INTO user (username, password, email, phone, status, create_time, update_time)
        VALUES (#{username}, #{password}, #{email}, #{phone}, #{status}, NOW(), NOW())
    </insert>
    
    <update id="update" parameterType="com.example.user.entity.User">
        UPDATE user
        SET username = #{username},
            email = #{email},
            phone = #{phone},
            status = #{status},
            update_time = NOW()
        WHERE id = #{id}
    </update>
    
    <delete id="deleteById">
        DELETE FROM user WHERE id = #{id}
    </delete>
</mapper>

package com.example.user.service;

import com.example.user.entity.User;
import java.util.List;

public interface UserService {
    List<User> findAll();
    User findById(Long id);
    void save(User user);
    void update(User user);
    void deleteById(Long id);
}

package com.example.user.service.impl;

import com.example.user.entity.User;
import com.example.user.exception.BusinessException;
import com.example.user.repository.UserMapper;
import com.example.user.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
    
    private final UserMapper userMapper;
    
    @Override
    public List<User> findAll() {
        return userMapper.findAll();
    }
    
    @Override
    public User findById(Long id) {
        User user = userMapper.findById(id);
        if (user == null) {
            throw new BusinessException("用户不存在");
        }
        return user;
    }
    
    @Override
    @Transactional
    public void save(User user) {
        userMapper.insert(user);
    }
    
    @Override
    @Transactional
    public void update(User user) {
        userMapper.update(user);
    }
    
    @Override
    @Transactional
    public void deleteById(Long id) {
        userMapper.deleteById(id);
    }
}

package com.example.user.controller;

import com.example.user.entity.User;
import com.example.user.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {
    
    private final UserService userService;
    
    @GetMapping
    public List<User> findAll() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    public User findById(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping
    public String save(@RequestBody User user) {
        userService.save(user);
        return "保存成功";
    }
    
    @PutMapping
    public String update(@RequestBody User user) {
        userService.update(user);
        return "更新成功";
    }
    
    @DeleteMapping("/{id}")
    public String delete(@PathVariable Long id) {
        userService.deleteById(id);
        return "删除成功";
    }
}

Web server failed to start. Port 8080 was already in use.

server:
  port: 8081

# Windows
netstat -ano | findstr :8080
taskkill /PID <PID> /F

# Linux/macOS
lsof -i :8080
kill -9 <PID>

java.sql.SQLException: Access denied for user 'root'@'localhost'

Field userService in com.example.demo.controller.UserController required a bean of type 'com.example.demo.service.UserService' that could not be found.

Could not transfer artifact org.springframework.boot:spring-boot-starter-web:pom:2.7.18

Error: Could not find or load main class com.example.demo.DemoApplication

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

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

spring:
  profiles:
    active: dev

spring:
  application:
    name: demo

---
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:mysql://localhost:3306/demo_dev

---
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://prod-server:3306/demo_prod

java -jar demo.jar --spring.profiles.active=prod

@Value("${app.name}")
private String name;

@Value("${app.timeout}")
private Integer timeout;

@Component
@ConfigurationProperties(prefix = "app")
@Validated
@Data
public class AppProperties {
    @NotBlank
    private String name;
    
    @Min(1000)
    private Integer timeout;
    
    private Security security;    // 支持复杂对象
}

com.example.demo/
├── user/                    # 用户模块
│   ├── controller/
│   ├── service/
│   ├── repository/
│   ├── entity/
│   ├── dto/
│   └── vo/
├── order/                   # 订单模块
│   ├── controller/
│   ├── service/
│   ├── repository/
│   ├── entity/
│   ├── dto/
│   └── vo/
├── config/                  # 公共配置
├── exception/               # 公共异常
├── util/                    # 公共工具
├── common/                  # 公共类
└── DemoApplication.java     # 启动类

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      minimum-idle: 5
      maximum-pool-size: 20
      connection-timeout: 30000

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

@Configuration
public class MultiDataSourceConfig {
    
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    @Primary
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

@Service
public class UserService {
    
    @Async
    public CompletableFuture<User> findUserAsync(Long id) {
        User user = userMapper.findById(id);
        return CompletableFuture.completedFuture(user);
    }
}

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

@RestController
public class UserController {
    
    @GetMapping("/user/{id}")
    public CompletableFuture<User> getUser(@PathVariable Long id) {
        return CompletableFuture.supplyAsync(() -> {
            return userService.findById(id);
        });
    }
}

@Configuration
public class AsyncConfig {
    
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}