🍊
翻译橙
🍊返回主站🤖参与贡献
  • hello,这里是翻译橙
  • spring boot参考文档
    • 1. 法律
    • 2. 寻求帮助
    • 3. 文档概述
    • 4. 入门
    • 5. 升级Spring Boot
    • 6. 使用 Spring Boot 进行开发
      • 6.1. 构建系统
      • 6.2. 构建你的代码
      • 6.3. 配置类
      • 6.4. 自动配置
      • 6.5. Spring Bean 和依赖注入
      • 6.6. 使用@SpringBootApplication注解
      • 6.7. 运行您的应用程序
      • 6.8. 开发者工具
      • 6.9. 打包您的生产应用程序
      • 6.10. 接下来读什么
    • 7.核心特性
      • 7.1. SpringApplication
      • 7.2. 外部化配置
      • 7.3.Profile配置
      • 7.4.日志记录
      • 7.5.国际化
      • 7.6 面向切面的编程
      • 7.7. JSON
      • 7.8. 任务执行与调度
      • 7.9. 单元测试
        • 7.9.1. 测试范围依赖
        • 7.9.2. 测试 Spring 应用程序
        • 7.9.3. 测试 Spring Boot 应用程序
        • 7.9.4. 测试容器
        • 7.9.5. 测试工具
      • 7.10. Docker Compose 支持
      • 7.11. 测试容器支持
      • 7.12. 创建您自己的自动配置
      • 7.13. Kotlin 支持
      • 7.14 SSL
      • 7.15.接下来要读什么
    • 8. 网络
      • 8.1. Servlet Web 应用程序
        • 8.1.1. “Spring Web MVC 框架”
        • 8.1.2. JAX-RS 和Jersey
        • 8.1.3. 嵌入式 Servlet 容器支持
      • 8.2 反应式网络应用程序
        • 8.2.1. “Spring WebFlux 框架”
        • 8.2.2. 嵌入式反应式服务器支持
        • 8.2.3. 反应式服务器资源配置
      • 8.3. 优雅关机
      • 8.4. spring安全
        • 8.4.1. MVC安全
        • 8.4.2. WebFlux 安全
        • 8.4.3. OAuth2
        • 8.4.4. SAML 2.0
      • 8.5. spring 会话
      • 8.6.GraphQL
      • 8.7. Spring HATEOAS
      • 8.8.接下来读什么
    • 9. 数据
      • 9.1. SQL数据库
      • 9.2. 使用 NoSQL 技术
      • 9.3. 接下来读什么
    • 10. 消息
      • 10.1. JMS
      • 10.2. AMQP
      • 10.3. Apache Kafka 支持
      • 10.4. Apache Pulsar 支持
      • 10.5. RSocket
      • 10.6. Spring Integration
      • 10.7. WebSockets
      • 10.8. What to Read Next
    • 11. IO
      • 11.1. 缓存
      • 11.2. Hazelcast
      • 11.3. Quartz 调度程序
      • 11.4. 发送电子邮件
      • 11.5. 验证
      • 11.6. 调用 REST 服务
      • 11.7. web services
      • 11.8. 使用 JTA 进行分布式事务
      • 11.9. 接下来读什么
    • 12. 容器镜像
  • Spring核心功能
    • 1.IOC容器和Bean简介
      • 1.2. 容器概述
      • 1.3. Bean概述
      • 1.4. 依赖项
        • 1.4.1. 依赖注入
        • 1.4.2. 详细的依赖关系和配置
        • 1.4.3. 使用depends-on
        • 1.4.4. 延迟初始化的 Bean
        • 1.4.5. 自动装配协作者
        • 1.4.6. 方法注入
    • 2. Resources
      • 2.1. 介绍
      • 2.2. Resource接口
      • 2.3. 内置Resource实现
      • 2.4. ResourceLoader接口
      • 2.5. ResourcePatternResolver接口
      • 2.6. ResourceLoaderAware接口
      • 2.7. 资源作为依赖
      • 2.8. 应用程序上下文和资源路径
    • 3. 验证、数据绑定和类型转换
      • 3.1. 使用 Spring 的 Validator 接口进行验证
      • 3.2. 将代码解析为错误消息
      • 3.3. Bean 操作和BeanWrapper
      • 3.4. spring类型转换
      • 3.5. spring字段格式
      • 3.6. 配置全局日期和时间格式
      • 3.7. Java Bean 验证
    • 4. SpEL表达式
    • 5. Spring 面向切面编程
      • 5.1. AOP 概念
      • 5.2. Spring AOP 的能力和目标
      • 5.3. AOP 代理
      • 5.4. @AspectJ 支持
        • 5.4.1. 启用@AspectJ 支持
        • 5.4.2. 声明一个切面
        • 5.4.3. 声明切入点
        • 5.4.4. 声明切点
        • 5.4.5. 切面说明
        • 5.4.6. 切面实例化模型
        • 5.4.7. AOP 示例
      • 5.5. 基于模式的 AOP 支持
      • 5.6. 选择要使用的 AOP 声明样式
      • 5.7. 混合切面类型
      • 5.8. 代理机制
      • 5.9. @AspectJ 代理的程序化创建
      • 5.10. 在 Spring 应用程序中使用 AspectJ
      • 5.11.更多资源
    • 6. Spring AOP API
      • 6.1. Spring中的切入点API
      • 6.2. Spring 中的 Advice API
      • 6.3. Spring 中的 Advisor API
      • 6.4. 使用ProxyFactoryBean创建 AOP 代理
      • 6.5. 简洁的代理定义
      • 6.6. 以编程方式创建 AOP 代理ProxyFactory
      • 6.7. 操作切面对象
      • 6.8. 使用“自动代理”工具
      • 6.9. 使用TargetSource实现
      • 6.10. 定义新的切面类型
    • 7. 空指针安全
    • 8. 数据缓冲器和编解码器
    • 9. 日志
    • 10. 附录
      • 10.1. XML 模式
      • 10.2. 自定义XML Schema
        • 10.2.1. 创作 Schema
        • 10.2.2. 编码一个NamespaceHandler
        • 10.2.3. 使用BeanDefinitionParser
        • 10.2.4. 注册处理程序和模式
        • 10.2.5. 在 Spring XML 配置中使用自定义扩展
        • 10.2.6. 更详细的例子
      • 10.3. 应用程序启动步骤
  • 使用redis实现分布式锁
  • Java 安全标准算法名称
  • JDK 9 JEP
  • JDK 10 JEP
  • 人件
    • 《人件》
    • 第一部分 管理人力资源
      • 01 此时此刻,一个项目正在走向失败
      • 02 干酪汉堡,做一个,卖一个
      • 03 维也纳在等你
      • 04 质量——如果时间允许
      • 05 再谈帕金森定律
      • 06 苦杏素
    • 第二部分 办公环境
      • 07 家具警察
      • 08 “朝九晚五在这里啥也完成不了。”
      • 09 在空间上省钱
      • 间奏曲:生产效率度量和不明飞行物
      • 10 大脑时问与身体时间
      • 11 电话
      • 12 门的回归
      • 13 采取保护步骤
    • 第三部分 正确的人
      • 14 霍恩布洛尔因素
      • 15 谈谈领导力
      • 16 雇一名杂耍演员
      • 17 与他人良好合作
      • 18 童年的终结
      • 19 在这儿很开心
      • 20 人力资本
    • 第四部分 高效团队养成
      • 21 整体大于部分之和
      • 22 黑衣团队
      • 23 团队自毁
      • 24 再谈团队自毁
      • 25 竞争
      • 26 一顿意面晚餐
      • 27 敞开和服
      • 28 团队形成的化学反应
    • 第五部分 沃土
      • 29 自我愈复系统
      • 30 与风险共舞
      • 3l 会议、独白和交流
      • 32 终极管理罪恶得主是……
      • 33 “邪恶”电邮
      • 34 让改变成为可能
      • 35 组织型学习
      • 36 构建社区
    • 第六部分 快乐地工作
      • 37 混乱与秩序
      • 38 自由电子
      • 39 霍尔加·丹斯克
