Springboot3学习：从入门到实战-原创手记-慕课网

概述

Spring Boot 3是Spring框架的最新版本，旨在简化开发过程，提高开发效率。本文将详细介绍Spring Boot 3的各项功能和优势，包括简化的配置、依赖管理、快速开发和健康监控等。通过学习Spring Boot 3，开发者可以更好地适应现代软件架构，提高软件质量和稳定性。从环境搭建到第一个项目的实现，本文将一步步引导你掌握Spring Boot 3的核心功能。

Spring Boot 3简介

什么是Spring Boot 3

Spring Boot 3是Spring框架的一个模块，它旨在简化Spring应用的开发过程，使开发者能够快速上手并构建功能完备的应用程序。Spring Boot 3遵循约定优于配置的原则，使得开发者可以专注于业务逻辑，而不需要处理大量的配置细节。

Spring Boot 3的优势

简化的配置：Spring Boot 3通过自动配置功能，减少了开发者在配置文件中的工作量。
依赖管理：Spring Boot 3自带了依赖管理功能，可以自动引入所需的依赖，减少配置错误。
快速开发：提供了大量的默认配置，使得开发者能够快速启动一个Spring Boot应用。
嵌入式服务器：Spring Boot 3内置了Tomcat、Jetty或Undertow服务器，简化了部署过程。
健康监控：Spring Boot 3提供了Actuator模块，用于监控应用的健康状态。
支持微服务架构：Spring Boot 3与Spring Cloud等其他框架集成，支持微服务架构的开发。

为什么学习Spring Boot 3

学习Spring Boot 3可以帮助开发者提高开发效率，简化配置，适应现代软件架构，并提高软件质量。例如，Spring Boot 3的自动配置功能可以减少配置错误，提高开发效率；支持微服务架构的特性使得开发者能够更轻松地构建和部署复杂的应用系统。

环境搭建

JDK安装与配置

JDK下载：访问Oracle官网或其他可信任的下载源，下载最新版本的JDK。例如，下载JDK 17版本。
安装JDK：双击下载的安装包，按照提示完成安装。
配置环境变量：
- 打开系统环境变量设置。
- 设置JAVA_HOME指向JDK的安装目录，例如C:\Program Files\Java\jdk-17。
- 设置PATH环境变量，添加%JAVA_HOME%\bin。
验证安装：
- 打开命令行工具，输入java -version，查看安装的JDK版本。

java -version

IDE环境搭建（推荐使用IntelliJ IDEA或Eclipse）

选择IDE：推荐使用IntelliJ IDEA或Eclipse作为开发工具。
安装IDE：访问IntelliJ IDEA或Eclipse官网，下载最新版本的安装包。
安装IDE：双击下载的安装包，按照提示完成安装。

IntelliJ IDEA配置

安装插件：安装Spring Boot插件，以支持Spring Boot项目开发。
创建新项目：选择File -> New -> Project，选择Spring Initializr。
选择项目类型：选择Maven或Gradle，并选择对应的Spring Boot版本。
填写项目信息：输入项目名称、语言（Java）、依赖范围等，点击Finish。

Eclipse配置

安装插件：在Eclipse市场中搜索并安装Spring Boot插件。
创建新项目：选择File -> New -> Spring Starter Project。
选择项目类型：选择项目名称、语言（Java），并选择对应的Spring Boot版本。
配置项目：选择需要的依赖，点击Finish。

Maven或Gradle配置

Maven配置：

在项目根目录下创建pom.xml文件。

添加Spring Boot依赖：

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

配置构建工具版本：

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

Gradle配置：

在项目根目录下创建build.gradle文件。

添加Spring Boot依赖：

dependencies {
 implementation 'org.springframework.boot:spring-boot-starter-web:3.0.5'
}

配置构建工具版本：

plugins {
 id 'org.springframework.boot' version '3.0.5'
 id 'io.spring.dependency-management' version '1.1.0'
}

第一个Spring Boot 3项目

创建Spring Boot项目

创建项目：使用IDE创建一个新的Spring Boot项目。
选择依赖：在创建项目的过程中，选择web依赖，以创建一个基于Web的应用程序。

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

示例代码

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

实现第一个简单的“Hello World”应用

创建控制器：创建一个简单的控制器，用于响应HTTP请求。
测试应用：启动应用并访问http://localhost:8080，查看结果。

package com.example.demo;

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

@RestController
public class HelloWorldController {

