首页手记 Spring Boot 3 + JDK 17 搭建后端教程

Spring Boot 3 + JDK 17 搭建后端教程

标签：

Java SpringBoot

概述

本文详细介绍了如何使用Spring Boot 3和JDK 17搭建后端教程，涵盖了环境准备、项目创建、配置、依赖添加以及编写后端接口的全过程。通过本文，读者可以学会如何安装必要的开发工具、配置项目并运行简单的RESTful API。

环境准备

在开始搭建 Spring Boot 3 和 JDK 17 的项目之前，首先需要安装 JDK 17，选择一个合适的 IDE，以及安装构建工具 Maven 或 Gradle。

安装 JDK 17

访问 Oracle 官方网站（https://www.oracle.com/java/technologies/javase/jdk17-downloads.html）或 Adoptium 网站（https://adoptium.net/），下载 JDK 17 的安装包。
运行下载的安装包，按照安装向导完成安装。
配置环境变量：
- JAVA_HOME：指向 JDK 安装的路径；
- PATH：添加 %JAVA_HOME%\bin 到 PATH 变量中。

检查 JDK 安装

确认安装成功，可以通过命令行运行以下命令来检查 JDK 版本：

java -version

输出信息应包含 "java version "17"。

安装 IDE（推荐 IntelliJ IDEA 或 Eclipse）

下载 IntelliJ IDEA（https://www.jetbrains.com/idea/download/）或 Eclipse（https://www.eclipse.org/downloads/packages/）。
运行安装程序，按照向导完成安装。
打开 IDE，选择 "File" -> "New" -> "Project" 以创建新项目。

Eclipse 安装步骤和配置

下载 Eclipse（https://www.eclipse.org/downloads/packages/）。
运行安装向导，选择合适的安装类型并完成安装。
打开 Eclipse，选择 "File" -> "New" -> "Project" 以创建新项目。
配置 Eclipse 中的 Maven 或 Gradle 插件：
- 安装 Maven 插件：Help -> Eclipse Marketplace -> 搜索 "Maven Integration for Eclipse" 并安装。
- 安装 Gradle 插件：Help -> Eclipse Marketplace -> 搜索 "Gradle Integration for Eclipse" 并安装。

安装 Maven 或 Gradle

Maven：访问 Maven 官方网站（https://maven.apache.org/download.cgi），下载 Maven 的二进制发行包。
解压到本地计算机，配置环境变量：
- MAVEN_HOME：指向 Maven 安装的路径；
- PATH：添加 %MAVEN_HOME%\bin 到 PATH 变量中。
Gradle：下载 Gradle 发行包（https://gradle.org/releases/），解压到本地计算机，配置环境变量：
- GRADLE_HOME：指向 Gradle 安装的路径；
- PATH：添加 %GRADLE_HOME%\bin 到 PATH 变量中。
检查安装：

mvn -v

或

gradle -v

分别输出 Maven 和 Gradle 的版本信息。

创建 Spring Boot 3 项目

创建一个 Spring Boot 3 项目，推荐使用 Spring Initializr 这个工具来快速搭建项目。

使用 Spring Initializr 创建新项目

访问 Spring Initializr 页面（https://start.spring.io/）。
选择项目配置：
- Project：Spring Boot 项目；
- Language：Java；
- Spring Boot：选择最新版本（例如 3.x.x）；
- Dependencies：根据需求选择，例如 Web、JPA、MyBatis 等。
点击 "Generate" 生成项目压缩包，下载并解压。
解压后，项目目录结构如下：

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── myapp/
│   │   │               ├── MyApplication.java
│   │   │               └── controller/
│   │   │                   └── HelloController.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── myapp/
│                       └── MyApplicationTests.java
└── pom.xml

Eclipse 中创建和导入项目

打开 Eclipse。
在 Eclipse 中，选择 "File" -> "New" -> "Project"，选择 "Maven Project"。
在向导中选择 "Create a simple project (skip archetype selection)"。
确保 "Use default workspace location" 选中，然后点击 "Next"。
输入项目名称和 groupId、artifactId，选择 Maven 版本。
点击 "Finish" 完成项目创建。
导入解压后的项目文件夹。

