1. Spring、SpringMVC、SpringBoot 三者关系与区别

一、核心定位与职责

1. Spring Framework（Spring 框架）

• 定位 ：轻量级的、全面的企业级 Java 开发框架
• 核心功能 ：

• IoC（控制反转）容器 ：管理对象生命周期和依赖注入
• AOP（面向切面编程） ：实现横切关注点的模块化
• 事务管理 ：声明式事务支持
• JDBC/ORM 集成 ：简化数据库操作
• Spring MVC ：Web 开发模块（但 MVC 只是 Spring 的一部分）

2. Spring MVC

• 定位 ：Spring 框架中的一个 Web MVC 框架模块
• 核心功能 ：

• 基于 Model-View-Controller 模式的 Web 开发
• 提供 DispatcherServlet、控制器、视图解析器等组件
• 支持 RESTful 服务开发
• 与多种视图技术集成（JSP、Thymeleaf 等）

3. Spring Boot

• 定位 ：Spring 应用的快速开发脚手架
• 核心功能 ：

• 自动配置 ：根据依赖自动配置 Spring 应用
• 起步依赖 ：预配置的依赖包，简化 Maven/Gradle 配置
• 嵌入式服务器 ：内置 Tomcat、Jetty 等，无需部署 WAR
• 生产就绪功能 ：监控、健康检查、外部化配置

二、三者关系图示

┌─────────────────────────────────────────┐
│            Spring Boot                    │
│  ┌─────────────────────────────────┐    │
│  │        Spring Framework          │    │
│  │  ┌─────────────────────────┐    │    │
│  │  │      Spring MVC         │    │    │
│  │  └─────────────────────────┘    │    │
│  └─────────────────────────────────┘    │
└─────────────────────────────────────────┘

包含关系 ：

• Spring Boot 包含并构建于 Spring Framework 之上
• Spring Framework 包含 Spring MVC 作为其 Web 模块
• 使用 Spring Boot 时，你同时在使用 Spring 和 Spring MVC

三、主要区别对比

维度	SPRING FRAMEWORK	SPRING MVC	SPRING BOOT
范围	完整的应用框架	Web 框架（模块）	快速开发工具
配置方式	大量 XML/注解配置	XML/注解配置	约定优于配置，自动配置
部署	需要外部服务器部署	需要外部服务器部署	嵌入式服务器，独立运行
依赖管理	手动管理依赖	手动管理依赖	起步依赖，简化管理
上手难度	较高，需理解多个模块	中等，专注 Web 层	较低，开箱即用
适用场景	需要精细控制的大型企业应用	基于 Spring 的 Web 应用	微服务、快速原型、现代应用

四、实际开发中的演进

传统 Spring 应用开发

<!-- 大量 XML 配置 -->
<bean id="dataSource" class="..."/>
<bean id="transactionManager" class="..."/>
<!-- 需要手动配置每个组件 -->

Spring Boot 应用开发

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args); // 一行启动
    }
}

// application.properties 简单配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb

五、如何选择？

1. 学习路径建议 ：

1. 先理解 Spring Core （IoC、AOP）
2. 再学习 Spring MVC （Web 开发）
3. 最后掌握 Spring Boot （提高生产力）

1. 项目选择 ：

1. Spring Boot ：绝大多数新项目（微服务、REST API、云原生）
2. Spring Framework ：遗留系统维护或需要深度定制的复杂企业应用
3. Spring MVC ：基于传统 Spring 的 Web 项目

六、总结

• Spring 是基础框架 ，提供了核心的容器和编程模型
• Spring MVC 是 Spring 的Web扩展 ，专门处理HTTP请求和响应
• Spring Boot 是加速器 ，通过默认配置和约定简化Spring应用开发

现代开发模式 ：通常使用 Spring Boot + Spring MVC + Spring 的组合，其中 Spring Boot 作为入口和配置中心，Spring MVC 处理 Web 层，Spring Framework 提供核心功能。这种组合让开发者能快速构建生产就绪的应用程序，而无需关注繁琐的配置细节。

2. SpringBoot 核心优势：简化配置、自动装配、独立运行、嵌入式容器

一、简化配置（Convention Over Configuration）

1. 零配置启动

@SpringBootApplication  // 一个注解替代大量配置
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2. 配置文件的简化

# application.properties（传统方式需要大量XML）
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=123456

# 对比传统Spring的XML配置
<!-- 
<bean id="dataSource" class="...">
    <property name="url" value="..."/>
    <property name="username" value="..."/>
    <property name="password" value="..."/>
