Springboot3+JDK17搭建后端入门教程

概述

本文详细介绍了如何使用Springboot3+JDK17搭建后端入门项目，包括JDK17的安装与配置、Spring Boot 3的项目创建与配置、以及基本的CRUD操作实现。通过跟随本文的步骤，读者可以快速搭建并运行一个基础的Spring Boot后端应用。

环境搭建 JDK17安装与配置

安装JDK17

安装JDK17的第一步是下载合适的安装包。访问Oracle官方网站或从OpenJDK获取适合您操作系统的安装文件。下载完成后，安装过程通常包括选择安装位置、设置环境变量等步骤。

配置环境变量

安装完成后，需要在系统中配置Java环境变量，包括JAVA_HOME、PATH和CLASSPATH。具体步骤如下：

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

# 设置PATH
export PATH=$JAVA_HOME/bin:$PATH

# 设置CLASSPATH
export CLASSPATH=$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar

配置完成后，可以通过以下命令验证JDK17是否安装成功：

java -version

输出应显示JDK17版本信息。

Spring Boot 3安装与配置

创建并配置Spring Boot项目

在Spring Initializr网站上创建一个新的Spring Boot项目。选择所需的依赖项，例如Spring Web和Spring Data JPA。下载并解压项目文件到本地，或使用IDEA导入项目。

配置Spring Boot项目

在Spring Boot项目中，最核心的配置文件是application.properties或application.yml。这些文件位于src/main/resources目录下。

# application.properties示例
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

# 或者使用YAML格式
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: update

运行Spring Boot应用

使用IDEA运行Spring Boot应用，确保应用正常启动，并在控制台输出中看到Started Application in ... seconds的信息。

创建第一个Spring Boot项目 使用IDEA创建Spring Boot项目

打开IntelliJ IDEA，选择“File” -> “New” -> “Project”。在弹出的窗口中选择“Spring Initializr”。

填写项目名称，选择语言（Java），选择项目版本（Java 17），选择Spring Boot版本（3.x.x）。点击“Next”按钮，选择Spring Boot依赖项，例如Spring Web和Spring Data JPA，完成设置后点击“Finish”。

导入项目后，确保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>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

搭建基本项目结构

Spring Boot项目的基本结构包括以下几个部分：

• src/main/java：存放Java源代码文件。
• src/main/resources：存放配置文件，如application.properties或application.yml。
• src/main/resources/static：存放静态资源文件，如HTML、CSS、JavaScript。
• src/main/resources/templates：存放Thymeleaf模板文件。

创建第一个控制器

在src/main/java目录下创建一个新的Java类，例如HelloController，并定义一个简单的REST API。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot 3!";
    }
}

运行并测试应用

运行Spring Boot应用，访问http://localhost:8080/hello，查看是否返回Hello, Spring Boot 3!。

Spring Boot核心概念与配置 了解Spring Boot的核心组件

Spring Boot的核心组件包括：

• 自动配置：Spring Boot会根据类路径中的依赖来自动配置Spring应用。
• 启动器：Spring Boot提供了许多启动器，每个启动器都包含了一系列的依赖项。
• 嵌入式服务器：Spring Boot支持嵌入式服务器，例如Tomcat或Jetty。
• Actuator：提供了生产就绪的功能，如健康检查、信息端点等。
• 外部配置：支持从各种来源加载配置，如命令行参数、环境变量、配置文件等。

自动配置示例

Spring Boot的自动配置根据类路径中的依赖自动配置Spring应用。例如，当引入spring-boot-starter-web依赖时，Spring Boot会自动配置一个Tomcat服务器。

启动器示例

使用spring-boot-starter-web启动器，可以快速创建一个包含Spring MVC的Web应用。

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

编写并运行第一个Spring Boot应用

项目结构

创建一个新的Spring Boot项目，结构如下：

src
├── main
│   ├── java
│   │   └── com.example.demo
│   │       └── DemoApplication.java
│   │       └── HelloController.java
│   ├── resources
│   │   ├── application.properties
│   │   └── static
│   │   └── templates

主类

主类DemoApplication作为应用的入口，使用@SpringBootApplication注解标记。

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);
    }
}

运行应用

运行DemoApplication，查看控制台输出。应用应该成功启动，并监听8080端口。