导入项目到 IDE

打开 IntelliJ IDEA 或 Eclipse。
在 IDE 中，选择 "File" -> "Open"，选择解压后的项目文件夹。
如果使用 IntelliJ IDEA，需要等待 IDE 进行代码索引。
确保 Maven 或 Gradle 插件已安装，IDE 会自动检测并使用项目中指定的构建工具。

项目配置

在项目创建后，需要配置构建工具和 Spring Boot 应用主类。

配置 Maven 或 Gradle 构建工具

Maven 和 Gradle 的配置文件分别是 pom.xml 和 build.gradle。本文以 Maven 为例进行配置。

使用 Maven 配置项目

打开 pom.xml 文件，确保包含以下基本配置：

<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>my-spring-boot-app</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>my-spring-boot-app</name>
    <packaging>jar</packaging>
    <dependencies>
        <!-- Spring Boot Starter Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.0.0</version>
        </dependency>
        <!-- 其他依赖 -->
    </dependencies>
    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
</project>

配置 application.properties 文件，根据需要定义应用属性：

server.port=8080
spring.application.name=my-spring-boot-app

使用 Gradle 配置项目

打开 build.gradle 文件，确保包含以下基本配置：

plugins {
    id 'org.springframework.boot' version '3.0.0'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'
targetCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // 其他依赖
}

配置 Spring Boot 应用主类

打开 MyApplication.java 文件，确保包含以下内容：

package com.example.myapp;

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

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

这个主类使用了 @SpringBootApplication 注解，该注解是 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 的组合，用于定义 Spring Boot 应用的入口点。

添加和使用依赖

在创建项目时，已经添加了一些常用的依赖，如 Web 依赖。接下来介绍如何添加更多依赖，并简要讨论这些依赖的使用方法。

添加 Web 依赖

在 pom.xml 文件中，添加 spring-boot-starter-web 依赖来支持 Web 应用：

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

这个依赖包含了 Spring MVC 和 Web 服务器的必要组件，可以轻松实现 RESTful API。

添加其他常用依赖

添加 JPA 和 MyBatis 依赖：

<!-- JPA -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>3.0.0</version>
</dependency>

<!-- MyBatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>

JPA 依赖的简单使用

在 application.properties 配置数据源和数据库连接：

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

创建一个简单的实体类：

package com.example.myapp.entity;

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;
    private String email;

    // Getters and Setters
}

创建一个 UserRepository 接口：

package com.example.myapp.repository;

import com.example.myapp.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

使用 UserRepository 在服务类中操作数据：

package com.example.myapp.service;

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

import java.util.List;

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

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

MyBatis 依赖的简单使用