</bean>
-->

3. YAML 支持

# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: 123456
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update

二、自动装配（Auto-Configuration）

1. 条件化自动配置

// Spring Boot 自动配置类示例
@Configuration
@ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class})
@ConditionalOnMissingBean(DataSource.class)  // 没有自定义DataSource时才生效
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
public class DataSourceAutoConfiguration {
    // 自动创建数据源
}

2. 按需加载

• 检测类路径 ：根据依赖自动配置

<!-- 添加依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- Spring Boot 自动配置：
     1. 检测到H2/H2依赖 → 配置内存数据库
     2. 检测到MySQL驱动 → 配置MySQL数据源
     3. 配置JPA相关Bean
-->

3. 自定义覆盖

@Configuration
public class MyConfig {
    
    @Bean
    @ConfigurationProperties(prefix = "app.datasource")
    public DataSource myDataSource() {
        // 自定义数据源，会覆盖自动配置
        return DataSourceBuilder.create().build();
    }
}

三、独立运行（Standalone）

1. 无需外部容器

# 传统方式
# 1. 打包成WAR → 2. 部署到Tomcat → 3. 启动Tomcat

# Spring Boot方式
mvn clean package
java -jar myapp.jar  # 直接运行

2. 打包方式

<!-- pom.xml -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <!-- 打包成可执行JAR -->
        </plugin>
    </plugins>
</build>

3. 多环境运行

# 开发环境
java -jar myapp.jar --spring.profiles.active=dev

# 生产环境
java -jar myapp.jar --spring.profiles.active=prod \
                    --server.port=8080 \
                    --spring.datasource.url=jdbc:mysql://prod-db:3306/app

四、嵌入式容器（Embedded Container）

1. 支持的容器

<!-- 默认使用Tomcat -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 切换为Jetty -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

2. 容器配置

# application.yml
server:
  port: 8080                    # 端口
  servlet:
    context-path: /api         # 上下文路径
  tomcat:
    max-threads: 200           # 最大线程数
    connection-timeout: 5000   # 连接超时
  ssl:
    enabled: true              # 启用HTTPS
    key-store: classpath:keystore.p12
    key-store-password: secret

3. 容器监控

@RestController
public class HealthController {
    
    @GetMapping("/health")
    public String health() {
        // 内置健康检查端点
        return "UP";
    }
}

// 或使用Actuator
@GetMapping("/actuator/health")
// 返回详细的健康信息

五、其他重要优势

4. 起步依赖（Starter POMs）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 包含了：
         spring-web, spring-webmvc, 
         tomcat-embed-core, jackson, validation等
    -->
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <!-- 包含了：
         spring-data-jpa, hibernate, 
         spring-orm, 数据库驱动等
    -->
</dependency>

5. 生产就绪功能

# Actuator端点
management:
  endpoints:
    web:
      exposure:
        include: "*"  # 暴露所有监控端点
  endpoint:
    health:
      show-details: always

六、总结表格

优势	具体体现	带来的好处
简化配置	约定优于配置、YAML支持	减少80%的配置代码
自动装配	条件化配置、按需加载	智能配置，避免冗余
独立运行	可执行JAR、无需容器	部署简单，适合云原生
嵌入式容器	内置Tomcat/Jetty	开发测试一体化
起步依赖	预配置的依赖包	解决依赖冲突问题
生产就绪	Actuator监控	运维友好，易于监控

核心价值 ：Spring Boot 让开发者专注于业务逻辑 ，而不是基础设施的搭建和配置。它通过合理的默认值和自动配置，极大地提高了开发效率，降低了 Spring 应用的入门门槛。

3. SpringBoot 版本体系选择（2.x 稳定版 vs 3.x 新版特性、适配JDK版本）

一、版本对比概览

特性	SPRING BOOT 2.X	SPRING BOOT 3.X	说明
JDK 要求	JDK 8+	JDK 17+	3.x 强制要求 JDK 17
Spring 版本	Spring 5.x	Spring 6.x	核心框架升级
Java EE	Jakarta EE 8	Jakarta EE 9+	包名变更
最低 Servlet	Servlet 3.1+	Servlet 5.0+	Tomcat 10+
发布状态	维护分支	当前主分支	2.7.x 是最后2.x版本

二、详细对比分析

1. JDK 版本要求