由 GitBook 提供支持
在本页

这有帮助吗?

在GitHub上编辑
  1. spring boot参考文档

4. 入门

上一页3. 文档概述下一页5. 升级Spring Boot

最后更新于1年前

这有帮助吗?

如果您正在开始使用 Spring Boot 或一般的“Spring”,请先阅读本节。它回答了基本的“什么?”、“如何?” 和“为什么?” 问题。它包括 Spring Boot 的介绍以及安装说明。然后,我们将引导您构建您的第一个 Spring Boot 应用程序,并讨论一些核心原则。

4.1. Spring Boot 简介

Spring Boot 可帮助您创建可以运行的独立的、生产级的、基于 Spring 的应用程序。我们对 Spring 平台和第三方库采取固执己见的观点,以便您可以轻松上手。大多数 Spring Boot 应用程序只需要很少的 Spring 配置。

您可以使用 Spring Boot 创建可以通过使用java -jar或更传统的 war 部署来启动的 Java 应用程序。

我们的主要目标是:

  • 为所有 Spring 开发提供更快、更广泛的入门体验。

  • 开箱即用,但当需求开始偏离默认值时,要迅速摆脱困境。

  • 提供一系列大型项目通用的非功能特性(例如嵌入式服务器、安全性、指标、运行状况检查和外部化配置)。

  • 绝对没有代码生成(当不针对本机图像时)并且不需要 XML 配置。

