Springboot3+JDK17搭建后端学习：简易教程

概述

本文详细介绍了如何使用Spring Boot 3和JDK 17搭建后端学习环境，包括环境准备、创建项目、基础配置与Hello World示例等步骤，帮助读者快速上手。文章还涵盖了数据库集成和RESTful API设计等内容，提供了丰富的实战案例和配置方法。通过本文的学习，读者可以掌握Spring Boot 3的基本应用和开发技巧。

环境准备

检查系统要求

在使用Spring Boot 3和JDK 17之前，首先需要确保您的开发环境满足以下要求：

• 操作系统：Windows、Linux或macOS
• JDK版本：JDK 17或更高版本
• IDE：推荐使用IntelliJ IDEA或Spring Tool Suite
• 构建工具：Maven或Gradle

安装JDK 17

1. 访问JDK官方网站（https://jdk.java.net/17/）下载JDK 17的安装包。
2. 运行安装程序，按照提示完成安装。
3. 安装完成后，设置环境变量。具体步骤如下：
   • 打开系统属性 -> 高级系统设置 -> 环境变量。
   • 在系统变量中添加JAVA_HOME，值为JDK的安装路径。
   • 在系统变量中编辑Path，添加%JAVA_HOME%\bin。

验证环境变量配置：

• 打开命令行界面，输入java -version，如果显示JDK版本信息则表示配置成功。

安装IDE

推荐使用IntelliJ IDEA或Spring Tool Suite作为开发工具。

IntelliJ IDEA

1. 访问官网下载IntelliJ IDEA（https://www.jetbrains.com/idea/）。
2. 安装并启动IntelliJ IDEA。
3. 在第一次启动时，选择安装插件，推荐选择Spring Boot相关插件。

Spring Tool Suite

1. 访问官网下载Spring Tool Suite（https://spring.io/tools）。
2. 安装并启动Spring Tool Suite。
3. 在安装向导中选择Spring Boot支持。

安装Maven或Gradle

Maven

1. 访问Maven官网下载Maven（https://maven.apache.org/download.cgi）。
2. 解压下载的压缩包并将其安装到本地目录。
3. 设置环境变量：
   • 添加MAVEN_HOME，值为Maven的安装路径。
   • 编辑Path，添加%MAVEN_HOME%\bin。

验证Maven配置：

• 打开命令行界面，输入mvn -version，如果显示Maven版本信息则表示配置成功。

Gradle

1. 访问Gradle官网下载Gradle（https://gradle.org/releases/）。
2. 解压下载的压缩包并将其安装到本地目录。
3. 设置环境变量：
   • 添加GRADLE_HOME，值为Gradle的安装路径。
   • 编辑Path，添加%GRADLE_HOME%\bin。

验证Gradle配置：

• 打开命令行界面，输入gradle -v，如果显示Gradle版本信息则表示配置成功。

配置环境变量

确保JAVA_HOME、MAVEN_HOME和GRADLE_HOME已正确设置，并将相应的bin目录添加到Path变量中。

创建Spring Boot 3项目

选择Spring Initializr创建项目

1. 访问Spring Initializr网站（https://start.spring.io/）。
2. 选择项目的基本信息：
   • Project: Maven Project
   • Language: Java
   • Spring Boot: 3.0.0
   • Java: 17
   • Packaging: Jar
   • Java Version: 17
   • Dependencies: Web, Thymeleaf
3. 点击Generate按钮，下载生成的项目压缩包。
4. 解压下载的压缩包，导入到IDE中。

添加必要的依赖

在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
</dependencies>

项目结构介绍

项目的基本结构包括：

• src/main/java: Java源代码目录。
• src/main/resources: 资源文件目录，如application.properties或application.yml。
• src/main/resources/templates: Thymeleaf模板文件存放位置。
• src/test/java: 测试代码目录。
• pom.xml: Maven构建配置文件。

基础配置与Hello World示例

编写第一个Controller

创建一个简单的Controller类HelloController.java：

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @GetMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello World!";
    }
}

配置application.properties或application.yml

在src/main/resources目录下创建application.properties文件：

spring.application.name=demo-app
server.port=8080

也可以使用application.yml进行配置：

spring:
  application:
   name: demo-app
server:
  port: 8080

运行项目并测试

1. 在IDE中运行项目，启动Spring Boot应用。
2. 使用浏览器访问http://localhost:8080/hello，应显示Hello World!。

在命令行中运行项目：