// Spring Boot 2.x - JDK 8+ 兼容
public class Java8Example {
    public static void main(String[] args) {
        // JDK 8 特性可用
        List<String> list = Arrays.asList("a", "b", "c");
        list.forEach(System.out::println);  // Lambda表达式
    }
}

// Spring Boot 3.x - 必须 JDK 17+
public class Java17Example {
    public static void main(String[] args) {
        // JDK 17 新特性
        String json = """
            {
                "name": "Spring Boot 3",
                "version": "3.0.0",
                "requires": "JDK 17+"
            }
            """;  // 文本块（Text Blocks）
        
        // Switch表达式增强
        String result = switch (args.length) {
            case 0 -> "No args";
            case 1 -> "One arg";
            default -> "Multiple args";
        };
    }
}

2. Jakarta EE 迁移（重要变化）

// Spring Boot 2.x - 使用 javax.*
import javax.servlet.http.HttpServletRequest;
import javax.persistence.Entity;
import javax.validation.constraints.NotNull;

// Spring Boot 3.x - 必须使用 jakarta.*
import jakarta.servlet.http.HttpServletRequest;
import jakarta.persistence.Entity;
import jakarta.validation.constraints.NotNull;

// Maven 依赖变化
<!-- Spring Boot 2.x -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

<!-- Spring Boot 3.x -->
<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.0.0</version>
</dependency>

3. 新特性对比

Spring Boot 2.x 特性

# 2.x 稳定特性
spring:
  boot:
    version: 2.7.x  # 最后稳定版
  features:
    - Actuator端点丰富
    - 配置属性元数据
    - 原生镜像支持（实验性）
    - 云原生特性完善

Spring Boot 3.x 新特性

// 1. 记录器接口（替代Lombok的@Slf4j）
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// 3.x 新方式
import org.springframework.boot.logging.LoggingSystem;

// 2. 问题详情API
import org.springframework.boot.diagnostics.ProblemDetail;
import org.springframework.http.ProblemDetail;

@RestController
public class ErrorController {
    
    @ExceptionHandler(Exception.class)
    public ProblemDetail handleException(Exception ex) {
        ProblemDetail problem = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        problem.setTitle("Bad Request");
        problem.setDetail(ex.getMessage());
        problem.setProperty("timestamp", Instant.now());
        return problem;
    }
}

// 3. 观察能力增强
import io.micrometer.observation.Observation;
import io.micrometer.observation.ObservationRegistry;

@Service
public class UserService {
    private final ObservationRegistry observationRegistry;
    
    public User getUser(Long id) {
        return Observation.createNotStarted("user.findById", observationRegistry)
            .lowCardinalityKeyValue("userId", id.toString())
            .observe(() -> userRepository.findById(id));
    }
}

4. GraalVM 原生镜像支持

<!-- Spring Boot 3.x 原生镜像支持更成熟 -->
<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
</plugin>

# 构建原生镜像
mvn -Pnative native:compile

# 对比传统JAR
传统JAR: 50MB, 启动时间: 3-5秒
原生镜像: 80MB, 启动时间: 0.05秒

三、选择建议

场景1：新项目启动

# 推荐 Spring Boot 3.x 如果：
conditions:
  - 项目是全新的
  - 团队使用 JDK 17+
  - 需要最新特性
  - 考虑未来长期维护
  
# 示例项目配置
spring:
  boot:
    version: "3.1.0"  # 最新稳定版
  java:
    version: "17"      # 或 "21"

场景2：现有项目升级

// 升级路径建议
public class MigrationPath {
    // 路径1：直接升级（如果依赖兼容）
    // Spring Boot 2.5 → 2.7 → 3.0 → 3.1
    
    // 路径2：分步升级
    // 1. 先升级到 Spring Boot 2.7.x
    // 2. 将 javax.* 改为 jakarta.*
    // 3. 升级到 JDK 17
    // 4. 升级到 Spring Boot 3.x
}

场景3：企业保守选择

# 选择 Spring Boot 2.7.x 如果：
# 1. 生产环境是 JDK 8/11
# 2. 依赖库不支持 Jakarta EE
# 3. 需要超稳定版本
# 4. 近期没有升级计划

spring-boot.version=2.7.14  # 2.x 最后版本，长期支持
java.version=1.8  # 或 11

四、版本迁移检查清单

public class MigrationChecklist {
    
    // ✅ 1. 检查JDK版本
    System.getProperty("java.version");  // 必须 >= 17
    
    // ✅ 2. 更新import语句
    // javax.servlet → jakarta.servlet
    // javax.persistence → jakarta.persistence
    // javax.validation → jakarta.validation
    