    @GetMapping("/")
    public String helloWorld() {
        return "Hello, World!";
    }
}

示例代码

package com.example.demo;

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

@RestController
public class HelloWorldController {

    @GetMapping("/")
    public String helloWorld() {
        return "Hello, World!";
    }
}

Spring Boot 3核心功能介绍

依赖注入

Spring Boot 3通过Spring框架的依赖注入功能，实现了组件的解耦和管理。依赖注入是Spring框架的核心功能之一，可以将应用程序的组件配置成可测试和可维护的。

示例代码

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class DemoApplication {

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

    @Bean
    public HelloWorldService helloWorldService() {
        return new HelloWorldService();
    }
}

package com.example.demo;

@Service
public class HelloWorldService {

    public String sayHello() {
        return "Hello, injected!";
    }
}

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

    private HelloWorldService helloWorldService;

    @Autowired
    public HelloWorldController(HelloWorldService helloWorldService) {
        this.helloWorldService = helloWorldService;
    }

    @GetMapping("/")
    public String helloWorld() {
        return helloWorldService.sayHello();
    }
}

自动配置

Spring Boot 3通过自动配置功能，为开发者提供了许多默认配置选项。这些配置选项覆盖了常见的应用需求，使得开发者可以快速启动一个应用。例如，当添加spring-boot-starter-web依赖时，Spring Boot会自动配置Tomcat服务器，并提供一个默认的HTTP端口。

示例代码

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

Starter依赖简化

Spring Boot 3通过Starter依赖简化了依赖管理。每个Starter都是一个预定义的依赖集合，包含了开发过程中常用的依赖。例如，spring-boot-starter-web包含了构建Web应用所需的所有依赖。

示例代码

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

Spring Boot 3的常用功能

数据库连接和JPA基础

Spring Boot 3通过JPA（Java Persistence API）简化了数据库操作。JPA提供了对象-关系映射（ORM）功能，使得开发者可以专注于对象模型的定义和操作。

示例代码

package com.example.demo;

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;

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

package com.example.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Bean;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@SpringBootApplication
@EntityScan(basePackages = "com.example.demo")
@EnableJpaRepositories(basePackages = "com.example.demo")
public class DemoApplication {

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

    @Bean
    CommandLineRunner commandLineRunner(UserRepository userRepository) {
        return args -> {
            User user = new User();
            user.setName("John Doe");
            user.setEmail("john.doe@example.com");
            userRepository.save(user);
        };
    }
}

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

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

RESTful API开发

Spring Boot 3提供了丰富的支持，帮助开发者快速开发RESTful API。通过使用Spring MVC和Spring Data JPA，开发者可以轻松地创建CRUD操作。

示例代码

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

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

    private UserRepository userRepository;

    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        List<User> users = userRepository.findAll();
        return ResponseEntity.ok(users);
    }

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

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userRepository.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
    }

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

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

配置文件详解（application.properties和application.yml）

Spring Boot 3支持两种配置文件格式：application.properties和application.yml。开发者可以根据喜好选择使用其中一种。

示例代码

# application.properties
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

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

测试与部署

单元测试与集成测试

Spring Boot 3提供了强大的测试支持，包括单元测试和集成测试。Spring Boot测试框架简化了测试过程，使得开发者可以方便地编写和运行测试。

单元测试示例代码

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

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

@SpringBootTest
public class HelloWorldServiceTest {

    @Autowired
    private HelloWorldService helloWorldService;

    @Test
    public void testSayHello() {
        String result = helloWorldService.sayHello();
        assertEquals("Hello, injected!", result);
    }
}

集成测试示例代码

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest
public class HelloWorldControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testHelloWorld() throws Exception {
        mockMvc.perform(get("/"))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello, World!"));
    }
}

应用打包与部署

打包应用

使用Maven或Gradle打包应用，生成可运行的JAR或WAR文件。

Maven打包示例代码

mvn clean package

Gradle打包示例代码

gradle build

部署应用

将生成的JAR或WAR文件部署到应用服务器或云平台。

部署到本地服务器：
- 将生成的JAR或WAR文件复制到服务器的指定目录。
- 使用命令运行应用：
```
java -jar myapp.jar
```
部署到云平台：
- 使用云平台提供的工具或命令，将应用部署到云服务器。
- 配置应用服务器，确保应用能够正确启动和运行。

示例代码

java -jar target/myapp.jar