跳到主要内容

环境配置

本章介绍如何搭建 Spring 开发环境，包括 JDK 安装、构建工具配置、IDE 选择以及创建第一个 Spring 项目。

JDK 安装​

Spring Framework 6.x 需要 Java 17 或更高版本。如果你使用的是 Spring Framework 5.x，则需要 Java 8 或更高版本。

下载安装 JDK​

从 Oracle 官网或 Adoptium（开源 JDK 发行版）下载 JDK：

Oracle JDK: https://www.oracle.com/java/technologies/downloads/
Adoptium: https://adoptium.net/

配置环境变量​

Windows 系统：

  1. 设置 JAVA_HOME 环境变量指向 JDK 安装目录
  2. 将 %JAVA_HOME%\bin 添加到 PATH 环境变量

Linux/macOS 系统：

在 ~/.bashrc 或 ~/.zshrc 中添加：

export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

验证安装​

java -version
javac -version

输出应该显示已安装的 JDK 版本。

构建工具选择​

现代 Java 项目通常使用 Maven 或 Gradle 作为构建工具。两者各有优势，Spring 官方对两者都提供完整支持。

Maven​

Maven 是最成熟的 Java 构建工具，使用 XML 配置，约定优于配置。

安装 Maven：

从 Apache Maven 官网下载并解压，配置 M2_HOME 环境变量。

mvn -version

Maven 项目结构：

my-project/
├── pom.xml                 # 项目配置文件
├── src/
│   ├── main/
│   │   ├── java/          # Java 源代码
│   │   └── resources/     # 资源文件（配置文件、属性文件等）
│   └── test/
│       ├── java/          # 测试代码
│       └── resources/     # 测试资源
└── target/                # 编译输出目录

Spring 依赖配置：

<?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>

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

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

    <dependencies>
        <!-- Spring Context：核心容器 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <!-- Spring Beans：Bean 工厂 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Gradle​

Gradle 使用 Groovy 或 Kotlin DSL 编写构建脚本，更加灵活，构建速度更快。

安装 Gradle：

从 Gradle 官网下载，或使用 SDKMAN 安装：

sdk install gradle
gradle -version

Gradle 项目结构：

与 Maven 类似，但配置文件是 build.gradle 或 build.gradle.kts。

my-project/
├── build.gradle            # 构建配置文件
├── settings.gradle         # 项目设置
├── src/
│   ├── main/
│   │   ├── java/
│   │   └── resources/
│   └── test/
│       ├── java/
│       └── resources/
└── build/                  # 构建输出目录

Spring 依赖配置（Groovy DSL）：

plugins {
    id 'java'
}

group = 'com.example'
version = '1.0.0'

java {
    sourceCompatibility = '17'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework:spring-context:6.1.0'
    implementation 'org.springframework:spring-beans:6.1.0'
}

IDE 选择​

IntelliJ IDEA​

IntelliJ IDEA 是最流行的 Java IDE，对 Spring 有出色的支持。

社区版：免费，支持基本的 Java 开发和 Maven/Gradle。

旗舰版：付费，提供完整的 Spring 支持，包括：

  • Spring 配置文件的智能提示和导航
  • Bean 依赖关系图
  • Spring Boot 配置提示
  • 内置数据库工具

Eclipse​

Eclipse 是免费开源的 IDE，通过 Spring Tools 插件提供 Spring 支持。

安装 Spring Tools：

  1. 打开 Eclipse Marketplace
  2. 搜索 "Spring Tools"
  3. 安装 Spring Tools 4

VS Code​

VS Code 配合扩展也可以进行 Spring 开发：

  • Extension Pack for Java
  • Spring Boot Extension Pack
  • Spring Initializr Java Support

创建第一个 Spring 项目​

下面我们创建一个简单的 Spring 项目，体验 Spring 的基本功能。

方式一：使用 Spring Initializr​

Spring Initializr 是官方提供的项目生成工具，可以快速创建 Spring 项目。

访问 https://start.spring.io/，选择：

  • Project: Maven
  • Language: Java
  • Spring Boot: 3.2.x（如果只是学习 Spring Framework，可以选择不使用 Spring Boot）
  • Group: com.example
  • Artifact: spring-demo
  • Java: 17

