Springboot3入门教程：轻松搭建你的第一个Spring Boot项目

概述

Spring Boot是一个基于Spring框架的开源项目，旨在简化应用的搭建和配置过程。本文详细介绍了Spring Boot的核心特点和新特性，并重点介绍了Spring Boot 3的新功能，包括对Java 17的支持和新的HTTP客户端等。

Spring Boot简介

什么是Spring Boot

Spring Boot 是一个基于Spring框架的开源项目，它旨在简化Spring应用的初始搭建以及配置过程。Spring Boot的核心目标是简化Spring应用的开发过程，使开发者能够快速构建独立、生产级别的应用。Spring Boot 通过提供一些默认配置和约定，减少了开发者需要编写的配置代码量，使得开发过程更加便捷。

Spring Boot的核心特点

• 约定优于配置：Spring Boot 使用了许多默认配置，使得开发者可以专注于功能实现，而不是每个细节的配置。
• 自动配置：Spring Boot 可以自动配置常见的开发场景，例如数据库连接、安全设置等。
• 内嵌Web服务器：Spring Boot 可以内嵌Web服务器（如Tomcat、Jetty、Undertow），使得应用可以直接运行，而无需部署到外部容器。
• 无需web.xml：Spring Boot 项目中不再需要传统的web.xml配置文件。
• 嵌入式Servlet容器：支持Tomcat、Jetty、Undertow等嵌入式的Servlet容器。
• 起步依赖：通过Spring Boot Starter项目，快速引入所需的依赖。
• 命令行接口：提供了简单易用的命令行接口，便于管理应用。
• 外部化配置：支持多种格式的配置文件，便于修改和管理应用的配置。
• 健康检查：内置了健康检查的功能，便于监控应用的运行状态。

Spring Boot 3的新特性介绍

Spring Boot 3引入了许多新的特性和改进，其中一些关键特性包括：

• Java 17支持：Spring Boot 3 支持Java 17，提升了Java版本的支持。
• 弃用Java 8相关的功能，提供更好的性能：Spring Boot 3不再支持Java 8，推荐使用Java 11及以上版本。

• 新的HTTP客户端：引入了新的HTTP客户端，提供了更高级的功能和更好的性能。例如，可以通过以下配置使用新的HTTP客户端：

  spring.http.decoder.force-plaintext=false

• 新的Spring Data结构：引入了新的Spring Data结构，提升了数据访问能力。例如，一个新的数据访问接口配置如下：

  package com.example.repository;
  
  import org.springframework.stereotype.Repository;
  
  @Repository
  public class UserRepository {
    public String findUserById(int id) {
        // 模拟数据库查询
        return "User " + id;
    }
  }

• 新的安全模块：提供了一个新的安全模块，使得安全配置更加简化。例如，一个简单的安全配置示例如下：

  package com.example.config;
  
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  
  @Configuration
  @EnableWebSecurity
  public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().anyRequest().permitAll();
    }
  }

• 新的API测试工具：提供了新的API测试工具，简化了测试过程。例如，使用Spring Boot的测试支持进行单元测试：

  package com.example;
  
  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;
  
  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 org.springframework.test.web.servlet.ResultActions;
  
  @WebMvcTest
  public class HelloControllerTest {
    @Autowired
    private MockMvc mockMvc;
  
    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        ResultActions response = mockMvc.perform(get("/"));
        response.andExpect(status().isOk());
        response.andExpect(content().string("Hello, World!"));
    }
  }

• 新的构建工具支持：支持新的构建工具，提升了构建速度和效率。例如，Gradle插件配置示例如下：

  plugins {
    id 'org.springframework.boot' version '3.0.0'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
  }
  
  group 'com.example'
  version '0.0.1-SNAPSHOT'
  sourceCompatibility = '17'
  
  repositories {
    mavenCentral()
  }
  
  dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
  }

• 新的启动器：提供了一些新的启动器，使得应用可以快速入门。例如，引入新的Spring Boot Starter依赖：

  implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