    // ✅ 3. 更新Maven依赖
    // 所有 javax.* → jakarta.*
    
    // ✅ 4. 配置文件更新
    // server.servlet.context-path → server.servlet.context.path
    // spring.mvc.format.date → spring.mvc.format.date-time
    
    // ✅ 5. 测试兼容性
    // 运行所有测试用例
    // 检查第三方库兼容性
}

五、具体迁移示例

Maven pom.xml 对比

<!-- Spring Boot 2.7.x -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.14</version>
</parent>

<properties>
    <java.version>1.8</java.version>
</properties>

<!-- Spring Boot 3.1.x -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.1.0</version>
</parent>

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

数据库配置变化

# Spring Boot 2.x
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    database-platform: org.hibernate.dialect.MySQL8Dialect

# Spring Boot 3.x
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect

六、总结建议表

项目类型	推荐版本	理由	注意事项
全新项目	Spring Boot 3.x	拥抱最新技术，长期支持	确保团队熟悉 JDK 17+
企业级稳定项目	Spring Boot 2.7.x	超稳定，生态成熟	2023年11月前有官方支持
微服务/云原生	Spring Boot 3.x	更好的云原生支持	需要评估第三方组件兼容性
传统维护项目	Spring Boot 2.7.x	最小化改动风险	如无必要，不升级
需要高性能启动	Spring Boot 3.x	原生镜像支持更好	考虑 GraalVM 编译

七、时间线参考

最终建议 ：

• 新项目 ：直接上 Spring Boot 3.x + JDK 17/21
• 老项目 ：评估升级成本，如无特殊需求可保持在 2.7.x
• 技术选型 ：考虑团队技术栈和未来3-5年的技术趋势

4. 开发环境搭建：JDK配置、Maven/Gradle环境配置、IDEA开发工具配置

一、JDK 配置（以 JDK 17 为例）

1. JDK 下载与安装

# 推荐使用 Azul Zulu JDK（免费，商业友好）
# 下载地址：https://www.azul.com/downloads/?package=jdk

# 或者使用 OpenJDK
# 下载地址：https://adoptium.net/

# 验证安装
java -version
# 输出应类似：
# openjdk version "17.0.5" 2022-10-18
# OpenJDK Runtime Environment (build 17.0.5+8)
# OpenJDK 64-Bit Server VM (build 17.0.5+8, mixed mode, sharing)

2. 多版本 JDK 管理（macOS/Linux）

# 使用 jenv 管理多个 JDK 版本
brew install jenv  # macOS

# 配置 bash/zsh
echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(jenv init -)"' >> ~/.zshrc

# 添加 JDK
jenv add /Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home
jenv add /Library/Java/JavaVirtualMachines/zulu-11.jdk/Contents/Home

# 设置全局版本
jenv global 17.0

# 设置项目特定版本
cd my-spring-project
jenv local 17.0

3. Windows JDK 环境变量配置

# 1. 下载并安装 JDK 17
# 2. 设置系统环境变量
# JAVA_HOME: C:\Program Files\Zulu\zulu-17
# Path: 添加 %JAVA_HOME%\bin

# 验证配置
java -version
javac -version

二、Maven 环境配置

1. Maven 安装与配置

# 下载 Maven
# 官网：https://maven.apache.org/download.cgi
# 推荐版本：3.8.6+

# 解压并配置环境变量
export MAVEN_HOME=/opt/apache-maven-3.8.6
export PATH=$MAVEN_HOME/bin:$PATH

# 验证安装
mvn -v

2. Maven 配置文件优化