访问http://localhost:8080/hello，验证是否返回Hello, Spring Boot 3!。

常用依赖与配置 添加依赖包

添加Web依赖

通过在pom.xml文件中添加spring-boot-starter-web依赖，可以快速构建Web应用。

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

添加JPA依赖

通过添加spring-boot-starter-data-jpa依赖，可以快速构建JPA应用。

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

添加MySQL依赖

通过添加MySQL驱动依赖，可以连接到MySQL数据库。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

配置文件详解

application.properties

配置文件application.properties用于配置应用的属性，例如数据库连接。

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# JPA配置
spring.jpa.hibernate.ddl-auto=update

application.yml

配置文件application.yml使用YAML格式进行配置。

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

CRUD操作入门 创建RESTful API服务

RESTful API基础

RESTful API是一种设计风格，用于构建Web服务。它遵循一些设计原则，如无状态、单一职责、资源定位符等。

创建RESTful控制器

创建一个新的控制器UserController，定义RESTful API。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.List;

@RestController
public class UserController {

    @GetMapping("/users")
    public List<User> getUsers() {
        return Arrays.asList(new User("John Doe", 30), new User("Jane Doe", 25));
    }
}

用户实体

定义用户实体User。

package com.example.demo;

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

测试API

运行应用，访问http://localhost:8080/users，验证是否返回用户列表。

实现增删改查操作

添加用户

定义一个方法addUser，用于添加新用户。

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
public class UserController {

    private Map<String, User> users = new HashMap<>();

    @GetMapping("/users/add")
    public User addUser(@RequestParam String name, @RequestParam int age) {
        String id = String.valueOf(users.size() + 1);
        User newUser = new User(name, age);
        users.put(id, newUser);
        return newUser;
    }

    @GetMapping("/users")
    public List<User> getUsers() {
        return new ArrayList<>(users.values());
    }
}

查询用户

定义一个方法getUser，根据用户ID查询用户。

@GetMapping("/users/{id}")
public User getUser(@PathVariable String id) {
    return users.get(id);
}

更新用户

定义一个方法updateUser，用于更新现有用户。

@GetMapping("/users/update/{id}")
public User updateUser(@PathVariable String id, @RequestParam String name, @RequestParam int age) {
    User user = users.get(id);
    user.setName(name);
    user.setAge(age);
    return user;
}

删除用户

定义一个方法deleteUser，用于删除用户。

@GetMapping("/users/delete/{id}")
public void deleteUser(@PathVariable String id) {
    users.remove(id);
}

测试CRUD操作

编写单元测试或通过Postman工具测试CRUD操作，验证增删改查功能是否正常。

项目打包与部署 打包Spring Boot应用

打包命令

使用Maven或Gradle打包Spring Boot应用。

mvn clean package

配置文件

确保打包时包含配置文件，可以在pom.xml中配置。

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

打包后的文件

打包完成后，会在target目录下生成一个.jar或.war文件。

部署到Tomcat或使用内置服务器

使用内置服务器

Spring Boot提供了一个内置的Tomcat服务器，可以在开发过程中直接使用。

java -jar target/my-app.jar

部署到Tomcat

将打包后的.war文件部署到Tomcat服务器。

1. 将.war文件复制到Tomcat的webapps目录。
2. 启动Tomcat服务器。
3. 访问http://localhost:8080/my-app，验证应用是否正常运行。

调试与日志

确保应用的日志配置正确，可以在application.properties中配置日志级别。

logging.level.root=INFO

监控与健康检查

使用Spring Boot Actuator监控应用的状态，例如/actuator/health端点可以检查应用的健康状况。

资源管理

确保静态资源路径正确，Spring Boot默认会查找/static、/public、/resources等目录中的静态文件。

数据库连接

确保数据库连接配置正确，应用启动时能正确连接到数据库。

运行时环境配置

在生产环境中，可以通过环境变量或外部配置文件设置应用的运行时环境配置。

部署策略

根据应用的需求选择合适的部署策略，例如集群部署、负载均衡等。

常见问题解决

• 依赖冲突：检查依赖版本是否冲突，使用IDEA的Maven或Gradle工具窗口进行查看。
• 端口冲突：修改应用配置文件中的端口号。
• 权限问题：确保应用有权限读写相关文件。