SpringBoot3+JDK17搭建后端简单教程-原创手记-慕课网

概述

本文详细介绍了如何使用Spring Boot 3和JDK 17搭建后端项目，涵盖从环境准备到项目构建，再到开发RESTful API和运行调试的每个步骤。通过本文，你将学会如何配置Spring Boot项目、设置数据源连接数据库以及创建简单的RESTful API。

环境准备

在开始搭建Spring Boot 3和JDK 17的后端项目之前，需要确保你的开发环境已经准备好。以下是环境准备的具体步骤：

检查操作系统要求

Spring Boot 可以在多种操作系统上运行，包括 Windows、macOS 和 Linux。无论你使用哪种操作系统，都需要确保它支持 Java 并且有足够稳定的网络连接来下载必要的软件。

示例代码

为了确保你的操作系统是最新版本并支持 Java，可以通过命令行检查你的操作系统版本。以下是在不同操作系统中检查版本信息的命令示例：

Windows:
```
echo %OS%
```
macOS:
```
echo $OSTYPE
```
Linux:
```
cat /etc/os-release
```

安装JDK17

为了运行 Spring Boot 应用，你需要先安装 JDK 17。JDK（Java Development Kit）包含了Java运行时环境（JRE）以及编译Java程序的工具。以下是安装 JDK 17 的步骤：

访问 Oracle 官方网站或 AdoptOpenJDK 等下载源下载 JDK 17。
下载完成后，运行安装程序并按照提示完成安装。
安装完成后，可以使用命令 java -version 检查是否安装成功。

示例代码

在命令行中执行以下命令来检查 Java 版本：

java -version

如果安装成功，命令将显示 Java 版本信息，例如：

java version "17.0.1" 2021-10-19 LTS
Java(TM) SE Runtime Environment (build 17.0.1+12-LTS-39)
Java HotSpot(TM) 64-Bit Server VM (build 17.0.1+12-LTS-39, mixed mode, sharing)

配置JAVA_HOME环境变量

安装好 JDK 后，设置环境变量 JAVA_HOME 来指向 JDK 的安装目录。这将帮助系统识别 Java 的安装位置。

示例代码

在 Windows 系统中，可以通过以下步骤设置 JAVA_HOME 环境变量：

打开“此电脑”右键点击选择“属性”。
点击“高级系统设置”。
在“系统属性”对话框中，点击“环境变量”按钮。
在“环境变量”对话框中，找到“系统变量”部分，点击“新建”按钮。
在新建变量对话框中，输入 JAVA_HOME 作为变量名，输入 JDK 的安装路径作为变量值（例如：C:\Program Files\Java\jdk-17）。
点击“确定”保存设置。

在 MacOS 或 Linux 系统中，编辑 .bashrc 或 .zshrc 文件（取决于你使用的 shell 类型），添加以下设置：

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home

保存后，运行 source ~/.bashrc 或 source ~/.zshrc 使环境变量生效。

验证JDK安装

通过命令行运行 Java 程序来验证 JDK 安装是否成功。可以运行一个简单的 Java程序来测试。

示例代码

创建一个简单的 Java 程序 HelloWorld.java：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

在命令行中编译并运行程序：

javac HelloWorld.java
java HelloWorld

程序成功输出 "Hello, World!" 表示 JDK 已经正确安装并配置。

创建Spring Boot项目

现在你已经准备好开发环境，接下来让我们开始创建 Spring Boot 项目。

使用Spring Initializr创建项目

Spring Initializr 是一个在线工具，可以生成基本的 Spring Boot 应用程序结构。访问 Spring Initializr 网站并按照以下步骤创建项目：

选择 Maven 或 Gradle 作为构建工具。
选择 Java 作为语言。
输入项目基本信息，如项目名称、描述、包名、Java 版本、Spring Boot 版本等。
选择需要的依赖，如 Web、JPA、Thymeleaf 等。
点击 "Generate" 按钮下载项目压缩包或直接导入 IDE。

示例代码