• 使用Maven：在项目根目录下打开命令行，输入mvn spring-boot:run。
• 或者直接运行Application.java文件中的main方法。

数据库集成

连接MySQL或PostgreSQL

首先需要在项目中添加数据库驱动依赖。

MySQL

编辑pom.xml文件，添加MySQL驱动依赖：

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.0.26</version>
</dependency>

PostgreSQL

编辑pom.xml文件，添加PostgreSQL驱动依赖：

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.2.18</version>
</dependency>

在application.properties文件中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/demo_db
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

初始化数据库表结构的SQL脚本：

CREATE DATABASE demo_db;
USE demo_db;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50)
);

使用Spring Data JPA进行数据操作

首先在pom.xml文件中添加Spring Data JPA依赖：

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

实现实体类

创建一个简单的实体类User.java：

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // 省略getter和setter方法
}

创建Repository接口

创建一个简单的Repository接口UserRepository.java：

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

实现Controller

创建一个Controller处理数据操作：

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping
    public List<User> getUsers() {
        return userRepository.findAll();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        User existingUser = userRepository.findById(id).orElse(null);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            return userRepository.save(existingUser);
        }
        return null;
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

RESTful API设计

编写Controller处理HTTP请求

继续使用上一节中创建的UserController.java类，实现CRUD操作：

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
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 {

    @Autowired
    private UserRepository userRepository;

    @GetMapping
    public List<User> getUsers() {
        return userRepository.findAll();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = userRepository.findById(id).orElse(null);
        return ResponseEntity.ok(user);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        User existingUser = userRepository.findById(id).orElse(null);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            userRepository.save(existingUser);
            return ResponseEntity.ok(existingUser);
        }
        return ResponseEntity.notFound().build();
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        if (userRepository.existsById(id)) {
            userRepository.deleteById(id);
            return ResponseEntity.noContent().build();
        }
        return ResponseEntity.notFound().build();
    }
}

实现CRUD操作

在上述代码中，UserController类实现了RESTful API的CRUD操作：

• GET: 查询所有用户或特定用户。
• POST: 创建新用户。
• PUT: 更新特定用户。
• DELETE: 删除特定用户。

使用Swagger生成API文档

在项目中添加Swagger依赖：

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>3.0.0</version>
</dependency>

配置Swagger：

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }
}

启动项目后，可以通过http://localhost:8080/swagger-ui.html访问Swagger UI，查看生成的API文档。

错误处理与日志管理

处理异常并返回JSON格式的错误信息

创建一个全局异常处理器GlobalExceptionHandler.java：

package com.example.demo.exception;

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

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, Object>> handleException(Exception ex, HttpServletRequest request) {
        Map<String, Object> error = new HashMap<>();
        error.put("timestamp", System.currentTimeMillis());
        error.put("status", HttpStatus.INTERNAL_SERVER_ERROR.value());
        error.put("error", HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase());
        error.put("message", ex.getMessage());
        error.put("path", request.getServletPath());
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

配置日志框架（如SLF4J、Logback）

在pom.xml文件中添加依赖：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.36</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
</dependency>

配置logback.xml文件：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="com.example.demo" level="DEBUG"/>

    <root level="info">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

验证日志输出：

• 运行项目后，打开命令行界面输入java -jar target/demo-app.jar，查看控制台输出的日志信息。

添加日志记录到Controller和Service中

在Controller或Service中使用SLF4J进行日志记录：

package com.example.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private UserRepository userRepository;

    @GetMapping
    public List<User> getUsers() {
        logger.info("Getting all users");
        return userRepository.findAll();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        logger.info("Creating user: {}", user);
        return userRepository.save(user);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        logger.info("Getting user by id: {}", id);
        User user = userRepository.findById(id).orElse(null);
        return ResponseEntity.ok(user);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        logger.info("Updating user: {}", user);
        User existingUser = userRepository.findById(id).orElse(null);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            userRepository.save(existingUser);
            return ResponseEntity.ok(existingUser);
        }
        return ResponseEntity.notFound().build();
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        logger.info("Deleting user by id: {}", id);
        if (userRepository.existsById(id)) {
            userRepository.deleteById(id);
            return ResponseEntity.noContent().build();
        }
        return ResponseEntity.notFound().build();
    }
}

通过以上步骤，您已经成功搭建了一个使用Spring Boot 3和JDK 17的后端项目，并实现了基本的错误处理和日志管理。希望这能帮助您更好地理解和使用Spring Boot 3。