点击 "GENERATE" 下载项目压缩包，解压后用 IDE 打开。

方式二：手动创建项目​

创建项目目录结构：

spring-demo/
├── pom.xml
└── src/
    └── main/
        ├── java/
        │   └── com/
        │       └── example/
        │           └── spring/
        │               ├── Application.java
        │               ├── service/
        │               │   └── UserService.java
        │               └── config/
        │                   └── AppConfig.java
        └── resources/
            └── applicationContext.xml

创建 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>

    <groupId>com.example</groupId>
    <artifactId>spring-demo</artifactId>
    <version>1.0.0</version>

    <properties>
        <spring.version>6.1.0</spring.version>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</project>

创建服务类 UserService.java：

package com.example.spring.service;

public class UserService {
    
    public String getUserName(Long userId) {
        return "User-" + userId;
    }
}

创建配置类 AppConfig.java：

package com.example.spring.config;

import com.example.spring.service.UserService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

创建主类 Application.java：

package com.example.spring;

import com.example.spring.service.UserService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.ApplicationContext;

public class Application {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(
            "com.example.spring.config"
        );
        
        UserService userService = context.getBean(UserService.class);
        String userName = userService.getUserName(1L);
        System.out.println(userName);
    }
}

运行项目​

使用 Maven 编译运行：

mvn compile exec:java -Dexec.mainClass="com.example.spring.Application"

或者在 IDE 中直接运行 Application 类的 main 方法。

输出结果：

User-1

三种配置方式对比​

Spring 支持三种配置方式：XML 配置、注解配置和 Java 配置。现代 Spring 项目推荐使用 Java 配置。

XML 配置​

传统的配置方式，使用 XML 文件定义 Bean。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.example.spring.service.UserService"/>
</beans>

使用方式：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);

注解配置​

在类上使用注解，配合组件扫描自动注册 Bean。

package com.example.spring.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public String getUserName(Long userId) {
        return "User-" + userId;
    }
}

配置类启用组件扫描：

@Configuration
@ComponentScan("com.example.spring")
public class AppConfig {
}

Java 配置​

使用 @Bean 方法显式定义 Bean，类型安全，IDE 友好。

@Configuration
public class AppConfig {
    
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

选择建议​

配置方式优点缺点适用场景
XML 配置配置与代码分离，修改无需重新编译冗长，无类型检查维护老项目
注解配置简洁，开发效率高配置分散在各个类中业务组件
Java 配置类型安全，IDE 支持好需要编写配置代码基础设施配置

实际项目中通常会混合使用：业务组件使用注解（@Service、@Repository 等），第三方库配置使用 Java 配置（@Bean）。

日志配置​

Spring 使用 Commons Logging 作为日志接口，默认支持 JUL（Java Util Logging）。实际项目中通常会使用 SLF4J + Logback 或 SLF4J + Log4j2。

添加日志依赖​

<dependencies>
    <!-- SLF4J API -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>2.0.9</version>
    </dependency>
    
    <!-- Logback 实现 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.4.11</version>
    </dependency>
</dependencies>

配置 Logback​

创建 src/main/resources/logback.xml：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
    
    <!-- 设置 Spring 框架的日志级别 -->
    <logger name="org.springframework" level="DEBUG"/>
</configuration>

使用日志​

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class UserService {
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    
    public String getUserName(Long userId) {
        logger.info("Getting user name for userId: {}", userId);
        return "User-" + userId;
    }
}

小结​

本章介绍了 Spring 开发环境的搭建，包括：

  1. JDK 的安装和配置，Spring 6.x 需要 Java 17+
  2. Maven 和 Gradle 两种构建工具的选择和配置
  3. IDE 的选择，推荐使用 IntelliJ IDEA
  4. 创建第一个 Spring 项目，体验 IOC 容器的基本用法
  5. Spring 的三种配置方式：XML、注解和 Java 配置
  6. 日志框架的配置

下一章我们将深入学习 Spring 的核心概念：IOC 容器。