以下是一个使用 Spring Initializr 生成的项目结构的示例代码。假设我们创建一个名为 demo 的 Spring Boot 项目，包含 Web 和 JPA 依赖：

<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>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>17</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <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>

导入项目到IDE中

导入项目到 IDE（例如 IntelliJ IDEA 或 Eclipse）中，以便进行后续的开发工作。

示例代码

导入项目到 IntelliJ IDEA 中：

打开 IntelliJ IDEA。
点击 File -> New -> Project from Existing Sources。
选择 Existing Sources，点击 Next。
选择 Maven 或 Gradle 项目，然后选择下载的项目文件夹。
点击 Next，选择导入项目的目录。
点击 Finish 完成项目导入。

导入项目到 Eclipse 中：

打开 Eclipse。
点击 File -> Import。
选择 Existing Projects into Workspace，点击 Next。
选择 File System，点击 Next。
选择下载的项目文件夹。
点击 Finish 完成项目导入。

项目结构简介

生成的项目结构主要包括以下部分：

src/main/java：存放 Java 源代码文件。
src/main/resources：存放配置文件（如 application.properties）。
src/test/java：存放测试代码。
pom.xml（或 build.gradle）：项目构建描述文件。

示例代码

以下是项目结构的具体示例：

- src/main/java
  - com/example/demo
  - DemoApplication.java
  - model
  - User.java
  - repository
  - UserRepository.java
  - service
  - UserService.java
  - controller
  - UserController.java
- src/main/resources
  - application.properties
- pom.xml

配置Spring Boot项目

配置 Spring Boot 项目以满足实际需求，包括设置应用的端口和默认编码、配置数据源连接数据库、添加依赖并管理版本。

设置应用的端口和默认编码

在 application.properties 文件中配置应用运行的端口和默认编码。

示例代码

在 src/main/resources 目录下的 application.properties 文件中添加以下配置：

server.port=8080
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp
server.servlet.context-path=/demo
spring.messages.basename=i18n/messages
spring.messages.encoding=UTF-8

这些配置包括了端口设置、数据源 URL 和数据库驱动类名等。

配置数据源连接数据库

根据项目需求配置数据源连接数据库。这里使用的是内存 H2 数据库，但在生产环境中通常会连接到 MySQL 或 PostgreSQL 等数据库。

示例代码

在 application.properties 文件中，可以添加以下配置来连接外部数据库：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

添加依赖并管理版本

在 pom.xml 或 build.gradle 文件中添加并管理项目依赖。

示例代码

在 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-data-jpa</artifactId>
    </dependency>
    <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>

开发简单RESTful API

接下来，我们将开发一个简单的 RESTful API。包括创建实体类、Repository 接口、Service 层实现和 Controller 层接口。

创建实体类

实体类代表数据库中的表结构。使用 @Entity 注解将类标记为实体类，并使用 @Table 注解来指定与实体类对应的数据库表名。

示例代码

假设我们有一个 User 实体类：

package com.example.demo.model;

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

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private String email;

    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接口

Repository 接口用于定义数据访问层的方法，例如查询、保存和删除实体类。

示例代码

为 User 实体类创建对应的 UserRepository 接口：

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> {
}

创建Service层实现

Service 层用于业务逻辑处理，通常调用 Repository 层提供的方法完成数据操作。

示例代码

创建 UserService 类，实现一些业务逻辑：

