关于 Spring Boot 的后端搭建教程

✨ 想快速搭建 Spring Boot 后端，却不知从何入手？✨ 本篇博客将手把手教你搭建一个完整的 Spring Boot 3.x 后端！从 项目初始化 到 数据库配置，再到 Spring Security + JWT认证，循序渐进，适合新手入门。还包含 项目结构解析 和 核心代码示例，助你轻松上手，快速构建安全高效的后端服务！🚀

概述

WiseLearn 是一个智能学习系统，使用 Spring Boot 3.x 作为后端框架，MySQL 作为数据库，并集成了 Spring Security 和 JWT 进行安全认证。

项目初始化可通过 Spring Initializr 并按以下配置进行：

项目配置：

• Project: Maven
• Language: Java
• Spring Boot: 3.3.9
• Group: com.wiselearn
• Artifact: wiselearn
• Name: wiselearn
• Description: WiseLearn Intelligent Learning System
• Package name: com.wiselearn
• Packaging: Jar
• Java: 17

依赖项选择：

• Spring Web
• Spring Data JPA
• MySQL Driver
• Spring Security
• Lombok
• Spring Boot DevTools
• Validation
• Spring Configuration Processor

点击 GENERATE 按钮。

• GENERATE 会直接下载项目的zip文件到你的电脑，你可以解压后放到你的WISELEARN目录中
• EXPLORE 只是在浏览器中预览项目结构，虽然也可以查看生成的代码，但最终还是需要下载

具体步骤：
点击 GENERATE 按钮，会下载一个名为 wiselearn-server.zip 的文件，将这个zip文件解压到你的WISELEARN目录中的后端目录

技术栈

• Spring Boot 3.3.9
• MySQL 8.0
• Spring Security
• JWT
• JPA
• Lombok
• Maven

因为使用的是Next.js 15.1.4作为前端，前后端是分离的架构，Spring Boot 3.x系列都需要Java 17+，所以选择 Spring Boot 3.3.9

项目结构检查完成，一切看起来都很正常！我们有：
✅ 正确的目录结构
✅ 所有必要的依赖都已配置在pom.xml中：

• Spring Web
• Spring Data JPA
• Spring Security
• MySQL Driver
• Lombok
• Validation
• DevTools
• Configuration Processor

接下来我们需要：

创建基础包结构
配置application.properties（数据库连接等）
创建基础的安全配置

首先让我们在src/main/java下创建必要的包结构。

我们需要创建以下基础包结构：

config - 配置类
controller - 控制器
service - 服务层
repository - 数据访问层
model - 实体类和DTO
security - 安全相关
exception - 异常处理
util - 工具类

让我们创建这些目录：

cd wiselearn-server/src/main/java/com/wiselearn

mkdir -p config controller service repository model/entity model/dto security exception util

项目结构

wiselearn-server/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── wiselearn/
│   │   │           ├── config/         # 配置类
│   │   │           ├── controller/     # 控制器
│   │   │           ├── service/        # 服务层
│   │   │           ├── repository/     # 数据访问层
│   │   │           ├── model/          # 实体类和 DTO
│   │   │           │   ├── entity/
│   │   │           │   └── dto/
│   │   │           ├── security/       # 安全相关
│   │   │           ├── exception/      # 异常处理
│   │   │           └── util/           # 工具类
│   │   └── resources/
│   │       └── application.properties  # 应用配置
│   └── test/                          # 测试目录
└── pom.xml                           # Maven 配置

搭建步骤

1. 创建项目

使用 Spring Initializr 创建项目，并配置必要的依赖。

我们可以创建一些基础类来自动创建这些目录。首先，让我们创建主应用类：

java:wiselearn-server/src/main/java/com/wiselearn/WiselearnServerApplication.java

package com.wiselearn;

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

@SpringBootApplication
public class WiselearnServerApplication {

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

现在让我们创建一些基础类来建立目录结构：

1. 配置类：

java:wiselearn-server/src/main/java/com/wiselearn/config/WebConfig.java

package com.wiselearn.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("http://localhost:3000") // 允许前端访问
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
                .allowedHeaders("*")
                .allowCredentials(true);
    }
}

2. 基础实体类：

java:wiselearn-server/src/main/java/com/wiselearn/model/entity/BaseEntity.java

package com.wiselearn.model.entity;

import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.MappedSuperclass;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

import java.time.LocalDateTime;

@Getter
@Setter
@MappedSuperclass
public abstract class BaseEntity {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @CreationTimestamp
    private LocalDateTime createdAt;

    @UpdateTimestamp
    private LocalDateTime updatedAt;
}

3. 全局异常处理：

java:wiselearn-server/src/main/java/com/wiselearn/exception/GlobalExceptionHandler.java

package com.wiselearn.exception;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        return ResponseEntity.internalServerError().body(e.getMessage());
    }
}