• 改进的日志配置：提供了改进的日志配置选项，使得日志管理更加方便。例如，Spring Boot的日志配置可直接通过application.properties文件设置：

  logging.level.root=INFO
  logging.file.path=./logs

• 新的仪表板和监控功能：提供了新的仪表板和监控功能，便于监控应用的运行状态。例如，使用Micrometer进行应用监控：

  package com.example;
  
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.boot.web.client.RestTemplateBuilder;
  import org.springframework.context.annotation.Bean;
  import org.springframework.web.client.RestTemplate;
  
  import io.micrometer.core.instrument.MeterRegistry;
  import io.micrometer.core.instrument.composite.CompositeMeterRegistry;
  
  @SpringBootApplication
  public class DemoApplication {
  
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
  
    @Bean
    public MeterRegistry meterRegistry() {
        return new CompositeMeterRegistry();
    }
  
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder.build();
    }
  }

环境搭建

开发工具的选择和安装

开发工具的选择和安装是开发Spring Boot应用的基础，常见的开发工具包括 IntelliJ IDEA、Eclipse 等。

IntelliJ IDEA

IntelliJ IDEA 是一个功能强大的Java IDE，支持Spring Boot项目的开发。以下是安装步骤：

1. 下载 IntelliJ IDEA：
   访问官网下载页面，下载适合的操作系统版本。

   https://www.jetbrains.com/idea/download/

2. 安装 IntelliJ IDEA：
   按照安装向导完成安装过程。

3. 配置开发环境：
   安装完成后，打开 IntelliJ IDEA，设置相关配置，如主题、字体、插件等。

Eclipse

Eclipse 是一个经典的Java IDE，支持各种Java开发任务，包括Spring Boot项目。

1. 下载 Eclipse：
   访问官网下载页面，下载适合的操作系统版本。

   https://www.eclipse.org/downloads/

2. 安装 Eclipse：
   按照安装向导完成安装过程。

3. 配置开发环境：
   安装完成后，打开 Eclipse，设置相关配置，如主题、字体、插件等。

推荐插件

• Spring Boot 插件：
  该插件提供了Spring Boot项目的支持，包括创建Spring Boot项目、运行Spring Boot应用等。
• Lombok 插件：
  Lombok插件可以帮助你自动添加getter/setter、构造函数等代码，减少样板代码的编写。

Java环境配置

Java环境配置是开发Spring Boot应用的基础。以下是配置步骤：

1. 下载Java JDK：
   访问Oracle官网下载页面，下载适合的操作系统版本。

   https://www.oracle.com/java/technologies/javase-jdk17-downloads.html

2. 安装 Java JDK：
   按照安装向导完成安装过程。

3. 配置环境变量：
   安装完成后，需要配置环境变量，具体步骤如下：

   • Windows：
     • 打开“控制面板” -> “系统和安全” -> “系统” -> “高级系统设置” -> “环境变量”。
     • 在“系统变量”中新建JAVA_HOME，值设为JDK的安装路径，如 C:\Program Files\Java\jdk-17。
     • 修改Path变量，追加 %JAVA_HOME%\bin。
   • Mac/Linux：
     • 使用brew安装JDK：brew install jdk。
     • 配置环境变量：export JAVA_HOME=/usr/local/opt/jdk。
4. 验证安装：
   打开命令行，输入java -version和javac -version，查看是否安装成功。

Maven或Gradle的安装与配置

Maven和Gradle是常用的构建工具，用于管理项目的依赖和构建过程。

Maven

1. 下载 Maven：
   访问Maven官网下载页面，下载适合的操作系统版本。

   https://maven.apache.org/download.cgi

2. 安装 Maven：
   将下载的压缩包解压到指定目录，如 /usr/local/apache-maven。