package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> listAll() {
        return userRepository.findAll();
    }

    public Optional<User> getUser(Long id) {
        return userRepository.findById(id);
    }

    public User saveUser(User user) {
        return userRepository.save(user);
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

创建Controller层接口

Controller 层用于处理 HTTP 请求，通常返回 JSON 格式的数据。

示例代码

创建 UserController 类，处理用户相关的 HTTP 请求：

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> listAllUsers() {
        return userService.listAll();
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        Optional<User> user = userService.getUser(id);
        return user.map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.saveUser(user);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        if (!userService.getUser(id).isPresent()) {
            return ResponseEntity.notFound().build();
        }
        user.setId(id);
        return ResponseEntity.ok(userService.saveUser(user));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        if (!userService.getUser(id).isPresent()) {
            return ResponseEntity.notFound().build();
        }
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

测试RESTful API

你可以通过 Postman 或其他工具来测试 API 的功能，也可以使用 Spring Boot 内置的测试框架进行单元测试。

示例代码

使用 Spring Boot 内置测试框架编写单元测试：

package com.example.demo;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @BeforeEach
    public void setUp() {
        User user = new User();
        user.setName("Test User");
        user.setEmail("testuser@example.com");
        userService.saveUser(user);
    }

    @Test
    public void listAllUsers() {
        List<User> users = userService.listAll();
        assertEquals(1, users.size());
    }

    @Test
    public void getUserById() {
        Optional<User> user = userService.getUser(1L);
        assertTrue(user.isPresent());
        assertEquals("Test User", user.get().getName());
    }

    @Test
    public void saveUser() {
        User user = new User();
        user.setName("New User");
        user.setEmail("newuser@example.com");
        User savedUser = userService.saveUser(user);
        assertNotNull(savedUser.getId());
        assertEquals("New User", savedUser.getName());
    }

    @Test
    public void deleteUser() {
        User user = userService.getUser(1L).get();
        userService.deleteUser(user.getId());
        assertFalse(userService.getUser(1L).isPresent());
    }
}

运行与调试

现在我们可以打包项目为可执行的 jar 文件，并通过命令行或 IDE 进行运行。也可以使用 IDE 进行调试。

打包项目为可执行jar文件

使用 Maven 或 Gradle 将项目打包为可执行 jar 文件。

示例代码

在命令行中，使用 Maven 打包项目：

mvn clean package

或使用 Gradle 打包项目：

./gradlew clean build

这将生成一个 jar 文件，位于 target 或 build/libs 目录下。

运行jar文件

运行生成的 jar 文件来启动应用。

示例代码

在命令行中，使用以下命令运行 jar 文件：

java -jar target/demo-0.0.1-SNAPSHOT.jar

使用IDE进行调试

可以使用 IDE 进行调试，例如 IntelliJ IDEA 或 Eclipse。

示例代码

在 IntelliJ IDEA 中，右键点击主类 DemoApplication，选择 Debug 'DemoApplication'，开始调试。

在 Eclipse 中，右键点击主类 DemoApplication，选择 Debug As -> Java Application，开始调试。

常见问题与解决方案

在开发 Spring Boot 应用过程中，可能会遇到一些问题。这里列举一些常见问题及解决方案。

项目启动失败的常见原因及解决办法

启动项目失败通常是因为依赖版本冲突、缺少必要的依赖或配置错误。

示例代码

配置文件格式错误：

# 错误示例
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# 正确的配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

缺少必要的依赖（例如 JPA 和数据库驱动）会导致启动失败，确保在 pom.xml 或 build.gradle 中添加了正确的依赖。

数据库连接失败的情况及解决方法

数据库连接失败可能是由于数据库地址和端口错误，数据库未启动，或数据库驱动版本不匹配。

示例代码

数据库连接配置示例：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

确保数据库服务已启动，并且 spring.datasource.url 中的地址和端口正确。

性能优化的小技巧

启用缓存：Spring Boot 提供了多种缓存实现，如 EhCache、Caffeine 等。通过配置缓存可以提高应用性能。
使用连接池：数据库连接池（如 HikariCP）可以提高数据库访问性能。配置 spring.datasource.hikari.* 属性来设置连接池参数。
禁用调试日志：减少不必要的日志输出可以提高性能。

示例代码

启用缓存配置示例：

spring.cache.type=caffeine

配置连接池示例：

spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.max-lifetime=1800000
spring.datasource.hikari.idle-timeout=600000

禁用调试日志配置示例：

logging.level.org.springframework=ERROR

通过以上配置可以优化应用的性能。

通过以上步骤，你已经成功搭建了一个基于 Spring Boot 3 和 JDK 17 的后端项目，并了解了如何配置项目、开发 RESTful API 和运行调试项目。希望这些信息对你有所帮助。