现在我们已经创建了基本的包结构和一些基础类。目录结构如下：

src/main/java/com/wiselearn/
├── WiselearnServerApplication.java
├── config/
│   └── WebConfig.java
├── controller/
├── service/
├── repository/
├── model/
│   ├── entity/
│   │   └── BaseEntity.java
│   └── dto/
├── security/
├── exception/
│   └── GlobalExceptionHandler.java
└── util/

这些基础类提供了：

1. 跨域配置（WebConfig）
2. 实体类的基础属性（BaseEntity）
3. 全局异常处理（GlobalExceptionHandler）

接下来我们需要：

1. 配置application.properties（数据库连接等）
2. 创建用户相关的实体类和接口
3. 配置Spring Security

按照以下顺序进行：
1.先配置 application.properties（数据库连接等）

• 这是最基础的配置
• 没有这个配置，后面的实体类无法正确连接数据库
• 包括数据库连接、JPA配置、服务器端口等

2.然后创建用户相关的实体类和接口

• 因为Spring Security的配置需要依赖用户实体和用户服务
• 包括User实体类、UserRepository、UserService等

3.最后配置 Spring Security

• 这部分依赖于前面的用户实体和服务
• 包括认证、授权、密码加密等配置

2. 配置数据库连接

在 application.properties 中添加数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/wiselearn?createDatabaseIfNotExist=true&useSSL=false&serverTimezone=UTC
spring.datasource.username=admin
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

server.port=8080
server.servlet.context-path=/api

3. 创建基础实体类

数据库配置已经更新完成。现在让我们开始创建用户相关的实体类和接口。我们需要创建以下文件：

• 用户实体类（User.java）
• 用户角色枚举（UserRole.java）
• 用户仓库接口（UserRepository.java）
• 用户服务接口和实现（UserService.java 和 UserServiceImpl.java）

用户角色枚举：

public enum UserRole {
    STUDENT,
    TEACHER,
    ADMIN
}

基础实体类：

@Getter
@Setter
@MappedSuperclass
public abstract class BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    private LocalDateTime updatedAt;
}

用户实体类：

@Data
@EqualsAndHashCode(callSuper = true)
@Entity
@Table(name = "users")
public class User extends BaseEntity {
    @NotBlank(message = "用户名不能为空")
    @Column(unique = true)
    private String username;
    
    @NotBlank(message = "密码不能为空")
    private String password;
    
    @Email(message = "邮箱格式不正确")
    @Column(unique = true)
    private String email;
    
    private String phone;
    private String realName;
    
    @Enumerated(EnumType.STRING)
    private UserRole role;
    
    private Boolean enabled = true;
}

我们已经创建了用户相关的所有基础类：

• User实体类：包含用户的基本信息字段
• UserRole枚举：定义了用户角色（学生、教师、管理员）
• UserRepository：数据访问层接口
• UserService：服务层接口
• UserServiceImpl：服务层实现类

4. 创建数据访问层

接下来我们需要配置Spring Security。这将包括：
安全配置类
JWT工具类
认证过滤器
用户详情服务

UserRepository.java

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

5. 配置 Spring Security

JWT 工具类（JwtTokenUtil.java）：

@Component
public class JwtTokenUtil {
    private static final long JWT_TOKEN_VALIDITY = 24 * 60 * 60 * 1000;
    private final Key key = Keys.secretKeyFor(SignatureAlgorithm.HS512);
    
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        return createToken(claims, userDetails.getUsername());
    }
}

安全配置（SecurityConfig.java）：

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated()
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            );
        return http.build();
    }
}

6. 认证功能

登录请求 DTO（LoginRequest.java）：

@Data
public class LoginRequest {
    @NotBlank(message = "用户名不能为空")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    private String password;
}

认证服务（AuthService.java）：

@Service
public class AuthService {
    public AuthResponse login(LoginRequest request) {
        // 登录逻辑
    }
    
    public AuthResponse register(RegisterRequest request) {
        // 注册逻辑
    }
}

认证控制器（AuthController.java）：

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @Autowired
    private AuthService authService;
    
    @PostMapping("/login")
    public ResponseEntity<AuthResponse> login(@Valid @RequestBody LoginRequest request) {
        return ResponseEntity.ok(authService.login(request));
    }
}

API 端点

• POST /api/auth/login - 用户登录
• POST /api/auth/register - 用户注册

注意事项

• 确保 MySQL 运行并配置正确的数据库连接
• 服务器端口冲突时可调整 server.port
• 结合 Spring Security 进行权限管理
• 确保 JWT 配置正确并安全存储密钥

-------------本文结束感谢您的阅读-------------

本文作者： 金金
本文链接： http://example.com/2025/03/10/关于-Spring-Boot-的后端搭建教程/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！