3. 配置环境变量：

   • Windows：
     • 打开“控制面板” -> “系统和安全” -> “系统” -> “高级系统设置” -> “环境变量”。
     • 在“系统变量”中新建M2_HOME，值设为Maven的安装路径，如 C:\Program Files\apache-maven。
     • 修改Path变量，追加 %M2_HOME%\bin。
   • Mac/Linux：
     • 解压Maven压缩包，将解压后的文件夹放到 /usr/local/apache-maven。
     • 配置环境变量：export M2_HOME=/usr/local/apache-maven，export PATH=$M2_HOME/bin:$PATH。
4. 验证安装：
   打开命令行，输入mvn -version，查看是否安装成功。

Gradle

1. 下载 Gradle：
   访问Gradle官网下载页面，下载适合的操作系统版本。

   https://gradle.org/download/

2. 安装 Gradle：
   将下载的压缩包解压到指定目录，如 /usr/local/gradle。

3. 配置环境变量：

   • Windows：
     • 打开“控制面板” -> “系统和安全” -> “系统” -> “高级系统设置” -> “环境变量”。
     • 在“系统变量”中新建GRADLE_HOME，值设为Gradle的安装路径，如 C:\Program Files\gradle。
     • 修改Path变量，追加 %GRADLE_HOME%\bin。
   • Mac/Linux：
     • 解压Gradle压缩包，将解压后的文件夹放到 /usr/local/gradle。
     • 配置环境变量：export GRADLE_HOME=/usr/local/gradle，export PATH=$GRADLE_HOME/bin:$PATH。
4. 验证安装：
   打开命令行，输入gradle -version，查看是否安装成功。

创建Spring Boot项目

使用Spring Initializr快速创建项目

Spring Initializr 是一个在线工具，可以帮助你快速创建Spring Boot项目。以下是步骤：

1. 访问 Spring Initializr 网站：

   https://start.spring.io/

2. 选择项目配置：

   • Project：选择Maven Project或Gradle Project。
   • Language：选择Java。
   • Spring Boot：选择版本，推荐使用最新版本。
   • Project Metadata：填写Group、Artifact、Name、Description等信息。
   • Packaging：选择jar或war。
   • Dependencies：选择所需的依赖，如Spring Web、Spring Data JPA等。

3. 生成项目：
   点击右下角的Generate按钮，生成压缩包。

4. 解压并导入项目：
   解压生成的压缩包，导入到IDE中，如 IntelliJ IDEA 或 Eclipse。

示例代码

以下是使用Spring Initializr生成的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>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>17</java.version>
    </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-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>

手动创建Spring Boot项目

手动创建Spring Boot项目需要手动配置Maven或Gradle文件，并添加Spring Boot依赖。

Maven项目

1. 创建目录结构：

   src
   ├── main
   │   ├── java
   │   │   └── com.example
   │   │       └── DemoApplication.java
   │   └── resources
   └── pom.xml

2. 编写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>demo</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <name>demo</name>
      <description>Demo project for Spring Boot</description>
      <properties>
          <java.version>17</java.version>
      </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-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>

3. 编写DemoApplication.java文件：

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

Gradle项目

1. 创建目录结构：

   src
   ├── main
   │   ├── java
   │   │   └── com.example
   │   │       └── DemoApplication.java
   │   └── resources
   └── build.gradle

2. 编写build.gradle文件：

   plugins {
      id 'org.springframework.boot' version '3.0.0'
      id 'io.spring.dependency-management' version '1.1.0'
      id 'java'
   }
   
   group 'com.example'
   version '0.0.1-SNAPSHOT'
   sourceCompatibility = '17'
   
   repositories {
      mavenCentral()
   }
   
   dependencies {
      implementation 'org.springframework.boot:spring-boot-starter-web'
      testImplementation 'org.springframework.boot:spring-boot-starter-test'
   }

3. 编写DemoApplication.java文件：

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

导入项目到IDE中

导入项目到IDE中是开发和调试Spring Boot应用的必要步骤。

IntelliJ IDEA

1. 打开 IntelliJ IDEA。
2. 导入项目：
   • 选择File -> New -> Project from Existing Sources。
   • 选择项目目录，如 /path/to/project。