4.2. 系统要求

Spring Boot 3.2.0 需要,并且兼容 Java 21(包括 Java 21)。 还需要

为以下构建工具提供显式构建支持:

构建工具

版本

Maven

3.6.3 或更高版本

Gradle

7.x(7.5 或更高版本)和 8.x

4.2.1. Servlet 容器

Spring Boot 支持以下嵌入式 servlet 容器:

姓名

小服务程序版本

Tomcat 10.1

6.0

Jetty 12.0

6.0

Undertow 2.3

6.0

您还可以将 Spring Boot 应用程序部署到任何 servlet 5.0+ 兼容容器。

4.2.2. GraalVM 本机镜像

支持以下版本:

姓名

版本

GraalVM Community

22.3

本机构建工具(Native Build Tools)

0.9.28

4.3. 安装 Spring Boot

$ java -version

4.3.1. Java 开发人员安装说明

您可以像使用任何标准 Java 库一样使用 Spring Boot。为此,请在类路径中包含适当的spring-boot-*.jar文件。Spring Boot 不需要集成任何特殊工具,因此您可以使用任何 IDE 或文本编辑器。此外,Spring Boot 应用程序没有什么特别之处,因此您可以像运行任何其他 Java 程序一样运行和调试 Spring Boot 应用程序。

尽管您可以复制 Spring Boot jar,但我们通常建议您使用支持依赖项管理的构建工具(例如 Maven 或 Gradle)。

Maven安装

Gradle安装

Gradle 包装器

4.3.2. 安装 Spring Boot CLI

Spring Boot CLI(命令行界面)是一个命令行工具,可用于使用 Spring 快速构建原型。

您不需要使用 CLI 来使用 Spring Boot,但它是无需 IDE 即可启动 Spring 应用程序的快速方法。

手动安装

您可以从以下位置之一下载 Spring CLI 发行版:

用SDKMAN安装!

$ sdk install springboot
$ spring --version
Spring CLI v3.2.0

如果您为 CLI 开发功能并希望访问您构建的版本,请使用以下命令:

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-3.2.0-bin/spring-3.2.0/
$ sdk default springboot dev
$ spring --version
Spring CLI v3.2.0

前面的说明安装了一个名为 dev 实例的spring 本地实例。它指向您的目标构建位置,因此每次您重建 Spring Boot 时,spring 都是最新的。

您可以通过运行以下命令来查看它:

$ sdk ls springboot
​
================================================================================
Available Springboot Versions
================================================================================
> + dev
* 3.2.0
​
================================================================================
+ - local version
* - installed
> - currently in use
================================================================================

OSX 自制软件安装

$ brew tap spring-io/tap
$ brew install spring-boot

Homebrew 会安装spring到/usr/local/bin.

如果您没有看到该公式,则您安装的brew 可能已过时。在这种情况下,请运行brew update并重试。

