Spring 7快速入门

环境要求

JDK安装

Spring 7要求JDK 17或更高版本，推荐使用JDK 21或JDK 25。

bash

# 检查Java版本
java -version
# 输出: java version "21.0.x"

# 设置JAVA_HOME
export JAVA_HOME=/path/to/jdk-21

Maven安装

bash

# 检查Maven版本
mvn -version
# Apache Maven 3.9.6+

IDE配置

IntelliJ IDEA：

安装JDK 21
配置Maven设置
安装Spring插件（通常已内置）

创建第一个Spring项目

方式一：Spring Initializr

访问 https://start.spring.io/
选择配置：
- Project: Maven
- Language: Java
- Spring Boot: 4.0.x
- Group: com.example
- Artifact: demo
- Package name: com.example.demo
- Packaging: Jar
- Java: 21
添加依赖：
- Spring Web
- Spring Data JPA
- H2 Database
生成项目并解压

方式二：命令行创建

bash

# 使用Spring Boot CLI
spring init --dependencies=web,data-jpa,h2 --java-version=21 demo

# 或使用curl
curl https://start.spring.io/starter.zip \
  -d dependencies=web,data-jpa,h2 \
  -d javaVersion=21 \
  -d type=maven-project \
  -o demo.zip

方式三：IDE创建

IntelliJ IDEA：

File → New → Project
选择 Spring Initializr
填写项目信息
选择依赖
完成创建

项目结构

demo/
├── pom.xml                     # Maven配置文件
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       ├── DemoApplication.java    # 启动类
│   │   │       ├── controller/             # 控制器
│   │   │       ├── service/                # 服务层
│   │   │       ├── repository/             # 数据访问层
│   │   │       └── entity/                 # 实体类
│   │   └── resources/
│   │       ├── application.properties      # 配置文件
│   │       ├── application.yml             # YAML配置
│   │       ├── static/                     # 静态资源
│   │       └── templates/                  # 模板文件
│   └── test/
│       └── java/
│           └── com/example/demo/           # 测试类
└── target/                     # 编译输出

核心文件说明

pom.xml

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 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>4.0.0</version>
        <relativePath/>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    
    <properties>
        <java.version>21</java.version>
    </properties>
    
    <dependencies>
        <!-- Spring Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Spring Data JPA -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        
        <!-- H2 Database -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        
        <!-- 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

启动类

java

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 - 组件扫描

配置文件

application.yml：

yaml

# 服务器配置
server:
  port: 8080
  servlet:
    context-path: /

# Spring配置
spring:
  application:
    name: demo
  
  # 数据源配置
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:
  
  # JPA配置
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
    properties:
      hibernate:
        format_sql: true
  
  # H2控制台
  h2:
    console:
      enabled: true
      path: /h2-console

# 日志配置
logging:
  level:
    root: INFO
    com.example: DEBUG

创建REST API

实体类

java

package com.example.demo.entity;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(unique = true)
    private String email;
    
    // 构造方法
    public User() {}
    
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }
    
    // Getter和Setter
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Repository接口

java

package com.example.demo.repository;

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

import java.util.Optional;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    Optional<User> findByEmail(String email);
    
    boolean existsByEmail(String email);
}

Service层

java

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
@Transactional
public class UserService {
    
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public List<User> findAll() {
        return userRepository.findAll();
    }
    
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }
    
    public User save(User user) {
        return userRepository.save(user);
    }
    
    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }
}

Controller层

java

package com.example.demo.controller;

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

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        return userService.findById(id)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.findById(id)
                .map(existingUser -> {
                    user.setId(id);
                    User updatedUser = userService.save(user);
                    return ResponseEntity.ok(updatedUser);
                })
                .orElse(ResponseEntity.notFound().build());
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        if (userService.findById(id).isPresent()) {
            userService.deleteById(id);
            return ResponseEntity.noContent().build();
        }
        return ResponseEntity.notFound().build();
    }
}

运行项目

使用Maven

bash

# 编译项目
mvn compile

# 运行项目
mvn spring-boot:run

# 打包项目
mvn package

# 运行JAR
java -jar target/demo-0.0.1-SNAPSHOT.jar

使用IDE

在IDE中直接运行DemoApplication类的main方法。

测试API

bash

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

# 创建用户
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"name":"张三","email":"zhangsan@example.com"}'

# 获取单个用户
curl http://localhost:8080/api/users/1

# 更新用户
curl -X PUT http://localhost:8080/api/users/1 \
  -H "Content-Type: application/json" \
  -d '{"name":"李四","email":"lisi@example.com"}'

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

常见问题

1. 端口被占用

yaml

# 修改端口
server:
  port: 8081

2. 依赖下载失败

xml

<!-- 配置阿里云镜像 -->
<mirror>
    <id>aliyun</id>
    <mirrorOf>central</mirrorOf>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

3. 编码问题

yaml

# 设置编码
server:
  servlet:
    encoding:
      charset: UTF-8
      enabled: true
      force: true

下一步

继续学习 IoC容器与依赖注入，深入理解Spring的核心机制。

Spring 7快速入门 ​

环境要求 ​

JDK安装 ​

Maven安装 ​

IDE配置 ​

创建第一个Spring项目 ​

方式一：Spring Initializr ​

方式二：命令行创建 ​

方式三：IDE创建 ​

项目结构 ​

核心文件说明 ​

pom.xml ​

启动类 ​

配置文件 ​

创建REST API ​

实体类 ​

Repository接口 ​

Service层 ​

Controller层 ​

运行项目 ​

使用Maven ​

使用IDE ​

测试API ​

常见问题 ​

1. 端口被占用 ​

2. 依赖下载失败 ​

3. 编码问题 ​

下一步 ​

Spring 7快速入门

环境要求

JDK安装

Maven安装

IDE配置

创建第一个Spring项目

方式一：Spring Initializr

方式二：命令行创建

方式三：IDE创建

项目结构

核心文件说明

pom.xml

启动类

配置文件

创建REST API

实体类

Repository接口

Service层

Controller层

运行项目

使用Maven

使用IDE

测试API

常见问题

1. 端口被占用

2. 依赖下载失败

3. 编码问题

下一步