在 application.properties 中配置数据源和数据库连接：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
mybatis.mapper-locations=classpath:mapper/*.xml

创建一个简单的 UserMapper.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.myapp.mapper.UserMapper">

    <select id="findUsers" resultType="com.example.myapp.entity.User">
        SELECT id, name, email FROM user
    </select>

</mapper>

创建 UserMapper 接口：

package com.example.myapp.mapper;

import com.example.myapp.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface UserMapper {
    @Select("SELECT id, name, email FROM user")
    List<User> findUsers();
}

在服务类中使用 UserMapper：

package com.example.myapp.service;

import com.example.myapp.entity.User;
import com.example.myapp.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public List<User> findAllUsers() {
        return userMapper.findUsers();
    }
}

添加更多依赖配置

例如，添加 Spring Security 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
    <version>3.0.0</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
    <version>3.0.0</version>
</dependency>

邮件发送依赖的简单使用

在 application.properties 中配置邮件发送：

spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=your-email@gmail.com
spring.mail.password=your-email-password
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

创建一个简单的邮件发送服务类：

package com.example.myapp.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

@Service
public class EmailService {

    @Autowired
    private JavaMailSender javaMailSender;

    public void sendEmail(String to, String subject, String body) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(body);

        javaMailSender.send(message);
    }
}

编写后端接口

编写后端接口时，通常会创建 RESTful API，添加响应体和状态码，以提供清晰且可维护的接口定义。

创建简单的 RESTful API

创建 HelloController 类，定义一个简单的 RESTful 接口：

package com.example.myapp.controller;

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

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

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/hello")
    public Map<String, String> sayHello() {
        Map<String, String> response = new HashMap<>();
        response.put("message", "Hello, World!");
        return response;
    }
}

添加响应体和状态码

在同一个 HelloController 类中添加一个带有响应体和状态码的接口：

@GetMapping("/status")
public Map<String, String> getStatus() {
    Map<String, String> response = new HashMap<>();
    response.put("status", "ok");
    response.put("code", "200");
    return response;
}

可以使用 @ResponseStatus 注解来定义响应码，例如：

@GetMapping("/error")
public Map<String, String> getError() {
    Map<String, String> response = new HashMap<>();
    response.put("message", "Error occurred");
    return response;
}

定义一个异常处理器来处理异常：

package com.example.myapp.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;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, String>> handleException(Exception ex) {
        Map<String, String> response = new HashMap<>();
        response.put("message", ex.getMessage());
        return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

创建更复杂的 RESTful API

创建一个带有分页、过滤和排序功能的接口：

@GetMapping("/users")
public Map<String, Object> getUsers(@RequestParam(required = false) Integer page,
                                    @RequestParam(required = false) Integer size,
                                    @RequestParam(required = false) String sort) {
    Map<String, Object> response = new HashMap<>();
    Integer currentPage = (page != null) ? page : 1;
    Integer pageSize = (size != null) ? size : 10;
    String sortField = (sort != null) ? sort : "id";

    // 例如，使用分页，过滤和排序的逻辑
    // response.put("users", userService.findAllUsers(currentPage, pageSize, sortField));

    return response;
}

运行和测试项目

完成项目配置和接口编写后，可以通过 IDE 运行项目，并使用 Postman 等工具测试接口。

使用 IDE 运行项目

在 IntelliJ IDEA 或 Eclipse 中，右键点击 MyApplication.java 类。
选择 "Run 'MyApplication.main(...)'", 启动 Spring Boot 应用。

项目启动后，可以通过命令行查看输出，确认应用是否已成功启动：

2023-10-10 12:00:00.000 [main] INFO  o.s.b.web.embedded.tomcat.TomcatEmbeddedServletContainer - Tomcat started on port(s): 8080 (http)

使用 Postman 等工具测试接口

打开 Postman 或其他 HTTP 请求客户端。
输入 URL，例如 http://localhost:8080/api/hello。
发送 GET 请求，查看响应信息。

示例请求：

GET /api/hello HTTP/1.1
Host: localhost:8080

示例响应：

{
  "message": "Hello, World!"
}

通过 Postman 或其他工具，还可以测试其他接口，包括带有状态码和异常处理的接口。

在不同IDE中运行项目的详细步骤

在 Eclipse 中运行项目

在 Eclipse 中，右键点击 MyApplication.java 类。
选择 "Run As" -> "Java Application"。

在 IntelliJ IDEA 中运行项目

在 IntelliJ IDEA 中，右键点击 MyApplication.java 类。
选择 "Run 'MyApplication.main(...)'", 启动 Spring Boot 应用。

更复杂的测试案例

测试带有状态码的接口 http://localhost:8080/api/status。
测试异常处理接口 http://localhost:8080/api/error。
测试带有分页、过滤和排序功能的接口 http://localhost:8080/api/users?page=1&size=10&sort=id。
测试邮件发送接口 http://localhost:8080/api/email?to=example@example.com&subject=Test&body=This is a test email.。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

holdtom

手记
篇

粉丝

240

获赞与收藏

992

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19278 315

Java 并发原理入门教程

26个小节 39003 568

Java 入门教程

50个小节 342046 3165

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空