MacPorts安装

$ sudo port install spring-boot-cli

命令行完成

$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
  grab  help  jar  run  test  version

如果您使用 Homebrew 或 MacPorts 安装 Spring Boot CLI,命令行完成脚本将自动注册到您的 shell。

Windows Scoop 安装

> scoop bucket add extras
> scoop install springboot

Scoop 安装spring到~/scoop/apps/springboot/current/bin.

如果您没有看到应用程序清单,则您安装的 scoop 可能已过时。在这种情况下,请运行scoop update并重试。

4.4. 开发您的第一个 Spring Boot 应用程序

本节介绍如何开发一个小型的“Hello World!” Web 应用程序,突出显示了 Spring Boot 的一些关键功能。您可以选择 Maven 或 Gradle 作为构建系统。

4.4.1. 先决条件

在开始之前,打开终端并运行以下命令以确保您安装了有效版本的 Java:

$ java -version
openjdk version "17.0.4.1" 2022-08-12 LTS
OpenJDK Runtime Environment (build 17.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM (build 17.0.4.1+1-LTS, mixed mode, sharing)

该示例需要在其自己的目录中创建。后续说明假定您已创建合适的目录并且它是您的当前目录。

Maven

如果要使用 Maven,请确保已安装 Maven:

$ mvn -v
Apache Maven 3.8.5 (3599d3414f046de2324203b78ddcf9b5e4388aa0)
Maven home: usr/Users/developer/tools/maven/3.8.5
Java version: 17.0.4.1, vendor: BellSoft, runtime: /Users/developer/sdkman/candidates/java/17.0.4.1-librca

Gradle

如果您想使用 Gradle,请确保已安装 Gradle:

$ gradle --version
​
------------------------------------------------------------
Gradle 8.1.1
------------------------------------------------------------
​
Build time:   2023-04-21 12:31:26 UTC
Revision:     1cf537a851c635c364a4214885f8b9798051175b
​
Kotlin:       1.8.10
Groovy:       3.0.15
Ant:          Apache Ant(TM) version 1.10.11 compiled on July 10 2021
JVM:          17.0.7 (BellSoft 17.0.7+7-LTS)
OS:           Linux 6.2.12-200.fc37.aarch64 aarch64

4.4.2. 使用 Maven 设置项目

我们需要首先创建一个 Mavenpom.xml文件。这pom.xml是用于构建项目的配方。打开您最喜欢的文本编辑器并添加以下内容:

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
​
    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>
​
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
    </parent>
​
    <!-- Additional lines to be added here... -->
​
</project>

前面的清单应该为您提供一个工作版本。您可以通过运行来测试它mvn package(目前,您可以忽略“jar将为空 - 没有内容被标记为包含!”警告)。

此时,您可以将项目导入 IDE(大多数现代 Java IDE 都包含对 Maven 的内置支持)。为简单起见,我们在此示例中继续使用纯文本编辑器。

4.4.3. 使用 Gradle 设置项目

我们需要首先创建一个 Gradlebuild.gradle文件。这build.gradle是用于构建项目的构建脚本。打开您最喜欢的文本编辑器并添加以下内容:

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
}
​
apply plugin: 'io.spring.dependency-management'
​
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'
​
repositories {
    mavenCentral()
}
​
dependencies {
}

前面的清单应该为您提供一个工作版本。您可以通过运行来测试它gradle classes。

此时,您可以将项目导入 IDE(大多数现代 Java IDE 都包含对 Gradle 的内置支持)。为简单起见,我们在此示例中继续使用纯文本编辑器。

4.4.4. 添加类路径依赖项

Spring Boot 提供了许多“Starters”,可让您将 jar 添加到类路径中。“Starters”提供了开发特定类型的应用程序时可能需要的依赖项。

Maven

由于我们正在开发一个 Web 应用程序,因此我们添加了一个spring-boot-starter-web依赖项。在此之前,我们可以通过运行以下命令来查看当前拥有的内容:

$ mvn dependency:tree
​
[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn dependency:tree命令打印项目依赖项的树表示。您可以看到spring-boot-starter-parent本身不提供依赖项。要添加必要的依赖项,请编辑pom.xml并添加spring-boot-starter-web紧邻该部分下方的依赖项parent:

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

如果再次运行mvn dependency:tree,您会发现现在有许多额外的依赖项,包括 Tomcat Web 服务器和 Spring Boot 本身。

Gradle

由于我们正在开发一个 Web 应用程序,因此我们添加了一个spring-boot-starter-web依赖项。在此之前,我们可以通过运行以下命令来查看当前拥有的内容:

$ gradle dependencies
​
> Task :dependencies
​
------------------------------------------------------------
Root project 'myproject'
------------------------------------------------------------

gradle dependencies命令打印项目依赖项的树表示。目前,该项目没有依赖项。要添加必要的依赖项,请编辑您build.gradle的依赖项并在dependencies部分中添加spring-boot-starter-web依赖项:

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

如果再次运行gradle dependencies,您会发现现在有许多额外的依赖项,包括 Tomcat Web 服务器和 Spring Boot 本身。

4.4.5. 编写代码

为了完成我们的应用程序,我们需要创建一个 Java 文件。默认情况下,Maven 和 Gradle 从src/main/java编译源代码,因此您需要创建该目录结构,然后添加一个名为src/main/java/MyApplication.java包含以下代码的文件:

package com.example;
​
@RestController
@SpringBootApplication
public class MyApplication {
​
    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }
​
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
​
}

虽然这里没有太多代码,但已经做了很多事情。我们将在接下来的几节中逐步介绍重要部分。

@RestController 和 @RequestMapping 注解

我们类的第一个注释MyApplication是@RestController. 这称为构造型注释。它为阅读代码的人提供提示,并为 Spring 提供该类扮演特定角色的提示。在本例中,我们的类是一个 web @Controller,因此 Spring 在处理传入的 Web 请求时会考虑它。

@RequestMapping注释提供“路由”信息。它告诉 Spring 任何具有该/路径的 HTTP 请求都应该映射到home方法。@RestController注释告诉 Spring 将结果字符串直接渲染回调用者。

@SpringBootApplication 注解

第二个类级注释是@SpringBootApplication。该注释称为元注释,它结合了@SpringBootConfiguration,@EnableAutoConfiguration和@ComponentScan。

其中,我们最感兴趣的注释是@EnableAutoConfiguration. @EnableAutoConfiguration告诉 Spring Boot 根据您添加的 jar 依赖项“猜测”您想要如何配置 Spring。由于spring-boot-starter-web添加了 Tomcat 和 Spring MVC,自动配置假定您正在开发 Web 应用程序并相应地设置 Spring。

启动器和自动配置

自动配置旨在与“初学者”很好地配合,但这两个概念并不直接相关。您可以自由选择启动程序之外的 jar 依赖项。Spring Boot 仍然尽力自动配置您的应用程序。

“main”方法

我们应用程序的最后一部分是main方法。这是遵循 Java 应用程序入口点约定的标准方法。我们的 main 方法通过调用run委托给 Spring Boot 的SpringApplication类。 SpringApplication引导我们的应用程序,启动 Spring,进而启动自动配置的 Tomcat Web 服务器。我们需要将MyApplication.class作为参数传递给该run方法来让SpringApplication判断哪个是主要的 Spring 组件。args数组也会被传递以公开任何命令行参数。

4.4.6. 运行示例

Maven

此时,您的应用程序应该可以运行。由于您使用了spring-boot-starter-parentPOM,您就有了一个可以用来启动应用程序的有用run目标。从根项目目录键入mvn spring-boot:run以启动应用程序。您应该看到类似于以下内容的输出:

$ mvn spring-boot:run
​
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.0)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)

如果您打开 Web 浏览器localhost:8080,您应该看到以下输出:

你好世界!

要正常退出应用程序,请按ctrl-c。

Gradle

此时,您的应用程序应该可以运行。由于您使用了org.springframework.bootGradle 插件,您就有了一个可以用来启动应用程序的有用bootRun目标。从根项目目录键入gradle bootRun以启动应用程序。您应该看到类似于以下内容的输出:

$ gradle bootRun
​
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.0)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)

如果您打开 Web 浏览器localhost:8080,您应该看到以下输出:

你好世界!

要正常退出应用程序,请按ctrl-c。

4.4.7. 创建可执行 Jar

我们通过创建一个可以在生产中运行的完全独立的可执行 jar 文件来完成我们的示例。可执行 jar(有时称为“uber jar”或“fat jar”)是包含已编译类以及代码运行所需的所有 jar 依赖项的档案。

可执行 jar 和 Java

Java 不提供加载嵌套 jar 文件(本身包含在 jar 中的 jar 文件)的标准方法。如果您希望分发独立的应用程序,这可能会出现问题。

为了解决这个问题,许多开发人员使用“uber”jar。uber jar 将所有应用程序依赖项中的所有类打包到一个存档中。这种方法的问题是很难看出应用程序中有哪些库。如果在多个 jar 中使用相同的文件名(但内容不同),也可能会出现问题。

gradle bootRun

要创建可执行 jar,我们需要将其添加spring-boot-maven-plugin到我们的pom.xml. 为此,请在该dependencies部分下方插入以下行:

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

保存pom.xml并从命令行运行mvn package,如下所示:

$ mvn package
​
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:3.2.0:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果您查看目录target,您应该会看到myproject-0.0.1-SNAPSHOT.jar. 文件大小应约为 18 MB。如果你想查看内部,可以使用jar tvf,如下所示:

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

您还应该在target目录中看到一个更小的文件myproject-0.0.1-SNAPSHOT.jar.original。这是 Maven 在被 Spring Boot 重新打包之前创建的原始 jar 文件。

要运行该应用程序,请使用java -jar以下命令:

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
​
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.0)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

和以前一样,要退出应用程序,请按ctrl-c。

Gradle

要创建可执行 jar,我们需要从命令行运行gradle bootJar,如下所示:

$ gradle bootJar
​
BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed

如果您查看build/libs目录,您应该会看到myproject-0.0.1-SNAPSHOT.jar. 文件大小应约为 18 MB。如果你想查看内部,可以使用jar tvf,如下所示:

$ jar tvf build/libs/myproject-0.0.1-SNAPSHOT.jar

要运行该应用程序,请使用java -jar以下命令:

$ java -jar build/libs/myproject-0.0.1-SNAPSHOT.jar
​
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.0)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

和以前一样,要退出应用程序,请按ctrl-c。

4.5. 接下来读什么

Spring Boot 应用程序可以使用 GraalVM 22.3 或更高版本转换为 。

可以使用Gradle/Maven 插件或GraalVM 提供的native-image工具来创建映像。创建本机映像。

Spring Boot 可以与“经典”Java 开发工具一起使用,也可以作为命令行工具安装。无论哪种方式,您都需要或更高版本。在开始之前,您应该使用以下命令检查当前的 Java 安装:

如果您是 Java 开发新手或者想要尝试 Spring Boot,您可能需要首先尝试(命令行界面)。否则,请继续阅读“经典”安装说明。

Spring Boot 与 Apache Maven 3.6.3 或更高版本兼容。如果您尚未安装 Maven,可以按照上的说明进行操作。

在许多操作系统上,Maven 可以通过包管理器安装。如果您使用 OSX Homebrew,请尝试brew install maven. Ubuntu 用户可以运行sudo apt-get install maven. 的 Windows 用户可以choco install maven从提升的(管理员)提示符下运行。

Spring Boot 依赖项使用组 IDorg.springframework.boot。通常,您的 Maven POM 文件继承自spring-boot-starter-parent项目并声明对一个或多个的依赖关系。Spring Boot 还提供了一个可选的来创建可执行 jar。

有关 Spring Boot 和 Maven 入门的更多详细信息,请参阅Maven 插件参考指南的

Spring Boot 与 Gradle 7.x(7.5 或更高版本)和 8.x 兼容。如果您尚未安装 Gradle,您可以按照上的说明进行操作。

Spring Boot 依赖项可以使用org.springframework.boot group. 通常,您的项目会声明对一个或多个的依赖关系。Spring Boot 提供了一个有用的,可用于简化依赖项声明并创建可执行 jar。