<!-- ~/.m2/settings.xml -->
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 
          http://maven.apache.org/xsd/settings-1.0.0.xsd">
    
    <!-- 本地仓库位置 -->
    <localRepository>/Users/username/.m2/repository</localRepository>
    
    <!-- 镜像配置（国内加速） -->
    <mirrors>
        <mirror>
            <id>aliyun-maven</id>
            <mirrorOf>central</mirrorOf>
            <name>阿里云公共仓库</name>
            <url>https://maven.aliyun.com/repository/public</url>
        </mirror>
        <mirror>
            <id>aliyun-spring</id>
            <mirrorOf>spring-milestones</mirrorOf>
            <name>阿里云Spring仓库</name>
            <url>https://maven.aliyun.com/repository/spring</url>
        </mirror>
    </mirrors>
    
    <!-- 代理配置（如果需要） -->
    <proxies>
        <proxy>
            <id>optional</id>
            <active>true</active>
            <protocol>http</protocol>
            <host>proxy.example.com</host>
            <port>8080</port>
            <nonProxyHosts>localhost|*.example.com</nonProxyHosts>
        </proxy>
    </proxies>
    
    <!-- 服务器认证 -->
    <servers>
        <server>
            <id>github</id>
            <username>${env.GITHUB_USERNAME}</username>
            <password>${env.GITHUB_TOKEN}</password>
        </server>
    </servers>
    
    <!-- 配置文件激活 -->
    <profiles>
        <profile>
            <id>spring</id>
            <repositories>
                <repository>
                    <id>spring-milestones</id>
                    <name>Spring Milestones</name>
                    <url>https://repo.spring.io/milestone</url>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </repository>
            </repositories>
        </profile>
    </profiles>
    
    <activeProfiles>
        <activeProfile>spring</activeProfile>
    </activeProfiles>
</settings>

3. Maven 常用命令优化

# 创建 Spring Boot 项目
mvn archetype:generate \
    -DgroupId=com.example \
    -DartifactId=demo \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DinteractiveMode=false

# 更推荐使用 Spring Initializr
curl https://start.spring.io/starter.zip \
    -d type=maven-project \
    -d language=java \
    -d bootVersion=3.1.0 \
    -d baseDir=demo \
    -d groupId=com.example \
    -d artifactId=demo \
    -d name=demo \
    -d description=Demo+project+for+Spring+Boot \
    -d packageName=com.example.demo \
    -d packaging=jar \
    -d javaVersion=17 \
    -d dependencies=web,data-jpa,security \
    -o demo.zip

# 常用命令别名配置（~/.bashrc 或 ~/.zshrc）
alias mci='mvn clean install'
alias mcis='mvn clean install -DskipTests'
alias mcp='mvn clean package'
alias mcps='mvn clean package -DskipTests'
alias mct='mvn clean test'
alias mvnrun='mvn spring-boot:run'
alias mvndebug='mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005"'

三、Gradle 环境配置（可选）

1. Gradle 安装与配置

# 使用 SDKMAN 安装（推荐）
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle 8.2.1

# 或手动安装
# 下载：https://gradle.org/releases/
export GRADLE_HOME=/opt/gradle-8.2.1
export PATH=$GRADLE_HOME/bin:$PATH

# 验证安装
gradle -v

2. Gradle 配置文件优化

// ~/.gradle/init.gradle.kts
allprojects {
    repositories {
        // 国内镜像加速
        maven { url = uri("https://maven.aliyun.com/repository/public") }
        maven { url = uri("https://maven.aliyun.com/repository/spring") }
        mavenCentral()
        maven { url = uri("https://repo.spring.io/milestone") }
    }
    
    // 全局配置
    tasks.withType<JavaCompile> {
        options.encoding = "UTF-8"
        options.compilerArgs.add("-parameters")
    }
    
    tasks.withType<Test> {
        useJUnitPlatform()
        testLogging {
            events("passed", "skipped", "failed")
        }
    }
}

// 配置代理（如果需要）
System.setProperty("http.proxyHost", "proxy.example.com")
System.setProperty("http.proxyPort", "8080")

3. Gradle Wrapper 配置

# 生成 Gradle Wrapper
gradle wrapper --gradle-version 8.2.1 --distribution-type all

# 常用命令
./gradlew build          # 构建项目
./gradlew bootRun        # 运行Spring Boot应用
./gradlew test           # 运行测试
./gradlew dependencies   # 查看依赖

四、IDEA 开发工具配置

1. IDEA 安装与激活

# 下载 IntelliJ IDEA Ultimate（推荐）
# 官网：https://www.jetbrains.com/idea/download/

# 或使用社区版（免费）
# 社区版功能对比：
# Ultimate: Spring Boot支持、数据库工具、JPA支持、Profiling等
# Community: 基础Java开发

# 学生可申请免费教育许可证

2. IDEA 基础配置

主题和外观配置

File → Settings → Editor → General
- 取消勾选 "Use tab character"
- Tab size: 4
- Indent: 4
- 勾选 "Show quick documentation on mouse move"

File → Settings → Editor → Code Style → Java
- 导入阿里巴巴代码规范：https://github.com/alibaba/p3c

编辑器配置

File → Settings → Editor → General
- 取消勾选 "Use tab character"
- Tab size: 4
- Indent: 4
- 勾选 "Show quick documentation on mouse move"