3. 等待项目同步：
   • IntelliJ IDEA 会自动检测项目结构，并同步相关配置。

Eclipse

1. 打开 Eclipse。
2. 导入项目：
   • 选择File -> Import -> Existing Projects into Workspace。
   • 选择项目目录，如 /path/to/project。
3. 等待项目同步：
   • Eclipse 会自动检测项目结构，并同步相关配置。

第一个Spring Boot应用

编写简单的HelloWorld程序

编写一个简单的HelloWorld程序，验证Spring Boot应用的基本功能。

示例代码

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

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

    @RestController
    public class HelloController {
        @GetMapping("/")
        public String hello() {
            return "Hello, World!";
        }
    }
}

运行和测试你的第一个Spring Boot应用

运行应用，验证是否正常启动并返回预期结果。

1. 启动应用：
   在IDE中运行DemoApplication类的main方法，或使用命令行运行：

   mvn spring-boot:run

2. 访问应用：
   打开浏览器，访问http://localhost:8080，查看返回结果是否为Hello, World!。

Spring Boot开发基础

控制器@Controller的使用

控制器@Controller是Spring Boot中用于处理HTTP请求的关键组件。以下是一个简单的控制器示例：

示例代码

package com.example;

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

@RestController
public class HelloController {
    @GetMapping("/")
    public String hello() {
        return "Hello, World!";
    }

    @GetMapping("/user")
    public String getUserInfo() {
        return "User Information";
    }
}

功能解释

• @RestController：标记该类为控制器类，简化返回JSON数据的处理。
• @GetMapping：标记HTTP GET请求处理方法。

服务@Service的实现

服务@Service是业务逻辑的实现，通常用于封装业务逻辑，实现数据处理、业务逻辑计算等。

示例代码

package com.example.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public String getUserInfo() {
        return "User Information";
    }
}

功能解释

• @Service：标记该类为服务类，用于实现业务逻辑。

数据访问@Repository的使用

数据访问@Repository用于封装数据访问逻辑，如数据库操作、缓存操作等。以下是一个简单的数据访问类示例：

示例代码

package com.example.repository;

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    public String findUserById(int id) {
        // 模拟数据库查询
        return "User " + id;
    }
}

功能解释

• @Repository：标记该类为数据访问类，用于封装数据访问逻辑。

配置@Configuration的设置

配置@Configuration是Spring Boot中用于管理应用配置的关键组件。以下是一个简单的配置类示例：

示例代码

package com.example.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public String getHelloMessage() {
        return "Hello Message";
    }
}

功能解释

• @Configuration：标记该类为配置类，用于管理应用配置。
• @Bean：标记该方法返回的实例为Spring容器管理的Bean。

部署与运行

使用IDE直接运行项目

在开发阶段，通常使用IDE直接运行项目，便于调试和测试。

1. 打开IDE。
2. 运行DemoApplication类的main方法，启动应用。
3. 访问应用，查看是否正常运行。

示例代码

package com.example;

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

打包并部署到Tomcat或Jetty

打包并部署到外部容器（如Tomcat或Jetty）是将应用部署到生产环境的常见方式。

打包步骤

1. 打包项目：
   使用Maven或Gradle打包项目，生成JAR或WAR文件。

   mvn package

   或者使用Gradle：

   ./gradlew bootJar

2. 部署到Tomcat：
   将生成的JAR或WAR文件复制到Tomcat的webapps目录，启动Tomcat，应用将自动部署。

示例代码

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

使用Docker容器化部署

Docker容器化部署是一种现代的部署方式，可以简化部署过程，提高应用的可移植性和可管理性。

Dockerfile示例

FROM openjdk:17-jdk-alpine
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

构建和运行Docker镜像

1. 构建Docker镜像：

   docker build -t my-spring-boot-app .

2. 运行Docker容器：

   docker run -p 8080:8080 my-spring-boot-app

示例代码

# Dockerfile
FROM openjdk:17-jdk-alpine
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

通过以上步骤，你可以轻松地创建、部署和运行一个Spring Boot应用。