当您需要构建项目时,Gradle Wrapper 提供了一种“获取”Gradle 的好方法。它是一个小脚本和库,您可以将其与代码一起提交以引导构建过程。有关详细信息,请参阅。

有关 Spring Boot 和 Gradle 入门的更多详细信息,请参阅Gradle 插件参考指南的

下载后,按照解压存档中的总之,.zip文件的 bin/ 目录中有一个 spring 脚本(Windows 下为 spring.bat)。或者,您可以将java -jar与.jar文件一起使用(该脚本可帮助您确保类路径设置正确)。

SDKMAN!(软件开发工具包管理器)可用于管理各种二进制 SDK 的多个版本,包括 Groovy 和 Spring Boot CLI。从获取 SDKMAN!并使用以下命令安装 Spring Boot:

如果您使用的是 Mac 并使用,则可以使用以下命令安装 Spring Boot CLI:

如果您使用的是 Mac 并使用,则可以使用以下命令安装 Spring Boot CLI:

Spring Boot CLI 也包含为和 shell 提供命令完成的脚本。您可以在任何 shell 中获取该脚本(也称为spring),或者将其放入您的个人或系统范围的 bash 完成初始化中。,或者将其放入您的个人或系统范围的 bash 完成初始化中。在 Debian 系统上,系统范围的脚本位于其中,<installation location>/shell-completion/bash并且在新 shell 启动时执行该目录中的所有脚本。例如,如果您已使用 SDKMAN! 安装,则要手动运行脚本,请使用以下命令:

如果您在 Windows 上并使用,则可以使用以下命令安装 Spring Boot CLI:

spring.io网站包含许多使用 Spring Boot 的入门”如果您需要解决特定问题,请先检查那里。并从依赖项搜索器中选择“Web”启动器来快捷执行以下步骤。这样做会生成一个新的项目结构,以便您可以。查看了解更多详细信息。

大多数 Spring Boot 应用程序在POM的parent 部分中使用spring-boot-starter-parent。spring-boot-starter-parent是一个特殊的启动器,提供有用的 Maven 默认值。它还提供了一个部分,以便您可以省略依赖项的version标签。

大多数 Spring Boot 应用程序都使用org.springframework.boot Gradle 插件。该插件提供有用的默认值和 Gradle 任务。io.spring.dependency-managementGradle插件提供,以便您可以省略依赖项的version标签。

@RestController和@RequestMapping注释是 Spring MVC 注释(它们不特定于 Spring Boot)。有关更多详细信息,请参阅Spring 参考文档中的

Spring Boot 采用了,让您可以直接嵌套 jar。

spring-boot-starter-parentPOM包含绑定repackage目标的<executions>配置。如果不使用父POM,则需要自己声明此配置。有关详细信息,请参阅。

希望本节提供了一些 Spring Boot 基础知识,并帮助您编写自己的应用程序。如果您是面向任务的开发人员,您可能想跳到并遵循一些指南来解决特定的“如何使用 Spring 做到这一点?” 问题。我们还有 Spring Boot 特定的“”参考文档。

否则,下一个逻辑步骤是阅读。如果你真的不耐烦,你也可以直接阅读。

Java 17
Spring Framework 6.1.1或更高版本。
Native Image
本机构建工具
您还可以使用本机映像 Paketo buildpack
Java SDK v17
Spring Boot CLI
maven.apache.org
使用Chocolatey
“Starters”
Maven 插件
入门部分。
gradle.org
“Starters”
Gradle 插件
docs.gradle.org/current/userguide/gradle_wrapper.html
入门部分。
spring-boot-cli-3.2.0-bin.zip
spring-boot-cli-3.2.0-bin.tar.gz
INSTALL.txt说明进行操作。
sdkman.io
Homebrew
MacPorts
BASH
zsh
Scoop
“
指南。
您可以通过转至start.spring.io
立即开始编码
start.spring.io 用户指南
dependency-management
依赖项管理
MVC 部分。
不同的方法
插件文档
spring.io
入门
操作方法
使用 Spring Boot 进行开发
Spring Boot 特性