File → Settings → Editor → Code Style → Java
- 导入阿里巴巴代码规范：https://github.com/alibaba/p3c

快捷键优化

# 常用快捷键（macOS/Windows）
# 搜索：Double Shift
# 最近文件：Cmd/Ctrl + E
# 代码生成：Alt + Insert
# 重命名：Shift + F6
# 提取方法：Cmd/Ctrl + Alt + M
# 提取变量：Cmd/Ctrl + Alt + V
# 环绕代码：Cmd/Ctrl + Alt + T
# 实现方法：Ctrl + I
# 重写方法：Ctrl + O

3. Spring Boot 相关插件

必装插件：
1. Spring Boot Assistant（内置）
2. Lombok
3. MapStruct Support
4. Maven Helper
5. Grep Console
6. GitToolBox
7. Rainbow Brackets
8. CodeGlance
9. RestfulToolkit
10. MyBatisX（如果使用MyBatis）

4. IDEA 项目配置

Maven 项目配置

<!-- 在 pom.xml 中添加 IDEA 配置 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>17</source>
                <target>17</target>
                <encoding>UTF-8</encoding>
                <parameters>true</parameters>  <!-- 支持 @RequestParam 省略 -->
                <annotationProcessorPaths>
                    <!-- Lombok 处理器 -->
                    <path>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                        <version>1.18.28</version>
                    </path>
                    <!-- MapStruct 处理器 -->
                    <path>
                        <groupId>org.mapstruct</groupId>
                        <artifactId>mapstruct-processor</artifactId>
                        <version>1.5.5.Final</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>

启用注解处理器

File → Settings → Build, Execution, Deployment → Compiler → Annotation Processors
- 勾选 "Enable annotation processing"
- Store generated sources relative to: Module content root

5. 运行和调试配置

# 创建 Spring Boot 运行配置
# Run → Edit Configurations → + → Spring Boot

# 配置示例：
- Main class: com.example.DemoApplication
- Environment variables:
  SPRING_PROFILES_ACTIVE: dev
  JAVA_OPTS: -Xmx512m -Xms256m
- VM options: 
  -Dspring.devtools.restart.enabled=true
  -Dspring.output.ansi.enabled=ALWAYS
- Program arguments: --server.port=8081
- Use classpath of module: demo.main
- JRE: 17 (Project SDK)

# 热部署配置
# 1. 添加依赖
dependencies:
  developmentOnly 'org.springframework.boot:spring-boot-devtools'

# 2. IDEA 设置
File → Settings → Build, Execution, Deployment → Compiler
- 勾选 "Build project automatically"

File → Settings → Advanced Settings
- 勾选 "Allow auto-make to start even if developed application is currently running"

6. 数据库工具配置

-- 配置 Database 工具
# View → Tool Windows → Database
# + → Data Source → MySQL

# 连接配置：
- Host: localhost
- Port: 3306
- User: root
- Database: demo_db
- URL: jdbc:mysql://localhost:3306/demo_db?useSSL=false&serverTimezone=UTC

# 启用 SQL 自动补全
File → Settings → Editor → General → Code Completion
- 勾选 "Show suggestions as you type"

五、常见问题解决

1. Maven 依赖下载慢

# 解决方案1：使用阿里云镜像
# 配置 settings.xml 如前面所示

# 解决方案2：使用代理
export MAVEN_OPTS="-DsocksProxyHost=127.0.0.1 -DsocksProxyPort=1080"

# 解决方案3：离线模式（提前下载）
mvn dependency:go-offline

2. IDEA Lombok 不生效

1. 安装 Lombok 插件
2. File → Settings → Build, Execution, Deployment → Compiler → Annotation Processors
   - 勾选 Enable annotation processing
3. 重启 IDEA
4. 检查 pom.xml 中 Lombok 依赖

3. JDK 版本不匹配

<!-- 在 pom.xml 中明确指定 -->
<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <java.version>17</java.version>
</properties>

<!-- 或在 IDEA 中设置 -->
# File → Project Structure → Project → SDK
# File → Project Structure → Modules → Language Level

4. 热部署失效

# 1. 确保 devtools 依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

# 2. IDEA 设置
# File → Settings → Build, Execution, Deployment → Compiler
# - 勾选 "Build project automatically"

# 3. 注册表设置
# Ctrl+Shift+A → Registry
# - 勾选 "compiler.automake.allow.when.app.running"